| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| package com.sun.star.help; |
| |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipOutputStream; |
| import java.util.zip.CRC32; |
| import org.apache.lucene.analysis.standard.StandardAnalyzer; |
| import org.apache.lucene.analysis.cjk.CJKAnalyzer; |
| import org.apache.lucene.analysis.Analyzer; |
| import org.apache.lucene.index.IndexWriter; |
| import org.apache.lucene.util.Version; |
| import org.apache.lucene.store.NIOFSDirectory; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.util.Date; |
| |
| /** |
| When this tool is used with long path names on Windows, that is paths which start |
| with \\?\, then the caller must make sure that the path is unique. This is achieved |
| by removing '.' and '..' from the path. Paths which are created by |
| osl_getSystemPathFromFileURL fulfill this requirement. This is necessary because |
| lucene is patched to not use File.getCanonicalPath. See long_path.patch in the lucene |
| module. |
| */ |
| |
| public class HelpIndexerTool |
| { |
| public HelpIndexerTool() |
| { |
| } |
| |
| |
| /** |
| * @param args the command line arguments |
| */ |
| public static void main( String[] args ) |
| { |
| boolean bExtensionMode = false; |
| mainImpl( args, bExtensionMode ); |
| } |
| |
| public static void mainImpl( String[] args, boolean bExtensionMode ) |
| { |
| String aDirToZipStr = ""; |
| String aSrcDirStr = ""; |
| String aLanguageStr = ""; |
| String aModule = ""; |
| String aTargetZipFileStr = ""; |
| String aCfsName = ""; |
| String aSegmentName = ""; |
| |
| // Scan arguments |
| //If this tool is invoked in the build process for extensions help, |
| //then -extension must be set. |
| boolean bExtension = false; |
| boolean bLang = false; |
| boolean bMod = false; |
| boolean bZipDir = false; |
| boolean bSrcDir = false; |
| boolean bOutput = false; |
| boolean bCfsName = false; |
| boolean bSegmentName = false; |
| |
| int nArgCount = args.length; |
| for( int i = 0 ; i < nArgCount ; i++ ) |
| { |
| if( "-extension".equals(args[i]) ) |
| { |
| bExtension = true; |
| } |
| else if( "-lang".equals(args[i]) ) |
| { |
| if( i + 1 < nArgCount ) |
| { |
| aLanguageStr = args[i + 1]; |
| bLang = true; |
| } |
| i++; |
| } |
| else if( "-mod".equals(args[i]) ) |
| { |
| if( i + 1 < nArgCount ) |
| { |
| aModule = args[i + 1]; |
| bMod = true; |
| } |
| i++; |
| } |
| else if( "-zipdir".equals(args[i]) ) |
| { |
| if( i + 1 < nArgCount ) |
| { |
| aDirToZipStr = args[i + 1]; |
| bZipDir = true; |
| } |
| i++; |
| } |
| else if( "-srcdir".equals(args[i]) ) |
| { |
| if( i + 1 < nArgCount ) |
| { |
| aSrcDirStr = args[i + 1]; |
| bSrcDir = true; |
| } |
| i++; |
| } |
| else if( "-o".equals(args[i]) ) |
| { |
| if( i + 1 < nArgCount ) |
| { |
| aTargetZipFileStr = args[i + 1]; |
| bOutput = true; |
| } |
| i++; |
| } |
| else if( "-checkcfsandsegname".equals(args[i]) ) |
| { |
| if( i + 1 < nArgCount ) |
| { |
| aCfsName = args[i + 1] + ".cfs"; |
| bCfsName = true; |
| } |
| i++; |
| if( i + 1 < nArgCount ) |
| { |
| aSegmentName = "segments" + args[i + 1]; |
| bSegmentName = true; |
| } |
| i++; |
| if (!(bCfsName && bSegmentName)) |
| { |
| System.out.println("Usage: HelpIndexer -checkcfsandsegname _0 _3 (2 arguments needed)"); |
| System.exit( -1 ); |
| } |
| } |
| } |
| |
| if( !bLang || !bMod || !bZipDir || (!bOutput && !bExtensionMode && !bExtension) ) |
| { |
| if( bExtensionMode ) |
| return; |
| |
| System.out.println("Usage: HelpIndexer -lang ISOLangCode -mod HelpModule -zipdir TempZipDir -o OutputZipFile"); |
| System.out.println("Usage: HelpIndexer -extension -lang ISOLangCode -mod HelpModule -zipdir PathToLangDir"); |
| System.exit( -1 ); |
| } |
| |
| String aIndexDirName = aModule + ".idxl"; |
| File aIndexDir = new File( aDirToZipStr + File.separator + aIndexDirName ); |
| if( !bSrcDir ) |
| aSrcDirStr = aDirToZipStr; |
| File aCaptionFilesDir = new File( aSrcDirStr + File.separator + "caption" ); |
| File aContentFilesDir = new File( aSrcDirStr + File.separator + "content" ); |
| |
| try |
| { |
| Date start = new Date(); |
| Analyzer analyzer = aLanguageStr.equals("ja") ? (Analyzer)new CJKAnalyzer(Version.LUCENE_29) : (Analyzer)new StandardAnalyzer(Version.LUCENE_29); |
| IndexWriter writer = new IndexWriter( NIOFSDirectory.open(aIndexDir), analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED ); |
| if( !bExtensionMode ) |
| System.out.println( "Lucene: Indexing to directory '" + aIndexDir + "'..." ); |
| int nRet = indexDocs( writer, aModule, bExtensionMode, aCaptionFilesDir, aContentFilesDir ); |
| if( nRet != -1 ) |
| { |
| if( !bExtensionMode ) |
| { |
| System.out.println(); |
| System.out.println( "Optimizing ..." ); |
| } |
| writer.optimize(); |
| } |
| writer.close(); |
| |
| boolean bCfsFileOk = true; |
| boolean bSegmentFileOk = true; |
| if( bCfsName && bSegmentName && !bExtensionMode && nRet != -1 ) |
| { |
| String aCompleteCfsFileName = aDirToZipStr + File.separator + aIndexDirName + File.separator + aCfsName; |
| String aCompleteSegmentFileName = aDirToZipStr + File.separator + aIndexDirName + File.separator + aSegmentName; |
| File aCfsFile = new File( aCompleteCfsFileName ); |
| File aSegmentFile = new File( aCompleteSegmentFileName ); |
| bCfsFileOk = aCfsFile.exists(); |
| bSegmentFileOk = aSegmentFile.exists(); |
| System.out.println( "Checking cfs file " + aCfsName+ ": " + (bCfsFileOk ? "Found" : "Not found") ); |
| System.out.println( "Checking segment file " + aSegmentName+ ": " + (bSegmentFileOk ? "Found" : "Not found") ); |
| } |
| |
| if( bExtensionMode || bExtension) |
| { |
| if( !bSrcDir ) |
| { |
| deleteRecursively( aCaptionFilesDir ); |
| deleteRecursively( aContentFilesDir ); |
| } |
| } |
| else |
| { |
| if( nRet == -1 ) |
| deleteRecursively( aIndexDir ); |
| |
| if( bCfsFileOk && bSegmentFileOk ) |
| System.out.println( "Zipping ..." ); |
| File aDirToZipFile = new File( aDirToZipStr ); |
| createZipFile( aDirToZipFile, aTargetZipFileStr ); |
| deleteRecursively( aDirToZipFile ); |
| } |
| |
| if( !bCfsFileOk ) |
| { |
| System.out.println( "cfs file check failed, terminating..." ); |
| System.exit( -1 ); |
| } |
| |
| if( !bSegmentFileOk ) |
| { |
| System.out.println( "segment file check failed, terminating..." ); |
| System.exit( -1 ); |
| } |
| |
| Date end = new Date(); |
| if( !bExtensionMode ) |
| System.out.println(end.getTime() - start.getTime() + " total milliseconds"); |
| } |
| catch (IOException e) |
| { |
| if( bExtensionMode ) |
| return; |
| |
| System.out.println(" caught a " + e.getClass() + |
| "\n with message: " + e.getMessage()); |
| System.exit( -1 ); |
| } |
| } |
| |
| private static int indexDocs(IndexWriter writer, String aModule, boolean bExtensionMode, |
| File aCaptionFilesDir, File aContentFilesDir) throws IOException |
| { |
| if( !aCaptionFilesDir.canRead() || !aCaptionFilesDir.isDirectory() ) |
| { |
| if( !bExtensionMode ) |
| System.out.println( "Not found: " + aCaptionFilesDir ); |
| return -1; |
| } |
| if( !aContentFilesDir.canRead() || !aContentFilesDir.isDirectory() ) |
| { |
| if( !bExtensionMode ) |
| System.out.println( "Not found: " + aContentFilesDir ); |
| return -1; |
| } |
| |
| String[] aCaptionFiles = aCaptionFilesDir.list(); |
| List aCaptionFilesList = Arrays.asList( aCaptionFiles ); |
| HashSet aCaptionFilesHashSet = new HashSet( aCaptionFilesList ); |
| |
| String[] aContentFiles = aContentFilesDir.list(); |
| List aContentFilesList = Arrays.asList( aContentFiles ); |
| HashSet aContentFilesHashSet = new HashSet( aContentFilesList ); |
| |
| // Loop over caption files and find corresponding content file |
| if( !bExtensionMode ) |
| System.out.println( "Indexing, adding files" ); |
| int nCaptionFilesLen = aCaptionFiles.length; |
| for( int i = 0 ; i < nCaptionFilesLen ; i++ ) |
| { |
| String aCaptionFileStr = aCaptionFiles[i]; |
| File aCaptionFile = new File( aCaptionFilesDir, aCaptionFileStr ); |
| File aContentFile = null; |
| if( aContentFilesHashSet.contains( aCaptionFileStr ) ) |
| aContentFile = new File( aContentFilesDir, aCaptionFileStr ); |
| |
| if( !bExtensionMode ) |
| System.out.print( "." ); |
| writer.addDocument( HelpFileDocument.Document( aModule, aCaptionFile, aContentFile ) ); |
| } |
| |
| // Loop over content files to find remaining files not mapped to caption files |
| int nContentFilesLen = aContentFiles.length; |
| for( int i = 0 ; i < nContentFilesLen ; i++ ) |
| { |
| String aContentFileStr = aContentFiles[i]; |
| if( !aCaptionFilesHashSet.contains( aContentFileStr ) ) |
| { |
| // Not already handled in caption files loop |
| File aCaptionFile = null; |
| File aContentFile = new File( aContentFilesDir, aContentFileStr ); |
| if( !bExtensionMode ) |
| System.out.print( "." ); |
| writer.addDocument( HelpFileDocument.Document( aModule, aCaptionFile, aContentFile ) ); |
| } |
| } |
| return 0; |
| } |
| |
| public static void createZipFile( File aDirToZip, String aTargetZipFileStr ) |
| throws FileNotFoundException, IOException |
| { |
| FileOutputStream fos = new FileOutputStream( aTargetZipFileStr ); |
| ZipOutputStream zos = new ZipOutputStream( fos ); |
| |
| File[] aChildrenFiles = aDirToZip.listFiles(); |
| int nFileCount = aChildrenFiles.length; |
| for( int i = 0 ; i < nFileCount ; i++ ) |
| addToZipRecursively( zos, aChildrenFiles[i], null ); |
| |
| zos.close(); |
| } |
| |
| public static void addToZipRecursively( ZipOutputStream zos, File aFile, String aBasePath ) |
| throws FileNotFoundException, IOException |
| { |
| if( aFile.isDirectory() ) |
| { |
| String aDirName = aFile.getName(); |
| if( aDirName.equalsIgnoreCase( "caption" ) || aDirName.equalsIgnoreCase( "content" ) ) |
| return; |
| |
| File[] aChildrenFiles = aFile.listFiles(); |
| String aNewBasePath = ""; |
| if( aBasePath != null ) |
| aNewBasePath += aBasePath + File.separator; |
| aNewBasePath += aDirName; |
| |
| int nFileCount = aChildrenFiles.length; |
| for( int i = 0 ; i < nFileCount ; i++ ) |
| addToZipRecursively( zos, aChildrenFiles[i], aNewBasePath ); |
| |
| return; |
| } |
| |
| // No directory |
| // read contents of file we are going to put in the zip |
| int fileLength = (int) aFile.length(); |
| FileInputStream fis = new FileInputStream( aFile ); |
| byte[] wholeFile = new byte[fileLength]; |
| int bytesRead = fis.read( wholeFile, 0, fileLength ); |
| fis.close(); |
| |
| String aFileName = aFile.getName(); |
| String aEntryName = ""; |
| if( aBasePath != null ) |
| aEntryName += aBasePath + "/"; |
| aEntryName += aFileName; |
| ZipEntry aZipEntry = new ZipEntry( aEntryName ); |
| aZipEntry.setTime( aFile.lastModified() ); |
| aZipEntry.setSize( fileLength ); |
| |
| int nMethod = ( aFileName.toLowerCase().endsWith( ".jar" ) ) |
| ? ZipEntry.STORED : ZipEntry.DEFLATED; |
| aZipEntry.setMethod( nMethod ); |
| |
| CRC32 tempCRC = new CRC32(); |
| tempCRC.update( wholeFile, 0, wholeFile.length ); |
| aZipEntry.setCrc( tempCRC.getValue() ); |
| |
| // write the contents into the zip element |
| zos.putNextEntry( aZipEntry ); |
| zos.write( wholeFile, 0, fileLength ); |
| zos.closeEntry(); |
| } |
| |
| static public boolean deleteRecursively( File aFile ) |
| { |
| if( aFile.isDirectory() ) |
| { |
| File[] aChildrenFiles = aFile.listFiles(); |
| int nFileCount = aChildrenFiles.length; |
| for( int i = 0 ; i < nFileCount ; i++ ) |
| { |
| File aChildrenFile = aChildrenFiles[i]; |
| boolean bSuccess = deleteRecursively( aChildrenFile ); |
| if( !bSuccess ) |
| return false; |
| } |
| } |
| |
| return aFile.delete(); |
| } |
| } |
| |
