Wie HASH Wert eines Anhangs bestimmen ?

[eknori]

Bevor ich mir die Finger selber wundschreibe, wollte ich mal fragen, ob irgendwer einen LS oder C-API Algorithmus parat hat, mit dem man 2 attachments bit-genau vergleichen kann ?

Hintergrund ist, herauszufinden, wie viele gleiche Anhänge in  n  Notes Datenbanken enthalten sind, und wie gross die Ersparnis an Speicherplatz ist, wenn man nur ein zentral gespeichertes attachment hat und alle docs, die diesen Anhang ursprünglich beinhalteten nur darauf referenzieren.

also Dublettenprüfung ...

[m3]

Ev. per MD5? http://www.nsftools.com/tips/NotesTips.htm#lsencryption oder http://wwwendt.de/tech/md5/

[flaite]

Offensichtlich gibt es eigentlich gerade in C sehr viele diff tools.
google: diff ODER diff C++

Das schwierige wäre für mich erst einmal die Domino Daten in eine Struktur zu bringen, um einen Vergleich einfach möglich zu machen.
Vielleicht per xml Dom Api Informationen aus den Domino Dokumenten in eine Verzeichnisstruktur auf die Festplatte schreiben.

Verzeichnis-name: DokUnique ID
a) description.xml -> Datenbankname, Server, UniversalId.
b) Die base64 encodierten Attachments (in dxl vorhanden) als eigene Dateien in das Verzeichnis.

Über die b)s könnte man dann diff-Tools füttern.

Vermutlich nicht wirklich an einen Nachmittag zu erledigen. Wär mein erster Ansatz.

Gruß Axel

[eknori]

ich denke, ich werde es mal hiermit versuchen ( http://www.codeproject.com/cpp/chash.asp )

[eknori]

Fluppt ganz gut mit  der Klasse; jetzt muss ich mal sehen, wie ich das hinbekomme, daß ich die Datei nicht erst detachen muss, sondern den hashWert gleich im Speicher berechnen kann.

Das Ganze könnte man dann in eine DLL packen und die Funktionen dann per DECLARE in LS bekanntmachen; oder wenn man schon eine DLL bastelt, kann man die Funktionen auch per COM zur Verfügung stellen.

Wer es nachbauen möchte, hier der Quellcode.
Das Programm ermittelt die has-werte aller Dateien im LW K:\ und gibt die Werte an der Konsole aus.

/////////////////////////////////////////////////////////////////////////////
// nHash.cpp
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "nHash.h"
#include "CHash.cpp"
#include "SADirRead.cpp"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

/////////////////////////////////////////////////////////////////////////////

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
   int nRetCode = 0;
   
   if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
   {
      nRetCode = 1;
   }
   else
   {
      CSADirRead dr;   
      CString outHash;      

      dr.ClearDirs();
      dr.GetDirs("k:\\", false);
      dr.ClearFiles();        // start clean
      dr.GetFiles("*.*");   // get all  files in k:\\
      CSADirRead::SAFileVector &files = dr.Files();
      CHash hashObj; // Define a CHash object
      hashObj.SetHashAlgorithm(SHA2); // Set the algorithm
      hashObj.SetHashFormat(3);
      hashObj.SetSHA2Strength(512); // Set the SHA-2 strength
      hashObj.SetHashOperation(FILE_HASH); // Set the operation
      
      for (CSADirRead::SAFileVector::const_iterator fit = files.begin(); fit!=files.end(); fit++)
      {
         hashObj.SetHashFile(("%s\n", (*fit).m_sName));    // Set the file
         outHash = hashObj.DoHash(); // HashIt !
         printf(outHash) ;
         std::cout << endl;
      }
   }
   
   return nRetCode;
}

[eknori]

Lustig ist auch, daß man die Reihenfolge der Header Dateien beachten muss

#include "lncppapi.h"
#include "stdafx.h"

umgekehrt gibt es Gemeckertes vom Linker ...

[flaite]

Meine Idee mit den diff-Tools gestern abend war natürlich Quatsch.
Thx. Hash ist das Ding.
Könnte es jetzt nicht u.U. hilfreich sein, das alles in (imho besser) Relationale Tabellen schreiben.
1. Tabelle DocUniqueIDs
PrimKey: id Identity/autoInkrement
VarChar: DocUniqueID
VarChar: DatenbankServer
VarChar: DatenbankPfad

2. Tabelle: AttachmentHashs
PrimKey: id identity/autoInkrement
long: idDocUniqueID (fremdschlüssel auf DocUniqueIDs.id
VarChar: Hash (wie groß sind die Hashs?)

Ich vermute, es gibt nichts bessere als SQL, um die Duplikate in AttachmentHashs.Hash zu finden, in denen Datensatz:AttachmentHashs.idDocUniqueId <> Datensatz:AttachmentHashs.idDocUniqueId.
Geht natürlich auch in einer NotesDatenbank. Nur dürfte das ziemlich lange dauern.

[eknori]

Nein, SQL ist in dem Fall das richtige Medium.

Das Tool soll nicht nur über MailDBs laufen sondern letztendlich auch über das Filesystem. Das das lange dauert, ist mir klar. Mengengerüstmäßig reden wir dann über ein paar Millionen Einträgen in der Datenbank;  da sehe ich bei Notes selber schwarz.

Ich denke, daß man die eigentliche Auswertung in der SQL DB dann einfacher gestalten kann, als das im Coding zu berücksichtigen.

Wir brauchen das Tool übrigens zur Kostenanalyse; rechnet sich die Anschaffung einer Centera ? Wo liegen unsere größten Redundanzen ? Sind es wirklich die doppelt und zehnfach verschickten Firmenpräsentationen in den Mailfiles oder ist die Volumenersparnis auf dem Filesystem vergleichsweise größer.

Insgesamt aber interessant für jeden, der sich mit Redundanzen herumquält ...

P.S. sollte diese Zeilen hier jemand von pro-clients lesen; ich weiß, daß ihr ein solches Tool im Angebot habt.

[flaite]

ich probier jetzt direkt mal aus in meine mySql 5.000.000 Einträge zu kloppen und guck mal was passiert.

[flaite]

zur Zeit ca. 0.050 sek pro insert.
4991000to go
brauch jetzt mein eclipse wieder.
Sah aber bis 4973000to go stabil aus. Blieb ungefähr bei 0.05 sec.
Kein Bulk-Insert (der wesentlich schneller ist).

[eknori]

Habe jetzt mal eine einfach DLL erstellt, die auch nur eine Funktion enthält

In LS wird die function so deklariert:

Declare Function GetHash Lib "filehash" (Byval strFileName As String ) As String

Der Aufruft erfolgt dann über

Sub Click(Source As Button)
   Msgbox GetHash ("e:\nstart.exe")
End Sub

Der Rückgabewert ist vom Typ String und liefert einen SHA2Strength(512) Wert zurück.
In der DLL sind diese Dinge momentan noch fest verdrahtet.
Das wird sich aber noch ändern. 

Betrachtet die DLL einfach als kleines Spielzeug für zwischendurch.

Hier der source code der DLL

/*
DLL filehash.dll
 */

#include "CHash.cpp"

extern "C"

{
   extern _declspec(dllexport)
      char *GetHash ( char *fileName );
   
   char *GetHash ( char *fileName )
   {

      try
      {
         
         CHash hashObj; // Define a CHash object

         /* Set the algorithm
         */
         hashObj.SetHashAlgorithm(SHA2);

         /* Set hash format
         */
         hashObj.SetHashFormat(3);

         /* Set the SHA-2 strength
         */
         hashObj.SetSHA2Strength(512);

         /* Set the operation   
         */
         hashObj.SetHashOperation(FILE_HASH);

         /* Set the file
         */
         hashObj.SetHashFile(fileName);    
         
         /* Now HashIt !   
         */
         CString outHash;
         outHash = hashObj.DoHash();
      
         /*convert CString to char 
         */
         char * hash_char= new char[outHash.GetLength()+1];
         strcpy(hash_char, outHash);
      
         /* return hash_char      
         */
         return hash_char;      
      }
      
      catch(...)
      {
         return "ERROR";
      }
   }
   
}

Und mit ein bisschen LS drumherum kann man sehr schön herausfinden, wie viele echte Dubletten eines Anhangs sich z.B. in der Maildatei befinden. ( übrigens 9 sec für eine Datei von 150MB über eim 100Mbit Netz )...

Kleine Anmerkung:
Der Quellcode ist hier natürlich nicht vollständig angebildet und so auch nicht kompilierbar. Ich weiss auch, daß man DLLs in CPP anders aufbauen kann; brauche hier aber keinen MFC support. Außerdem bleibt das auch für einen Anfänger in der dargestellten Form nachvollziehbar.

und hier die DLL zum Download ( ins System32 Verzeichnis der Win Installation kopieren )

[flaite]

Das ist natürlich noch besser.
Bin mir aber nicht sicher, ob du die x.000.000 Hashs und DocUniques alle im Speicher halten kannst (weil zu viel und zu groß)?
Wenn du die nirgendwo zwischenspeichern willst, mußt du die im Speicher halten?
Ich weiss es nicht.
Nur so am Rande: Man könnte es auch in Java machen.