Neues Thema starten

TSE Export und Archivieren

 Hallo,

das Beispielprogramm ist wirklich extrem hilfreich.
Für die Export und Archivierungsaufgaben als TARball sind ja leider keine Programmteile/ beispiele zu sehen. Auch die html Doku gibt da wenig her. Wird es da noch etwas geben oder habe ich das nur übersehen?


Vielen Dank

Stefan


3 Personen haben diese Frage

Ich schliesse mich dem Vorredner an.
Insbesondere würden mich die C# DllImports für die Funktionen und das Callback interessieren.

ich füge mal was ein, bekomme aber einen AccessViolation Error im letzten Block:

Snippet

public delegate uint WormExportTarCallback(IntPtr chunk, int chunkLength, ref IntPtr callbackData);
 
[DllImport("WormAPI.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
private static extern int worm_export_tar(IntPtr context, WormExportTarCallback callback, IntPtr callbackData);


Snippet
 using (fs = File.Create("C:\\temp\\test.tar"))
 {
 
 int result = worm_export_tar(worm_context, MyWormExportTarCallback, Ptr);
 if (result != 0)
 {
 }
 }
 
}
 
 
public uint MyWormExportTarCallback(IntPtr chunk, int chunkLength, ref IntPtr callbackData)
{
 
 byte[] array = new byte[chunkLength];
 Marshal.Copy(chunk, array, 0, chunkLength);
 
 fs.Write(array, 0, chunkLength);
 
 //string s = System.Text.Encoding.ASCII.GetString(array, 0, array.Length);
 
 
 
 return 0;
}
vielleicht kann das ja mal jemand ausprobieren.

1 Person gefällt dies

Hallo,

Dein Snippet habe ich nach vb.net übersetzt und es wird eine TAR Datei erstellt (hängt an).
Nun ist die TSE so gut wie leer und ich kann nicht sagen wie es aussieht wenn die voll ist. Ist mein erster Callback...und muss erstmal verstehen wie das funktioniert. Also 1000 Dank für das snippet


Ich habe ein Modul mit den Wormklassen. Im WormAccess habe ich die Deklaration


Public fs As IO.FileStream

Public Delegate Function WormExportTarCallback(ByVal chunk As IntPtr, ByVal chunkLength As Integer, ByRef callbackData As IntPtr) As UInteger

 <DllImport("WormAPI.dll", CallingConvention:=CallingConvention.Cdecl, CharSet:=CharSet.Ansi)>
Private Shared Function worm_export_tar(ByVal context As IntPtr, ByVal callback As WormExportTarCallback, ByVal callbackData As IntPtr) As Integer
End Function


Ebenfalls als Member von WormAccess

Public Function TarStart() As Int32
    Dim ptr As IntPtr
    Dim result As Integer = worm_export_tar(worm_context, AddressOf MyWormExportTarCallback, ptr)
    If result <> 0 Then
       '??? ToDo
   End If
   Return result
End Function

Private Function MyWormExportTarCallback(ByVal chunk As IntPtr, ByVal chunkLength As Integer, ByRef callbackData As IntPtr) As UInteger
    Dim array As Byte() = New Byte(chunkLength - 1) {}
    Marshal.Copy(chunk, array, 0, chunkLength)
    fs.Write(array, 0, chunkLength)
    'TODO
    Return 0
 End Function


Der Aufruf dann zum Test per Button. Referenz auf WormAccess muss vorhanden sein, hier myWorm

myWorm.fs = IO.File.Create("C:\Temp\xyz.tar")
myWorm.TarStart()
myWorm.fs.Close()


Gruß Stefan


ps. könnte etwas mehr los sein im Forum




tar
(31 KB)

1 Person gefällt dies

Ich hänge leider genau an der gleichen Stelle (allerdings in der VB.NET-Varainte) mit AccessViolation-Error  beim Aufruf von worm_eport_tar.

Wer hat dieses Problem bereits lösen können?

hier mein aktueller Code, sowohl für Tar als auch automatisch gleich als ZIP. Es wird eine Variable ulong mTSEExportSize verwendet. Somit gibt es keine Exception mehr am Ende.


Snippet

/// <summary>
 /// exportiere die Daten der TSE in eine TAR-Datei
 /// </summary>
 /// <param name="Filename"></param>
 /// <returns></returns>
 public int TSEExportTAR(string Filename)
 {
 IntPtr Ptr = IntPtr.Zero;
 int result = (int)Top3TSE.BBTSEControlState.WORM_ERROR_EXPORT_FAILED;
 
 try
 {
 File.Delete(Filename);
 }
 catch (Exception)
 {
 }
 
 mTSEExportSize = Info.TarExportSize;
 if (mTSEExportSize > 0)
 {
 try
 {
 using (mTSETarExport = File.Create(Filename))
 {
 
 result = worm_export_tar(worm_context, MyWormExportTarCallback, Ptr);
 }
 mTSETarExport = null;
 }
 catch (Exception)
 {
 
 }
 }
 return result;
 }
 
 /// <summary>
 /// exportiere die Daten der TSE in eine ZIP-Datei, die diese TAR-Datei enthält
 /// </summary>
 /// <param name="Filename"></param>
 /// <returns></returns>
 public int TSEExportZIP(string Filename)
 {
 IntPtr Ptr = IntPtr.Zero;
 int result = (int)Top3TSE.BBTSEControlState.WORM_ERROR_EXPORT_FAILED;
 
 try
 {
 File.Delete(Filename);
 }
 catch (Exception)
 {
 }
 
 mTSEExportSize = Info.TarExportSize;
 if (mTSEExportSize > 0)
 {
 try
 {
 using (var memoryStream = new MemoryStream())
 {
 
 using (var archive = new System.IO.Compression.ZipArchive(memoryStream, ZipArchiveMode.Create, true))
 {
 var demoFile = archive.CreateEntry("tse.tar");
 
 using (var entryStream = demoFile.Open())
 {
 mTSEZIPExport = new BinaryWriter(entryStream);
 result = worm_export_tar(worm_context, MyWormExportTarCallbackZipped, Ptr);
 mTSEZIPExport.Close();
 mTSEZIPExport.Dispose();
 }
 }
 
 // und speichern
 using (var fileStream = new FileStream(Filename, FileMode.Create))
 {
 memoryStream.Position = 0;
 memoryStream.WriteTo(fileStream);
 }
 }
 mTSEZIPExport = null;
 }
 catch (Exception)
 {
 
 }
 }
 return result;
 }
 
 /// <summary>
 /// exportiere die Daten der TSE in eine ZIP-Datei, die diese TAR-Datei enthält
 /// </summary>
 /// <param name="Filename"></param>
 /// <returns></returns>
 public int TSEExportZIPByteStream(out byte[] byteSteam)
 {
 IntPtr Ptr = IntPtr.Zero;
 int result = (int)Top3TSE.BBTSEControlState.WORM_ERROR_EXPORT_FAILED;
 mTSEExportSize = Info.TarExportSize;
 byteSteam = new byte[0];
 
 if (mTSEExportSize > 0)
 {
 try
 {
 using (var memoryStream = new MemoryStream())
 {
 using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
 {
 var demoFile = archive.CreateEntry("tse.tar");
 
 using (var entryStream = demoFile.Open())
 {
 mTSEZIPExport = new BinaryWriter(entryStream);
 result = worm_export_tar(worm_context, MyWormExportTarCallbackZipped, Ptr);
 mTSEZIPExport.Close();
 mTSEZIPExport.Dispose();
 }
 }
 
 byteSteam = memoryStream.ToArray();
 }
 
 mTSEZIPExport = null;
 }
 catch (Exception)
 {
 
 }
 }
 
 return result;
 }
 
 /// <summary>
 /// Callback für den TAR Export
 /// </summary>
 /// <param name="chunk"></param>
 /// <param name="chunkLength"></param>
 /// <param name="callbackData"></param>
 /// <returns></returns>
 public int MyWormExportTarCallback(IntPtr chunk, uint chunkLength, IntPtr callbackData)
 {
 int Len = (int)chunkLength;
 if (mTSEExportSize < chunkLength)
 Len = (int)mTSEExportSize;
 
 byte[] array = new byte[Len];
 Marshal.Copy(chunk, array, 0, Len);
 
 mTSETarExport.Write(array, 0, Len);
 mTSEExportSize -= (UInt64)Len;
 
 if (mTSEExportSize == 0)
 mTSETarExport.Close();
 return 0;
 }
 
 
 /// <summary>
 /// Callback für den ZIP/TAR Export (anderes File-Objekt)
 /// </summary>
 /// <param name="chunk"></param>
 /// <param name="chunkLength"></param>
 /// <param name="callbackData"></param>
 /// <returns></returns>
 public int MyWormExportTarCallbackZipped(IntPtr chunk, uint chunkLength, IntPtr callbackData)
 {
 int Len = (int)chunkLength;
 if (mTSEExportSize < chunkLength)
 Len = (int)mTSEExportSize;
 
 
 byte[] array = new byte[Len];
 Marshal.Copy(chunk, array, 0, Len);
 
 mTSEZIPExport.Write(array, 0, Len);
 mTSEExportSize -= (UInt64)Len;
 
 if (mTSEExportSize == 0)
 mTSEZIPExport.Close();
 return 0;
 }
 

1 Person gefällt dies

Danke schön!!

Ich habe das Problem heute morgen auch gelöst, jedoch ungezippt.

Allerdings weicht gelegentlich meine Größe der exportierten Daten (mehr Bytes) von der Größe der zu expotierenden Daten ab. Aber auch das werde ich noch lösen.

Anmelden oder Registrieren um einen Kommentar zu veröffentlichen