Examples of AsynchronousFileImpl


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

    *  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

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

      }
   }

   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

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

      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

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

   }


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

      ByteBuffer buffer = null;

      try
      {
         final int SIZE = 10 * 512;

         buffer = AsynchronousFileImpl.newBuffer(SIZE);

         for (int i = 0 ; i < SIZE; i++)
         {
            buffer.put(getSamplebyte(i));
         }

         controller.writeInternal(0, SIZE, buffer);

         InputStream fileInput = new BufferedInputStream(new FileInputStream(new File(FILE_NAME)));

         for (int  i = 0 ; i < SIZE; i++)
         {
            assertEquals((int)getSamplebyte(i), (int)fileInput.read());
         }

         assertEquals(-1, fileInput.read());

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

   }
View Full Code Here

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

   }


   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

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

      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

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

    * Opening and closing a file immediately can lead to races on the native layer,
    * creating crash conditions.
    * */
   public void testOpenClose() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      for (int i = 0; i < 1000; i++)
      {
         controller.open(FILE_NAME, 10000);
         controller.close();

      }
   }
View Full Code Here

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

      }
   }

   public void testReleaseBuffers() throws Exception
   {
      AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      WeakReference<ByteBuffer> bufferCheck = null;
      try
      {
         controller.open(FILE_NAME, 10000);
         bufferCheck = new WeakReference<ByteBuffer>(controller.getHandler());
         controller.fill(0, 10, 1024, (byte)0);

         ByteBuffer write = AsynchronousFileImpl.newBuffer(1024);

         for (int i = 0; i < 1024; i++)
         {
            write.put(UnitTestCase.getSamplebyte(i));
         }

         final CountDownLatch latch = new CountDownLatch(1);

         controller.write(0, 1024, write, new AIOCallback()
         {

            public void onError(final int errorCode, final String errorMessage)
            {
            }

            public void done()
            {
               latch.countDown();
            }
         });

         Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));

         WeakReference<ByteBuffer> bufferCheck2 = new WeakReference<ByteBuffer>(write);

         AsynchronousFileImpl.destroyBuffer(write);

         write = null;

         UnitTestCase.forceGC(bufferCheck2, 5000);

         Assert.assertNull(bufferCheck2.get());
      }
      finally
      {
         controller.close();
      }

      controller = null;

      UnitTestCase.forceGC(bufferCheck, 5000);
View Full Code Here

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

      Assert.assertNull(bufferCheck.get());
   }

   public void testFileNonExistent() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      for (int i = 0; i < 1000; i++)
      {
         try
         {
            controller.open("/non-existent/IDontExist.error", 10000);
            Assert.fail("Exception expected! The test could create a file called /non-existent/IDontExist.error when it was supposed to fail.");
         }
         catch (Exception ignored)
         {
         }
         try
         {
            controller.close();
            Assert.fail("Supposed to throw exception as the file wasn't opened");
         }
         catch (Exception ignored)
         {
         }
View Full Code Here

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

    * simultaneous files without loose any callbacks. This test made the native
    * layer to crash at some point during development
    */
   public void testTwoFiles() throws Exception
   {
      final AsynchronousFileImpl controller = new AsynchronousFileImpl(executor, pollerExecutor);
      final AsynchronousFileImpl controller2 = new AsynchronousFileImpl(executor, pollerExecutor);
      controller.open(FILE_NAME + ".1", 10000);
      controller2.open(FILE_NAME + ".2", 10000);

      int numberOfLines = 1000;
      int size = 1024;

      ArrayList<Integer> listResult1 = new ArrayList<Integer>();
      ArrayList<Integer> listResult2 = new ArrayList<Integer>();

      AtomicInteger errors = new AtomicInteger(0);

      ByteBuffer buffer = null;
      try
      {
         CountDownLatch latchDone = new CountDownLatch(numberOfLines);
         CountDownLatch latchDone2 = new CountDownLatch(numberOfLines);

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

         preAlloc(controller, numberOfLines * size);
         preAlloc(controller2, numberOfLines * size);

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

         for (int i = 0; i < numberOfLines; i++)
         {
            list.add(new CountDownCallback(latchDone, errors, listResult1, i));
            list2.add(new CountDownCallback(latchDone2, errors, listResult2, i));
         }

         int counter = 0;

         Iterator<CountDownCallback> iter2 = list2.iterator();

         for (CountDownCallback cb1 : list)
         {
            CountDownCallback cb2 = iter2.next();

            controller.write(counter * size, size, buffer, cb1);
            controller2.write(counter * size, size, buffer, cb2);
            ++counter;

         }

         latchDone.await();
         latchDone2.await();

         CountDownCallback.checkResults(numberOfLines, listResult1);
         CountDownCallback.checkResults(numberOfLines, listResult2);

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

         for (CountDownCallback callback : list2)
         {
            Assert.assertEquals(1, callback.timesDoneCalled.get());
            Assert.assertTrue(callback.doneCalled);
         }

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

         controller.close();
      }
      finally
      {
         AsynchronousFileImpl.destroyBuffer(buffer);
         try
         {
            controller.close();
         }
         catch (Exception ignored)
         {
         }
         try
         {
            controller2.close();
         }
         catch (Exception ignored)
         {
         }
      }
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
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.