Neues Thema starten
Beantwortet

Inkrementeller TAR-Export

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


Beste Antwort

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);

 


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

Gruß,

Dennis

Antwort

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

Anmelden oder Registrieren um einen Kommentar zu veröffentlichen