Examples of org.apache.lucene.store.IndexInput

org.apache.lucene.store.IndexInput
Abstract base class for input from a file in a {@link Directory}. A random-access input stream. Used for all Lucene index input operations. @see Directory

  /**
   * Copy the contents of the file with specified extension into the provided
   * output stream.
   */
  private void copyFile(FileEntry source, IndexOutput os) throws IOException {
    IndexInput is = source.dir.openInput(source.file);
    try {
      long startPtr = os.getFilePointer();
      long length = is.length();
      os.copyBytes(is, length);


      if (checkAbort != null) {
        checkAbort.work(length);
      }


      // Verify that the output length diff is equal to original file
      long endPtr = os.getFilePointer();
      long diff = endPtr - startPtr;
      if (diff != length)
        throw new IOException("Difference in the output file offsets " + diff
            + " does not match the original file length " + length);


    } finally {
      is.close();
    }
  }

View Full Code Here

  }


  byte[] buffer = new byte[4096];


  private void readFile(Directory dir, String name) throws Exception {
    IndexInput input = dir.openInput(name);
    try {
      long size = dir.fileLength(name);
      long bytesLeft = size;
      while (bytesLeft > 0) {
        final int numToRead;
        if (bytesLeft < buffer.length)
          numToRead = (int) bytesLeft;
        else
          numToRead = buffer.length;
        input.readBytes(buffer, 0, numToRead, false);
        bytesLeft -= numToRead;
      }
      // Don't do this in your real backups!  This is just
      // to force a backup to take a somewhat long time, to
      // make sure we are exercising the fact that the
      // IndexWriter should not delete this file even when I
      // take my time reading it.
      Thread.sleep(1);
    } finally {
      input.close();
    }
  }

View Full Code Here

            return false;
        }


        byte[] buf = new byte[BUFFER_SIZE];


        IndexInput is = null;
        IndexOutput os = null;


        try
        {
            is = source.openInput( srcName );


            os = target.createOutput( targetName );


            // and copy to dest directory
            long len = is.length();
            long readCount = 0;
            while ( readCount < len )
            {
                int toRead = readCount + BUFFER_SIZE > len ? (int) ( len - readCount ) : BUFFER_SIZE;
                is.readBytes( buf, 0, toRead );
                os.writeBytes( buf, toRead );
                readCount += toRead;
            }


            return true;

View Full Code Here

            Date result = null;
            try
            {
                if ( directory.fileExists( TIMESTAMP_FILE ) )
                {
                    IndexInput ii = null;


                    try
                    {
                        ii = directory.openInput( TIMESTAMP_FILE );


                        result = new Date( ii.readLong() );
                    }
                    finally
                    {
                        close( ii );
                    }

View Full Code Here

    {
        ZipEntry e = new ZipEntry( name );


        zos.putNextEntry( e );


        IndexInput in = directory.openInput( name );


        try
        {
            int toRead = 0;


            int bytesLeft = (int) in.length();


            while ( bytesLeft > 0 )
            {
                toRead = ( bytesLeft >= buf.length ) ? buf.length : bytesLeft;
                bytesLeft -= toRead;


                in.readBytes( buf, 0, toRead, false );


                zos.write( buf, 0, toRead );
            }
        }
        finally

View Full Code Here


      final int FILE_SIZE = 1000;
      assert BUFFER_SIZE < FILE_SIZE;
      createFileWithRepeatableContent(dir, "RandomSampleFile.txt", FILE_SIZE);


      IndexInput indexInput = dir.openInput("RandomSampleFile.txt", IOContext.DEFAULT);
      assert indexInput.length() == FILE_SIZE;
      RepeatableLongByteSequence bytesGenerator = new RepeatableLongByteSequence();


      Random r = new Random();
      long seekPoint = 0;
      // Now it reads some random byte and it compares to the expected byte
      for (int i = 0; i < FILE_SIZE; i++) {
         if (seekPoint == i) {
            byte expectedByte = bytesGenerator.nextByte();
            byte actualByte = indexInput.readByte();
            assert expectedByte == actualByte;
            seekPoint = indexInput.getFilePointer() + r.nextInt(10);
            indexInput.seek(seekPoint);
         } else {
            bytesGenerator.nextByte();
         }


      }
      indexInput.close();
      dir.close();
      DirectoryIntegrityCheck.verifyDirectoryStructure(cache, INDEXNAME);
   }

View Full Code Here

    *           The length of byte array to read
    * @throws IOException
    */
   private void assertReadBytesWorkingCorrectly(Directory dir, String fileName,
            final int contentFileSizeExpected, final int arrayLengthToRead) throws IOException {
      IndexInput indexInput = dir.openInput(fileName, IOContext.DEFAULT);
      AssertJUnit.assertEquals(contentFileSizeExpected, indexInput.length());


      RepeatableLongByteSequence bytesGenerator = new RepeatableLongByteSequence();


      byte[] readBytes = new byte[arrayLengthToRead];
      byte[] expectedBytes = new byte[arrayLengthToRead];


      long toRead = contentFileSizeExpected;
      while (toRead > 0) {
         // the condition is satisfied when the file is close to the end
         if (toRead < arrayLengthToRead) {
            readBytes = new byte[(int) toRead];
            expectedBytes = new byte[(int) toRead];
         }
         int nextBytesToRead = (int) Math.min(toRead, arrayLengthToRead);


         bytesGenerator.nextBytes(expectedBytes);
         indexInput.readBytes(readBytes, 0, nextBytesToRead);


         assert Arrays.equals(expectedBytes, readBytes);


         toRead = toRead - nextBytesToRead;


      }
      indexInput.close();
   }

View Full Code Here

    *           The size content file expected
    * @throws IOException
    */
   private void assertReadByteWorkingCorrectly(Directory dir, String fileName,
            final int contentFileSizeExpected) throws IOException {
      IndexInput indexInput = dir.openInput(fileName, IOContext.DEFAULT);
      AssertJUnit.assertEquals(contentFileSizeExpected, indexInput.length());
      RepeatableLongByteSequence bytesGenerator = new RepeatableLongByteSequence();


      for (int i = 0; i < contentFileSizeExpected; i++) {
         AssertJUnit.assertEquals(bytesGenerator.nextByte(), indexInput.readByte());
      }
      indexInput.close();
   }

View Full Code Here

      Set other = new HashSet(Arrays.asList(new String[0]));


      // ok, file listing works.
      AssertJUnit.assertEquals(s, other);


      IndexInput ii = dir.openInput("Hello.txt", IOContext.DEFAULT);


      assert ii.length() == helloText.length();


      ByteArrayOutputStream baos = new ByteArrayOutputStream();


      for (int i = 0; i < ii.length(); i++) {
         baos.write(ii.readByte());
      }


      assert new String(baos.toByteArray()).equals(helloText);


      ii = dir.openInput("World.txt", IOContext.DEFAULT);


      assert ii.length() == worldText.length();


      baos = new ByteArrayOutputStream();


      for (int i = 0; i < ii.length(); i++) {
         baos.write(ii.readByte());
      }


      assert new String(baos.toByteArray()).equals(worldText);


      // now with buffered reading


      ii = dir.openInput("Hello.txt", IOContext.DEFAULT);


      assert ii.length() == helloText.length();


      baos = new ByteArrayOutputStream();


      long toRead = ii.length();
      while (toRead > 0) {
         buf = new byte[19]; // suitably arbitrary
         int bytesRead = (int) Math.min(toRead, 19);
         ii.readBytes(buf, 0, bytesRead);
         toRead = toRead - bytesRead;
         baos.write(buf, 0, bytesRead);
      }


      assert new String(baos.toByteArray()).equals(helloText);


      ii = dir.openInput("World.txt", IOContext.DEFAULT);


      assert ii.length() == worldText.length();


      baos = new ByteArrayOutputStream();


      toRead = ii.length();
      while (toRead > 0) {
         buf = new byte[19]; // suitably arbitrary
         int bytesRead = (int) Math.min(toRead, 19);
         ii.readBytes(buf, 0, bytesRead);
         toRead = toRead - bytesRead;
         baos.write(buf, 0, bytesRead);
      }


      assert new String(baos.toByteArray()).equals(worldText);


      dir.deleteFile("Hello.txt");
      assert null == cache.get(new FileCacheKey(INDEXNAME, "Hello.txt"));
      assert null == cache.get(new ChunkCacheKey(INDEXNAME, "Hello.txt", 0, BUFFER_SIZE));


      Object ob1 = cache.get(new FileCacheKey(INDEXNAME, "World.txt"));
      Object ob2 = cache.get(new ChunkCacheKey(INDEXNAME, "World.txt", 0, BUFFER_SIZE));
      Object ob3 = cache.get(new ChunkCacheKey(INDEXNAME, "World.txt", 1, BUFFER_SIZE));


      ((DirectoryExtensions)dir).renameFile("World.txt", "HelloWorld.txt");
      assert null == cache.get(new FileCacheKey(INDEXNAME, "Hello.txt"));
      assert null == cache.get(new ChunkCacheKey(INDEXNAME, "Hello.txt", 0, BUFFER_SIZE));
      assert null == cache.get(new ChunkCacheKey(INDEXNAME, "Hello.txt", 1, BUFFER_SIZE));


      assert cache.get(new FileCacheKey(INDEXNAME, "HelloWorld.txt")).equals(ob1);
      assert cache.get(new ChunkCacheKey(INDEXNAME, "HelloWorld.txt", 0, BUFFER_SIZE)).equals(ob2);
      assert cache.get(new ChunkCacheKey(INDEXNAME, "HelloWorld.txt", 1, BUFFER_SIZE)).equals(ob3);


      // test that contents survives a move
      ii = dir.openInput("HelloWorld.txt", IOContext.DEFAULT);


      assert ii.length() == worldText.length();


      baos = new ByteArrayOutputStream();


      toRead = ii.length();
      while (toRead > 0) {
         buf = new byte[19]; // suitably arbitrary
         int bytesRead = (int) Math.min(toRead, 19);
         ii.readBytes(buf, 0, bytesRead);
         toRead = toRead - bytesRead;
         baos.write(buf, 0, bytesRead);
      }


      assert new String(baos.toByteArray()).equals(worldText);

View Full Code Here

      assert dir.fileExists("MyNewFile.txt");
      assert null != cache.get(new ChunkCacheKey(INDEXNAME, "MyNewFile.txt", 0, BUFFER_SIZE));


      // test contents by reading:
      byte[] buf = new byte[9];
      IndexInput ii = dir.openInput("MyNewFile.txt", IOContext.DEFAULT);
      ii.readBytes(buf, 0, (int) ii.length());
      ii.close();


      assert new String(new byte[] { 66, 69 }).equals(new String(buf).trim());


      String testText = "This is some rubbish again that will span more than one chunk - one hopes.  Who knows, maybe even three or four chunks.";
      io = dir.createOutput("MyNewFile.txt", IOContext.DEFAULT);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.lucene.store.IndexInput

org.apache.blur.lucene.warmup.IndexWarmup

org.apache.blur.store.BaseDirectoryTestSuite

org.apache.blur.store.blockcache.BlockDirectoryTest

org.apache.blur.store.blockcache_v2.CacheDirectoryTest

org.apache.blur.store.blockcache_v2.CacheIndexInputTest

org.apache.blur.store.blockcache_v2.CacheIndexOutputTest

org.apache.blur.store.HdfsDirectoryTest

org.apache.jackrabbit.core.query.lucene.CachingIndexReader$CacheInitializer

org.apache.jackrabbit.core.query.lucene.directory.FSDirectoryManager$FSDir

org.apache.jackrabbit.core.query.lucene.PersistentIndex

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.