Lotus Notes
Lotus Notes TIPS
Tips rund um Lotus Notes
Domino Entwicklungen

Domino Counter:

http://www.rhizomatics.co.uk/software/domcount.html/odyframe.htm

Bücker

http://www.bueckergmbh.de/
http://www.lotusnotesdomino.de/
http://www.brainit.net/

Knowledgbase

http://www.techdci.com/tdci/corpinfo.nsf
http://noteslinks.com/

Redbooks
ftp://www.redbooks.ibm.com/redbooks/
http://redbooks.ibm.com

Installation und Starten des Servers unter suse 9.0 mit Lotus Domino 6.5 nicht möglich.

Lösungsweg: wir haben diesem Tipp befolgt:

I modified the file
/home/notes/.profile

add the following line:
export PATH=$PATH:/opt/lotus/bin
export LD_ASSUME_KERNEL=2.4.0

und es hat funktioniert - eigenes Risiko

Für die Javaprobleme verweisen wir in der Datei

/opt/lotus/notes/latest/linux

die serversetup - Datei manipuliert und den Pfad für das Java geändert:

echo ./java -ss512k -Xoss5M -cp "jhall.jar:cfgdomserver.jar:Notes.jar" lotus.domino.setup.WizardManagerDomino $datapath $1 $2 $3 $4 $5 $6 $7 $8 $9
/usr/java/j2re1.4.2_01/bin/java -ss512k -Xoss5M -cp "jhall.jar:cfgdomserver.jar:Notes.jar" lotus.domino.setup.WizardManagerDomino $datapath $1 $2 $3 $4 $5 $6 $7 $8 $9




Lotus Notes cannot restart anymore


Autor: http://www.eknori.de

Wer kennt das nicht. Der Notes Client ist mal wieder abgestürzt und läßt sich nun beim besten Willen nicht mehr zu einem Neustart bewegen. Schuld daran sind Prozesse, die nach einem Absturz im Speicher verbleiben und den Neustart verhindern.
Zwar gibt es bereits Tools auf dem Markt, die einem aus diesem Dilemma heraushelfen können. Aber in den meisten Fällen müssen diese Tools erst installiert und nach einem Crash erst aufgerufen werden.
Daher habe ich dieses Tool (nkill.exe)geschrieben. Es läßt sich über eine Batch Datei vor dem Start des Notes Client starten.
c:\Notes\nkill.exe
c:\Notes\notes.exe


Für die Interessierten habe ich den Quelltext beigefügt. Das Tool lauft unter Win9.x/WinME/Win NT 3.x/Win NT 4.0/ Win 2000 und XP
 nkill.zip (24 kB)    psapi.dll (29 kB)
#include <windows.h>
#include <tlhelp32.h>
#include <iostream.h>
#include <string.h>
#ifdef BORLANDC
  #include <string.h>
  #include <ctype.h>
#endif
int KILL_PROC_BY_NAME(const char *);
int main(int argc,char *argv[])
{
  int iRes;
    char string[] = "ldapsearch.exe, nadminp.exe, naldaemn.exe, namgr.exe, napdaemn.exe, nchronos.exe, ncollect.exe, nconvert.exe, ndiiop.exe, ndyncfg.exe, nhldaemn.exe, nhttp.exe, nhttpcgi.exe, nimapcl.exe, nlnotes.exe, nlogasio.exe, nminder.exe, nnntpcl.exe, nnotesmm.exe, stringn.exe, npop3.exe, nupdall.exe, nupdate.exe, nweb.exe, nwrdaemn.exe, nxpcdmn.exe, rtfcnvt.exe, CLHAP32.EXE, ntaskldr.exe";
    char separator[] = ",";
    char *token;
    token = strtok(string, separator); 
    while( token != NULL )
    {
    iRes=KILL_PROC_BY_NAME(token);
    cout << token << " Result code=" << iRes << endl;    
      token = strtok(NULL, separator);
    }
  return 0;
}
int KILL_PROC_BY_NAME(const char *szToTerminate)
//   Return codes are as follows:
//   0   = Process was successfully terminated
//   603 = Process was not currently running
//   604 = No permission to terminate process
//   605 = Unable to load PSAPI.DLL
//   602 = Unable to terminate process for some other reason
//   606 = Unable to identify system type
//   607 = Unsupported OS
//   632 = Invalid process name
//   700 = Unable to get procedure address from PSAPI.DLL
//   701 = Unable to get process list, EnumProcesses failed
//   702 = Unable to load KERNEL32.DLL
//   703 = Unable to get procedure address from KERNEL32.DLL
//   704 = CreateToolhelp32Snapshot failed
{
  BOOL bResult,bResultm;
  DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
  DWORD iCbneeded,i,iFound=0;
  char szName[MAX_PATH],szToTermUpper[MAX_PATH];
  HANDLE hProc,hSnapShot,hSnapShotm;
  OSVERSIONINFO osvi;
    HINSTANCE hInstLib;
  int iLen,iLenP,indx;
    HMODULE hMod;
  PROCESSENTRY32 procentry;      
  MODULEENTRY32 modentry;
  iLenP=strlen(szToTerminate);
  if(iLenP<1 || iLenP>MAX_PATH) return 632;
  for(indx=0;indx<iLenP;indx++)
    szToTermUpper[indx]=toupper(szToTerminate[indx]);
  szToTermUpper[iLenP]=0;
     // PSAPI Function Pointers.
     BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
     BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,
        DWORD, LPDWORD );
     DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,
        LPTSTR, DWORD );
      // ToolHelp Function Pointers.
      HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
      BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
      BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;
  // First check what version of Windows we're in
  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    bResult=GetVersionEx(&osvi);
  if(!bResult)     // Unable to identify system version
      return 606;
  if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
    (osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
    return 607;
    if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
  {
         hInstLib = LoadLibraryA("PSAPI.DLL");
         if(hInstLib == NULL)
            return 605;
         // Get procedure addresses.
         lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))
            GetProcAddress( hInstLib, "EnumProcesses" ) ;
         lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,
            DWORD, LPDWORD)) GetProcAddress( hInstLib,
            "EnumProcessModules" ) ;
         lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,
            LPTSTR, DWORD )) GetProcAddress( hInstLib,
            "GetModuleBaseNameA" ) ;
         if(lpfEnumProcesses == NULL ||
            lpfEnumProcessModules == NULL ||
            lpfGetModuleBaseName == NULL)
            {
               FreeLibrary(hInstLib);
               return 700;
            }
     
    bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
    if(!bResult)
    {
      // Unable to get process list, EnumProcesses failed
            FreeLibrary(hInstLib);
      return 701;
    }
    // How many processes are there?
    iNumProc=iCbneeded/sizeof(DWORD);
    // Get and match the name of each process
    for(i=0;i<iNumProc;i++)
    {
      // Get the (module) name for this process
          strcpy(szName,"Unknown");
      // First, get a handle to the process
          hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,
        aiPID[i]);
          // Now, get the process name
          if(hProc)
      {
               if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
         {
                  iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
         }
      }
          CloseHandle(hProc);
      // We will match regardless of lower or upper case
#ifdef BORLANDC
            if(strcmp(strupr(szName),szToTermUpper)==0)
#else
      if(strcmp(_strupr(szName),szToTermUpper)==0)
#endif
      {
        // Process found, now terminate it
        iFound=1;
        // First open for termination
        hProc=OpenProcess(PROCESS_TERMINATE,FALSE,aiPID[i]);
        if(hProc)
        {
          if(TerminateProcess(hProc,0))
          {
            // process terminated
            CloseHandle(hProc);
                        FreeLibrary(hInstLib);
            return 0;
          }
          else
          {
            // Unable to terminate process
            CloseHandle(hProc);
                        FreeLibrary(hInstLib);
            return 602;
          }
        }
        else
        {
          // Unable to open process for termination
                    FreeLibrary(hInstLib);
          return 604;
        }
      }
    }
  }
  if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
  {
    // Win/95 or 98 or ME
      
    hInstLib = LoadLibraryA("Kernel32.DLL");
    if( hInstLib == NULL )
      return 702;
    lpfCreateToolhelp32Snapshot=
      (HANDLE(WINAPI *)(DWORD,DWORD))
      GetProcAddress( hInstLib,
      "CreateToolhelp32Snapshot" ) ;
    lpfProcess32First=
      (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
      GetProcAddress( hInstLib, "Process32First" ) ;
    lpfProcess32Next=
      (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
      GetProcAddress( hInstLib, "Process32Next" ) ;
    lpfModule32First=
      (BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
      GetProcAddress( hInstLib, "Module32First" ) ;
    lpfModule32Next=
      (BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
      GetProcAddress( hInstLib, "Module32Next" ) ;
    if( lpfProcess32Next == NULL ||
      lpfProcess32First == NULL ||
        lpfModule32Next == NULL ||
      lpfModule32First == NULL ||
      lpfCreateToolhelp32Snapshot == NULL )
    {
      FreeLibrary(hInstLib);
      return 703;
    }
      
    hSnapShot = lpfCreateToolhelp32Snapshot(
      TH32CS_SNAPPROCESS, 0 ) ;
    if( hSnapShot == INVALID_HANDLE_VALUE )
    {
      FreeLibrary(hInstLib);
      return 704;
    }
    
        // Get the first process' information.
        procentry.dwSize = sizeof(PROCESSENTRY32);
        bResult=lpfProcess32First(hSnapShot,&procentry);
        // While there are processes, keep looping and checking.
        while(bResult)
        {
        // Get a handle to a Toolhelp snapshot of this process.
        hSnapShotm = lpfCreateToolhelp32Snapshot(
          TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
        if( hSnapShotm == INVALID_HANDLE_VALUE )
      {
        CloseHandle(hSnapShot);
          FreeLibrary(hInstLib);
          return 704;
      }
      // Get the module list for this process
      modentry.dwSize=sizeof(MODULEENTRY32);
      bResultm=lpfModule32First(hSnapShotm,&modentry);
      // While there are modules, keep looping and checking
      while(bResultm)
      {
            if(strcmp(modentry.szModule,szToTermUpper)==0)
        {
            // Process found, now terminate it
            iFound=1;
            // First open for termination
            hProc=OpenProcess(PROCESS_TERMINATE,FALSE,procentry.th32ProcessID);
            if(hProc)
          {
              if(TerminateProcess(hProc,0))
            {
                // process terminated
              CloseHandle(hSnapShotm);
              CloseHandle(hSnapShot);
              CloseHandle(hProc);
                      FreeLibrary(hInstLib);
                return 0;
            }
              else
            {
                // Unable to terminate process
              CloseHandle(hSnapShotm);
              CloseHandle(hSnapShot);
              CloseHandle(hProc);
                      FreeLibrary(hInstLib);
                return 602;
            }
          }
            else
          {
              // Unable to open process for termination
            CloseHandle(hSnapShotm);
            CloseHandle(hSnapShot);
                  FreeLibrary(hInstLib);
              return 604;
          }
        }
        else
        {  // Look for next modules for this process
          modentry.dwSize=sizeof(MODULEENTRY32);
          bResultm=lpfModule32Next(hSnapShotm,&modentry);
        }
      }
      //Keep looking
      CloseHandle(hSnapShotm);
            procentry.dwSize = sizeof(PROCESSENTRY32);
            bResult = lpfProcess32Next(hSnapShot,&procentry);
        }
    CloseHandle(hSnapShot);
  }
  if(iFound==0)
  {
    FreeLibrary(hInstLib);
    return 603;
  }
  FreeLibrary(hInstLib);
  return 0;
}

Script zum Starten und Stoppen eines Dominoservers