Gastro-MIS GmbH

Hallo zusammen,

ich hänge aktuell noch beim inkrementellen TAR-Export. Der "normale" Full-Export (worm_export_tar) klappt ohne Probleme, allerdings nicht der inkrementelle (worm_export_tar_incremental).

Definiert habe ich die Funktion und den Callback wie folgt: 

TWormExportTarIncrementalCallback = function(chunk: PBytes; chunkLength: Cardinal; processedBlocks: DWORD; totalBlocks: DWORD; callbackData: PBytes): Integer; stdcall;

TWorm_export_tar_incremental = function(context: Pointer; lastState: PAnsiChar; lastStateSize: Integer; newState: PByteArray; newStateSize: Integer; var firstSignatureCounter: UInt64; var lastSignatureCounter: UInt64; callback: TWormExportTarIncrementalCallback; callbackData: Pointer): Integer; stdcall;

 Der Aufruf ist dann wie folgt: 

var
  data: TBytes;
  fs: TFileStream;
  oldState: PAnsiChar;
  newState: PByteArray;
  firstSignatureCounter: UInt64;
  lastSignatureCounter: UInt64;
begin
  SetLength(data, 0);
  GetMem(newState, 16);

  oldState := '';

  Result := worm_export_tar_incremental(context, oldState, Length(oldState), newState, 16,
    firstSignatureCounter, lastSignatureCounter, exportTarIncrementalCallback, @data);

Als Result kriege ich immer "WORM_ERROR_INVALID_PARAMETER". 

Hat jemand eine Idee was ich machen muss, damit das funktioniert?

Danke für die Hilfe,

Dennis Glittenberg

Perfekt, das hat mir sehr geholfen. Großes Danke!

Gruß,

Dennis

bei mir läuft das mit dem Export so:

function exportTSE(Filename: String; Typ: TWormExportFilterTyp = kein; Von: Worm_UInt = 0; Bis: Worm_UInt = 0; Incremental: Boolean = False): Boolean;
var
  Data, LastState, NewState: TBytes;
  PNewState, PLastState: PBytes;
  SaveNewState: Boolean;
  fs: TFileStream;
  WE: WormError;
  lastStateSize: Int32;
  firstSignatureCounter, lastSignatureCounter: PUInt64;
  i: Integer;
begin
  WE := WORM_ERROR_NOT_DEFINED;
  try
    SetLength(data, 0);
    try
      if not Incremental then
      begin
        case Typ of
          kein: WE := worm_export_tar(PWormContext, @WormExportTarCallBack, @Data);
          Zeit: WE := worm_export_tar_filtered_time(PWormContext, Von, Bis, PWormClientID, @WormExportTarCallBack, @Data);
          Transaktionen: WE := worm_export_tar_filtered_transaction(PWormContext, Von, Bis, PWormClientID, @WormExportTarCallBack, @Data);
        end;
      end else
      begin
        if FileExists('lastIncExpState.sv') then
          LastState := TFile.ReadAllBytes('lastIncExpState.sv')
        else
          LastState := nil;
        PLastState := Pointer(LastState);
        if PLastState = nil then
          lastStateSize := 0
        else
          lastStateSize := WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE;
        SetLength(NewState, WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE);
        PNewState := Pointer(NewState);
        firstSignatureCounter := nil;
        lastSignatureCounter := nil;
        WE := worm_export_tar_incremental(PWormContext, PLastState, lastStateSize, PNewState, WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE, firstSignatureCounter, lastSignatureCounter, @WormExportTarIncrementalCallback, @Data);
        if Length(NewState) > 0 then
        begin
          SaveNewState := False;
          for i := Low(NewState) to High(NewState) do
            if NewState[i] > 0 then
            begin
              SaveNewState := True;
              break;
            end;
          if SaveNewState then
            TFile.WriteAllBytes('lastIncExpState.sv', NewState);
        end;
        SetLength(LastState, 0);
        SetLength(NewState, 0);
      end;
      if Length(Data) > 0 then
      begin
        fs := TFileStream.Create(Filename, fmCreate);
        fs.WriteBuffer(Data, Length(Data));
        fs.Free;
      end;
    finally
      SetLength(Data, 0);
      Result := (WE = WORM_ERROR_NOERROR);
    end;
  except
    Result := False;
  end;
end;

 kein Integer, sondern Int32:

WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE: Int32 = 16;

 und der Context zur Sicherheit:

PWormContext: PIntPtr;
...
WE := worm_init(PWormContext, PWormMountPoint);

Danke nochmal für deine Hilfe. Trotzdem kriege ich bisher immer nur den Fehler "WORM_ERROR_INVALID_PARAMETER " (sowohl mit der stdcall als auch mit cdecl-DLL)

Die Deklaration habe ich jetzt von dir übernommen und mein Aufruf sieht jetzt so aus: 

var
  data: TBytes;
  fs: TFileStream;
  firstSignatureCounter: PUInt64;
  lastSignatureCounter: PUInt64;
  PLastState: PBytes;
  lastStateSize: Integer;
  PNewState: PBytes;
const
  WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE = 16;
begin
  Assert(@worm_export_tar_incremental <> nil, 'Function not found: worm_export_tar_incremental');

  SetLength(data, 0);

  Result := worm_export_tar_incremental(context, PLastState, lastStateSize, PNewState,
    WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE, firstSignatureCounter, lastSignatureCounter,
    @exportTarIncrementalCallback, @Data);

  if (Result = 0) and (Length(data) > 0) then
  begin
    fs := TFileStream.Create(filename, fmCreate);
    fs.WriteBuffer(data, Length(data));
    fs.Free;
  end;

Wie initialisierst du die Variablen? Siehst du vielleicht irgendwelche anderen Fehler?

Gruß,

Dennis

Achja, und der Aufruf selber:

WE := worm_export_tar_incremental(PWormContext, PLastState, lastStateSize, PNewState, WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE, firstSignatureCounter, lastSignatureCounter, @WormExportTarIncrementalCallback, @Data);

 wobei WORM_EXPORT_TAR_INCREMENTAL_STATE_SIZE : const = 16

Hallo,

PIntPtr = ^IntPTR;

weiters

TWormExportTarIncrementalCallback = function(chunk: PBytes; chunkLength: Cardinal; processedBlocks: UInt32; totalBlocks: UInt32; callbackData: PBytes): Integer; cdecl;

 und

function WormExportTarIncrementalCallback(const chunk: PBytes; chunkLength: Cardinal; processedBlocks: UInt32; totalBlocks: UInt32; callbackData: PBytes): Integer; cdecl;

 und dann im Aufruf:

function worm_export_tar_incremental(Context: PIntPtr; const lastState: PBytes; lastStateSize: Int32; newState: PBytes; newStateSize: Int32; out firstSignatureCounter: PUInt64; out lastSignatureCounter: PUInt64; callback: TWormExportTarIncrementalCallback; callbackData: Pointer): WormError; cdecl; external WormDLL;

function WormExportTarIncrementalCallback(const chunk: PBytes; chunkLength: Cardinal; processedBlocks: UInt32; totalBlocks: UInt32; callbackData: PBytes): Integer; cdecl;
var
  L: Integer;
begin
  Result := 0;
  try
    L := Length(callbackData^);
    SetLength(callbackData^, L + Integer(chunkLength));
    Move(chunk^, callbackData^[L], chunkLength);
  except
    Result := 1;
  end;
end;

Wie hast du du denn PIntPtr definiert? 
Und wie ist dein Aufruf von der Funktion?

Danke für deine Hilfe,

Dennis

meine callback ist ziemlich identisch:

function WormExportTarIncrementalCallback(const chunk: PBytes; chunkLength: Cardinal; processedBlocks: UInt32; totalBlocks: UInt32; callbackData: PBytes): Integer; cdecl;

meine funktion ist leicht anders definiert:

function worm_export_tar_incremental(Context: PIntPtr; const lastState: PBytes; lastStateSize: Int32; newState: PBytes; newStateSize: Int32; out firstSignatureCounter: PUInt64; out lastSignatureCounter: PUInt64; callback: TWormExportTarIncrementalCallback; callbackData: Pointer): WormError; cdecl; external WormDLL;

 Grüße

Hans