Examples of org.hornetq.core.asyncio.impl.AsynchronousFileImpl$PollerRunnable

org.hornetq.core.asyncio.impl.AsynchronousFileImpl
Explicitly adding a compare to clause that returns 0 for at least the same object.
If {@link Comparable#compareTo(Object)} does not return 0 -for at least the same object- someCollection classes methods will fail (example {@link PriorityQueue#remove(Object)}. If it returns 0, then {@link #equals(Object)} must return {@code true} for the exact same cases,otherwise we will get compatibility problems between Java5 and Java6.

   }


   public void testBufferCallbackAwaysSameBuffer() throws Exception
   {
      boolean closed = false;
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      ByteBuffer buffer = null;
      try
      {
         final int NUMBER_LINES = 1000;
         final int SIZE = 512;


         controller.open(FILE_NAME, 1000);


         controller.fill(0, 1, NUMBER_LINES * SIZE, (byte)'j');


         final ArrayList<ByteBuffer> buffers = new ArrayList<ByteBuffer>();


         BufferCallback bufferCallback = new BufferCallback()
         {
            public void bufferDone(final ByteBuffer buffer)
            {
               buffers.add(buffer);
            }
         };


         controller.setBufferCallback(bufferCallback);


         CountDownLatch latch = new CountDownLatch(NUMBER_LINES);


         buffer = AsynchronousFileImpl.newBuffer(SIZE);
         buffer.rewind();
         for (int j = 0; j < SIZE; j++)
         {
            buffer.put((byte)(j % Byte.MAX_VALUE));
         }


         ArrayList<Integer> result = new ArrayList<Integer>();


         for (int i = 0; i < NUMBER_LINES; i++)
         {
            CountDownCallback aio = new CountDownCallback(latch, null, result, i);
            controller.write(i * SIZE, SIZE, buffer, aio);
         }


         // The buffer callback is only called after the complete callback was
         // called.
         // Because of that a race could happen on the assertions to
         // buffers.size what would invalidate the test
         // We close the file and that would guarantee the buffer callback was
         // called for all the elements
         controller.close();
         closed = true;


         CountDownCallback.checkResults(NUMBER_LINES, result);


         Assert.assertEquals(NUMBER_LINES, buffers.size());


         // Make sure all the buffers are unique
         ByteBuffer lineOne = null;
         for (ByteBuffer bufferTmp : buffers)
         {
            if (lineOne == null)
            {
               lineOne = bufferTmp;
            }
            else
            {
               Assert.assertTrue(lineOne == bufferTmp);
            }
         }


         buffers.clear();


      }
      finally
      {
         AsynchronousFileImpl.destroyBuffer(buffer);
         if (!closed)
         {
            controller.close();
         }
      }
   }

View Full Code Here

      }
   }


   public void testRead() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      controller.setBufferCallback(new BufferCallback()
      {


         public void bufferDone(final ByteBuffer buffer)
         {
            AsynchronousFileImpl.destroyBuffer(buffer);
         }


      });


      ByteBuffer readBuffer = null;
      try
      {


         final int NUMBER_LINES = 1000;
         final int SIZE = 1024;


         controller.open(FILE_NAME, 1000);


         controller.fill(0, 1, NUMBER_LINES * SIZE, (byte)'j');


         {
            CountDownLatch latch = new CountDownLatch(NUMBER_LINES);
            ArrayList<Integer> result = new ArrayList<Integer>();


            AtomicInteger errors = new AtomicInteger(0);


            for (int i = 0; i < NUMBER_LINES; i++)
            {
               if (i % 100 == 0)
               {
                  System.out.println("Wrote " + i + " lines");
               }
               ByteBuffer buffer = AsynchronousFileImpl.newBuffer(SIZE);
               for (int j = 0; j < SIZE; j++)
               {
                  buffer.put(UnitTestCase.getSamplebyte(j));
               }


               CountDownCallback aio = new CountDownCallback(latch, errors, result, i);
               controller.write(i * SIZE, SIZE, buffer, aio);
            }


            latch.await();


            Assert.assertEquals(0, errors.get());


            CountDownCallback.checkResults(NUMBER_LINES, result);
         }


         // If you call close you're supposed to wait events to finish before
         // closing it
         controller.close();
         controller.setBufferCallback(null);


         controller.open(FILE_NAME, 10);


         readBuffer = AsynchronousFileImpl.newBuffer(SIZE);


         for (int i = 0; i < NUMBER_LINES; i++)
         {
            if (i % 100 == 0)
            {
               System.out.println("Read " + i + " lines");
            }
            AsynchronousFileImpl.clearBuffer(readBuffer);


            CountDownLatch latch = new CountDownLatch(1);
            AtomicInteger errors = new AtomicInteger(0);
            CountDownCallback aio = new CountDownCallback(latch, errors, null, 0);


            controller.read(i * SIZE, SIZE, readBuffer, aio);


            latch.await();
            Assert.assertEquals(0, errors.get());
            Assert.assertTrue(aio.doneCalled);


            byte bytesRead[] = new byte[SIZE];
            readBuffer.get(bytesRead);


            for (int count = 0; count < SIZE; count++)
            {
               Assert.assertEquals("byte position " + count + " differs on line " + i + " position = " + count,
                                   UnitTestCase.getSamplebyte(count),
                                   bytesRead[count]);
            }
         }
      }
      finally
      {
         if (readBuffer != null)
         {
            AsynchronousFileImpl.destroyBuffer(readBuffer);
         }
         try
         {
            controller.close();
         }
         catch (Throwable ignored)
         {
         }

View Full Code Here

    *  This test will call file.close() when there are still callbacks being processed. 
    *  This could cause a crash or callbacks missing and this test is validating both situations.
    *  The file is also read after being written to validate its correctness */
   public void testConcurrentClose() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      try
      {


         final int NUMBER_LINES = 1000;
         CountDownLatch readLatch = new CountDownLatch(NUMBER_LINES);
         final int SIZE = 1024;


         controller.open(FILE_NAME, 10000);


         controller.fill(0, 1, NUMBER_LINES * SIZE, (byte)'j');


         controller.setBufferCallback(new BufferCallback()
         {


            public void bufferDone(final ByteBuffer buffer)
            {
               AsynchronousFileImpl.destroyBuffer(buffer);
            }


         });


         for (int i = 0; i < NUMBER_LINES; i++)
         {
            ByteBuffer buffer = AsynchronousFileImpl.newBuffer(SIZE);


            buffer.clear();
            addString("Str value " + i + "\n", buffer);
            for (int j = buffer.position(); j < buffer.capacity() - 1; j++)
            {
               buffer.put((byte)' ');
            }
            buffer.put((byte)'\n');


            CountDownCallback aio = new CountDownCallback(readLatch, null, null, 0);
            controller.write(i * SIZE, SIZE, buffer, aio);
         }


         // If you call close you're supposed to wait events to finish before
         // closing it
         controller.close();


         controller.setBufferCallback(null);


         Assert.assertEquals(0, readLatch.getCount());
         readLatch.await();
         controller.open(FILE_NAME, 10);


         ByteBuffer newBuffer = AsynchronousFileImpl.newBuffer(SIZE);


         ByteBuffer buffer = AsynchronousFileImpl.newBuffer(SIZE);


         for (int i = 0; i < NUMBER_LINES; i++)
         {
            newBuffer.clear();
            addString("Str value " + i + "\n", newBuffer);
            for (int j = newBuffer.position(); j < newBuffer.capacity() - 1; j++)
            {
               newBuffer.put((byte)' ');
            }
            newBuffer.put((byte)'\n');


            CountDownLatch latch = new CountDownLatch(1);
            CountDownCallback aio = new CountDownCallback(latch, null, null, 0);
            controller.read(i * SIZE, SIZE, buffer, aio);
            latch.await();
            Assert.assertEquals(0, aio.errorCalled);
            Assert.assertTrue(aio.doneCalled);


            byte bytesRead[] = new byte[SIZE];
            byte bytesCompare[] = new byte[SIZE];


            newBuffer.rewind();
            newBuffer.get(bytesCompare);
            buffer.rewind();
            buffer.get(bytesRead);


            for (int count = 0; count < SIZE; count++)
            {
               Assert.assertEquals("byte position " + count + " differs on line " + i,
                                   bytesCompare[count],
                                   bytesRead[count]);
            }


            Assert.assertTrue(buffer.equals(newBuffer));
         }


         AsynchronousFileImpl.destroyBuffer(newBuffer);
         AsynchronousFileImpl.destroyBuffer(buffer);


      }
      finally
      {
         try
         {
            controller.close();
         }
         catch (Throwable ignored)
         {
         }

View Full Code Here

      }
   }


   private void asyncData(final int numberOfLines, final int size, final int aioLimit) throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      controller.open(FILE_NAME, aioLimit);


      ByteBuffer buffer = null;


      try
      {
         CountDownLatch latchDone = new CountDownLatch(numberOfLines);


         buffer = AsynchronousFileImpl.newBuffer(size);
         encodeBufer(buffer);


         preAlloc(controller, numberOfLines * size);


         ArrayList<CountDownCallback> list = new ArrayList<CountDownCallback>();


         ArrayList<Integer> result = new ArrayList<Integer>();


         for (int i = 0; i < numberOfLines; i++)
         {
            list.add(new CountDownCallback(latchDone, null, result, i));
         }


         long valueInitial = System.currentTimeMillis();


         long lastTime = System.currentTimeMillis();
         int counter = 0;
         for (CountDownCallback tmp : list)
         {
            controller.write(counter * size, size, buffer, tmp);
            if (++counter % 20000 == 0)
            {
               AsynchronousFileTest.debug(20000 * 1000 / (System.currentTimeMillis() - lastTime) + " rec/sec (Async)");
               lastTime = System.currentTimeMillis();
            }


         }


         latchDone.await();


         long timeTotal = System.currentTimeMillis() - valueInitial;


         CountDownCallback.checkResults(numberOfLines, result);


         AsynchronousFileTest.debug("After completions time = " + timeTotal +
                                    " for " +
                                    numberOfLines +
                                    " registers " +
                                    " size each line = " +
                                    size +
                                    ", Records/Sec=" +
                                    numberOfLines *
                                    1000 /
                                    timeTotal +
                                    " (Assynchronous)");


         for (CountDownCallback tmp : list)
         {
            Assert.assertEquals(1, tmp.timesDoneCalled.get());
            Assert.assertTrue(tmp.doneCalled);
            Assert.assertEquals(0, tmp.errorCalled);
         }


         controller.close();
      }
      finally
      {
         AsynchronousFileImpl.destroyBuffer(buffer);
         try
         {
            controller.close();
         }
         catch (Exception ignored)
         {
         }
      }

View Full Code Here

      try
      {
         final int NUMBER_LINES = 3000;
         final int SIZE = 1024;


         final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
         controller.open(FILE_NAME, 2000);


         buffer = AsynchronousFileImpl.newBuffer(SIZE);
         encodeBufer(buffer);


         preAlloc(controller, NUMBER_LINES * SIZE);


         long startTime = System.currentTimeMillis();


         for (int i = 0; i < NUMBER_LINES; i++)
         {
            CountDownLatch latchDone = new CountDownLatch(1);
            CountDownCallback aioBlock = new CountDownCallback(latchDone, null, null, 0);
            controller.write(i * 512, 512, buffer, aioBlock);
            latchDone.await();
            Assert.assertTrue(aioBlock.doneCalled);
            Assert.assertEquals(0, aioBlock.errorCalled);
         }


         long timeTotal = System.currentTimeMillis() - startTime;
         AsynchronousFileTest.debug("time = " + timeTotal +
                                    " for " +
                                    NUMBER_LINES +
                                    " registers " +
                                    " size each line = " +
                                    SIZE +
                                    " Records/Sec=" +
                                    NUMBER_LINES *
                                    1000 /
                                    timeTotal +
                                    " Synchronous");


         controller.close();
      }
      catch (Exception e)
      {
         throw e;
      }

View Full Code Here


   }


   public void testInvalidWrite() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      controller.open(FILE_NAME, 2000);


      ByteBuffer buffer = null;


      try
      {
         final int SIZE = 512;


         buffer = AsynchronousFileImpl.newBuffer(SIZE);
         encodeBufer(buffer);


         preAlloc(controller, 10 * 512);


         CountDownLatch latchDone = new CountDownLatch(1);


         CountDownCallback aioBlock = new CountDownCallback(latchDone, null, null, 0);
         controller.write(11, 512, buffer, aioBlock);


         latchDone.await();


         Assert.assertTrue(aioBlock.errorCalled != 0);
         Assert.assertFalse(aioBlock.doneCalled);


      }
      catch (Exception e)
      {
         throw e;
      }
      finally
      {
         AsynchronousFileImpl.destroyBuffer(buffer);
         controller.close();
      }


   }

View Full Code Here

      Assert.assertEquals(0, errors.get());
   }


   public void testSize() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);


      final int NUMBER_LINES = 10;
      final int SIZE = 1024;


      controller.open(FILE_NAME, 1);


      controller.fill(0, 1, NUMBER_LINES * SIZE, (byte)'j');


      Assert.assertEquals(NUMBER_LINES * SIZE, controller.size());


      controller.close();


   }

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.hornetq.core.asyncio.impl.AsynchronousFileImpl$PollerRunnable

org.hornetq.core.journal.impl.AIOSequentialFile

org.hornetq.tests.unit.core.asyncio.AsynchronousFileTest

org.hornetq.tests.unit.core.asyncio.MultiThreadAsynchronousFileTest

org.hornetq.api.core.HornetQException

java.util.concurrent.Semaphore

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.