xmlhelp/source/com/sun/star/help/HelpIndexer.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: HelpIndexer.java,v $
  10  * $Revision: 1.21 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 package com.sun.star.help;
  32
  33 import com.sun.star.lib.uno.helper.WeakBase;
  34 import com.sun.star.lang.XServiceInfo;
  35 import com.sun.star.script.XInvocation;
  36 import com.sun.star.beans.XIntrospectionAccess;
  37 import com.sun.star.uno.AnyConverter;
  38 import com.sun.star.uno.XComponentContext;
  39
  40 import java.io.FileInputStream;
  41 import java.io.FileOutputStream;
  42 import java.util.Arrays;
  43 import java.util.HashSet;
  44 import java.util.List;
  45 import java.util.zip.ZipEntry;
  46 import java.util.zip.ZipOutputStream;
  47 import java.util.zip.CRC32;
  48 import org.apache.lucene.analysis.standard.StandardAnalyzer;
  49 import org.apache.lucene.analysis.cjk.CJKAnalyzer;
  50 import org.apache.lucene.analysis.Analyzer;
  51 import org.apache.lucene.index.IndexWriter;
  52
  53 import java.io.File;
  54 import java.io.FileNotFoundException;
  55 import java.io.IOException;
  56 import java.util.Date;
  57
  58 public class HelpIndexer extends WeakBase
  59     implements XServiceInfo, XInvocation
  60 {
  61     static private final String __serviceName =
  62         "com.sun.star.help.HelpIndexer";
  63     static private final String aCreateIndexMethodName = "createIndex";
  64
  65     public HelpIndexer()
  66     {
  67     }
  68
  69     public HelpIndexer(XComponentContext xCompContext)
  70     {
  71     }
  72
  73     /**
  74      * @param args the command line arguments
  75      */
  76     public static void main( String[] args )
  77     {
  78         boolean bExtensionMode = false;
  79         mainImpl( args, bExtensionMode );
  80     }
  81
  82     private static void mainImpl( String[] args, boolean bExtensionMode )
  83     {
  84         String aDirToZipStr = "";
  85         String aSrcDirStr = "";
  86         String aLanguageStr = "";
  87         String aModule = "";
  88         String aTargetZipFileStr = "";
  89
  90         // Scan arguments
  91         boolean bLang = false;
  92         boolean bMod = false;
  93         boolean bZipDir = false;
  94         boolean bSrcDir = false;
  95         boolean bOutput = false;
  96
  97         int nArgCount = args.length;
  98         for( int i = 0 ; i < nArgCount ; i++ )
  99         {
 100             if( "-lang".equals(args[i]) )
 101             {
 102                 if( i + 1 < nArgCount )
 103                 {
 104                     aLanguageStr = args[i + 1];
 105                     bLang = true;
 106                 }
 107                 i++;
 108             }
 109             else if( "-mod".equals(args[i]) )
 110             {
 111                 if( i + 1 < nArgCount )
 112                 {
 113                     aModule = args[i + 1];
 114                     bMod = true;
 115                 }
 116                 i++;
 117             }
 118             else if( "-zipdir".equals(args[i]) )
 119             {
 120                 if( i + 1 < nArgCount )
 121                 {
 122                     aDirToZipStr = args[i + 1];
 123                     bZipDir = true;
 124                 }
 125                 i++;
 126             }
 127             else if( "-srcdir".equals(args[i]) )
 128             {
 129                 if( i + 1 < nArgCount )
 130                 {
 131                     aSrcDirStr = args[i + 1];
 132                     bSrcDir = true;
 133                 }
 134                 i++;
 135             }
 136             else if( "-o".equals(args[i]) )
 137             {
 138                 if( i + 1 < nArgCount )
 139                 {
 140                     aTargetZipFileStr = args[i + 1];
 141                     bOutput = true;
 142                 }
 143                 i++;
 144             }
 145         }
 146
 147         if( !bLang || !bMod || !bZipDir || (!bOutput && !bExtensionMode) )
 148         {
 149             if( bExtensionMode )
 150                 return;
 151
 152             System.out.println("Usage: HelpIndexer -lang ISOLangCode -mod HelpModule -zipdir TempZipDir -o OutputZipFile");
 153             System.exit( -1 );
 154         }
 155
 156         String aIndexDirName = aModule + ".idxl";
 157         File aIndexDir = new File( aDirToZipStr + File.separator + aIndexDirName );
 158         if( !bSrcDir )
 159             aSrcDirStr = aDirToZipStr;
 160         File aCaptionFilesDir = new File( aSrcDirStr + File.separator + "caption" );
 161         File aContentFilesDir = new File( aSrcDirStr + File.separator + "content" );
 162
 163         try
 164         {
 165             Date start = new Date();
 166             Analyzer analyzer = aLanguageStr.equals("ja") ? (Analyzer)new CJKAnalyzer() : (Analyzer)new StandardAnalyzer();
 167             IndexWriter writer = new IndexWriter( aIndexDir, analyzer, true );
 168             if( !bExtensionMode )
 169                 System.out.println( "Lucene: Indexing to directory '" + aIndexDir + "'..." );
 170             int nRet = indexDocs( writer, aModule, bExtensionMode, aCaptionFilesDir, aContentFilesDir );
 171             if( nRet != -1 )
 172             {
 173                 if( !bExtensionMode )
 174                 {
 175                     System.out.println();
 176                     System.out.println( "Optimizing ..." );
 177                 }
 178                 writer.optimize();
 179             }
 180             writer.close();
 181
 182             if( bExtensionMode )
 183             {
 184                 if( !bSrcDir )
 185                 {
 186                     deleteRecursively( aCaptionFilesDir );
 187                     deleteRecursively( aContentFilesDir );
 188                 }
 189             }
 190             else
 191             {
 192                 if( nRet == -1 )
 193                     deleteRecursively( aIndexDir );
 194
 195                 if( !bExtensionMode )
 196                     System.out.println( "Zipping ..." );
 197                 File aDirToZipFile = new File( aDirToZipStr );
 198                 createZipFile( aDirToZipFile, aTargetZipFileStr );
 199                 deleteRecursively( aDirToZipFile );
 200             }
 201
 202             Date end = new Date();
 203             if( !bExtensionMode )
 204                 System.out.println(end.getTime() - start.getTime() + " total milliseconds");
 205         }
 206         catch (IOException e)
 207         {
 208             if( bExtensionMode )
 209                 return;
 210
 211             System.out.println(" caught a " + e.getClass() +
 212                 "\n with message: " + e.getMessage());
 213             System.exit( -1 );
 214         }
 215     }
 216
 217     private static int indexDocs(IndexWriter writer, String aModule, boolean bExtensionMode,
 218         File aCaptionFilesDir, File aContentFilesDir) throws IOException
 219     {
 220         if( !aCaptionFilesDir.canRead() || !aCaptionFilesDir.isDirectory() )
 221         {
 222             if( !bExtensionMode )
 223                 System.out.println( "Not found: " + aCaptionFilesDir );
 224             return -1;
 225         }
 226         if( !aContentFilesDir.canRead() || !aContentFilesDir.isDirectory() )
 227         {
 228             if( !bExtensionMode )
 229                 System.out.println( "Not found: " + aContentFilesDir );
 230             return -1;
 231         }
 232
 233         String[] aCaptionFiles = aCaptionFilesDir.list();
 234         List aCaptionFilesList = Arrays.asList( aCaptionFiles );
 235         HashSet aCaptionFilesHashSet = new HashSet( aCaptionFilesList );
 236
 237         String[] aContentFiles = aContentFilesDir.list();
 238         List aContentFilesList = Arrays.asList( aContentFiles );
 239         HashSet aContentFilesHashSet = new HashSet( aContentFilesList );
 240
 241         // Loop over caption files and find corresponding content file
 242         if( !bExtensionMode )
 243             System.out.println( "Indexing, adding files" );
 244         int nCaptionFilesLen = aCaptionFiles.length;
 245         for( int i = 0 ; i < nCaptionFilesLen ; i++ )
 246         {
 247             String aCaptionFileStr = aCaptionFiles[i];
 248             File aCaptionFile = new File( aCaptionFilesDir, aCaptionFileStr );
 249             File aContentFile = null;
 250             if( aContentFilesHashSet.contains( aCaptionFileStr ) )
 251                 aContentFile = new File( aContentFilesDir, aCaptionFileStr );
 252
 253             if( !bExtensionMode )
 254                 System.out.print( "." );
 255             writer.addDocument( HelpFileDocument.Document( aModule, aCaptionFile, aContentFile ) );
 256         }
 257
 258         // Loop over content files to find remaining files not mapped to caption files
 259         int nContentFilesLen = aContentFiles.length;
 260         for( int i = 0 ; i < nContentFilesLen ; i++ )
 261         {
 262             String aContentFileStr = aContentFiles[i];
 263             if( !aCaptionFilesHashSet.contains( aContentFileStr ) )
 264             {
 265                 // Not already handled in caption files loop
 266                 File aCaptionFile = null;
 267                 File aContentFile = new File( aContentFilesDir, aContentFileStr );
 268                 if( !bExtensionMode )
 269                     System.out.print( "." );
 270                 writer.addDocument( HelpFileDocument.Document( aModule, aCaptionFile, aContentFile ) );
 271             }
 272         }
 273         return 0;
 274     }
 275
 276     public static void createZipFile( File aDirToZip, String aTargetZipFileStr )
 277             throws FileNotFoundException, IOException
 278     {
 279         FileOutputStream fos = new FileOutputStream( aTargetZipFileStr );
 280         ZipOutputStream zos = new ZipOutputStream( fos );
 281
 282         File[] aChildrenFiles = aDirToZip.listFiles();
 283         int nFileCount = aChildrenFiles.length;
 284         for( int i = 0 ; i < nFileCount ; i++ )
 285             addToZipRecursively( zos, aChildrenFiles[i], null );
 286
 287         zos.close();
 288     }
 289
 290     public static void addToZipRecursively( ZipOutputStream zos, File aFile, String aBasePath )
 291             throws FileNotFoundException, IOException
 292     {
 293         if( aFile.isDirectory() )
 294         {
 295             String aDirName = aFile.getName();
 296             if( aDirName.equalsIgnoreCase( "caption" ) || aDirName.equalsIgnoreCase( "content" ) )
 297                 return;
 298
 299             File[] aChildrenFiles = aFile.listFiles();
 300             String aNewBasePath = "";
 301             if( aBasePath != null )
 302                 aNewBasePath += aBasePath + File.separator;
 303             aNewBasePath += aDirName;
 304
 305             int nFileCount = aChildrenFiles.length;
 306             for( int i = 0 ; i < nFileCount ; i++ )
 307                 addToZipRecursively( zos, aChildrenFiles[i], aNewBasePath );
 308
 309             return;
 310         }
 311
 312         // No directory
 313         // read contents of file we are going to put in the zip
 314         int fileLength = (int) aFile.length();
 315         FileInputStream fis = new FileInputStream( aFile );
 316         byte[] wholeFile = new byte[fileLength];
 317         int bytesRead = fis.read( wholeFile, 0, fileLength );
 318         fis.close();
 319
 320         String aFileName = aFile.getName();
 321         String aEntryName = "";
 322         if( aBasePath != null )
 323             aEntryName += aBasePath + "/";
 324         aEntryName += aFileName;
 325         ZipEntry aZipEntry = new ZipEntry( aEntryName );
 326         aZipEntry.setTime( aFile.lastModified() );
 327         aZipEntry.setSize( fileLength );
 328
 329         int nMethod = ( aFileName.toLowerCase().endsWith( ".jar" ) )
 330                 ? ZipEntry.STORED : ZipEntry.DEFLATED;
 331         aZipEntry.setMethod( nMethod );
 332
 333         CRC32 tempCRC = new CRC32();
 334         tempCRC.update( wholeFile, 0, wholeFile.length );
 335         aZipEntry.setCrc( tempCRC.getValue() );
 336
 337         // write the contents into the zip element
 338         zos.putNextEntry( aZipEntry );
 339         zos.write( wholeFile, 0, fileLength );
 340         zos.closeEntry();
 341     }
 342
 343     static public boolean deleteRecursively( File aFile )
 344     {
 345         if( aFile.isDirectory() )
 346         {
 347             File[] aChildrenFiles = aFile.listFiles();
 348             int nFileCount = aChildrenFiles.length;
 349             for( int i = 0 ; i < nFileCount ; i++ )
 350             {
 351                 File aChildrenFile = aChildrenFiles[i];
 352                 boolean bSuccess = deleteRecursively( aChildrenFile );
 353                 if( !bSuccess )
 354                     return false;
 355             }
 356         }
 357
 358         return aFile.delete();
 359     }
 360
 361     //===================================================
 362     // XInvocation
 363     public XIntrospectionAccess getIntrospection()
 364     {
 365         return  null;
 366     }
 367
 368     public Object invoke( String aFunctionName, java.lang.Object[] aParams,
 369         short[][] aOutParamIndex, java.lang.Object[][] aOutParam )
 370             throws      com.sun.star.lang.IllegalArgumentException,
 371                     com.sun.star.script.CannotConvertException,
 372                     com.sun.star.reflection.InvocationTargetException
 373     {
 374         if( !aFunctionName.equals( aCreateIndexMethodName  ) )
 375             throw new com.sun.star.lang.IllegalArgumentException();
 376
 377         aOutParamIndex[0] = new short[0];
 378         aOutParam[0] = new Object[0];
 379
 380         int nParamCount = aParams.length;
 381         String aStrs[] = new String[nParamCount];
 382         for( int i = 0 ; i < nParamCount ; i++ )
 383         {
 384             try
 385             {
 386                 aStrs[i] = AnyConverter.toString( aParams[i] );
 387             }
 388             catch( IllegalArgumentException e )
 389             {
 390                 aStrs[i] = "";
 391             }
 392         }
 393
 394         boolean bExtensionMode = true;
 395         mainImpl( aStrs, bExtensionMode );
 396
 397         return null;
 398     }
 399
 400     public void setValue( String aPropertyName, java.lang.Object aValue )
 401         throws  com.sun.star.beans.UnknownPropertyException,
 402                 com.sun.star.script.CannotConvertException,
 403                 com.sun.star.reflection.InvocationTargetException
 404     {
 405         throw new com.sun.star.beans.UnknownPropertyException();
 406     }
 407
 408     public Object getValue( String aPropertyName )
 409         throws com.sun.star.beans.UnknownPropertyException
 410     {
 411         throw new com.sun.star.beans.UnknownPropertyException();
 412     }
 413
 414     public boolean hasMethod( String aMethodName )
 415     {
 416         boolean bRet = (aMethodName.equals( aCreateIndexMethodName ) );
 417         return bRet;
 418     }
 419     public boolean hasProperty( String aName ) {
 420         return false;
 421     }
 422
 423
 424     /** This method returns an array of all supported service names.
 425      * @return Array of supported service names.
 426      */
 427     public String[] getSupportedServiceNames()
 428     {
 429         return getServiceNames();
 430     }
 431
 432     /** This method is a simple helper function to used in the
 433      * static component initialisation functions as well as in
 434      * getSupportedServiceNames.
 435      */
 436     public static String[] getServiceNames()
 437     {
 438         String[] sSupportedServiceNames = { __serviceName };
 439         return sSupportedServiceNames;
 440     }
 441
 442     /** This method returns true, if the given service will be
 443      * supported by the component.
 444      * @param sServiceName Service name.
 445      * @return True, if the given service name will be supported.
 446      */
 447     public boolean supportsService( String sServiceName )
 448     {
 449         return sServiceName.equals( __serviceName );
 450     }
 451
 452     /** Return the class name of the component.
 453      * @return Class name of the component.
 454      */
 455     public String getImplementationName()
 456     {
 457         return  HelpIndexer.class.getName();
 458     }
 459 }
 460