Example usage for org.apache.cassandra.io.util SequentialWriter sync

Introduction

In this page you can find the example usage for org.apache.cassandra.io.util SequentialWriter sync.

Prototype

public void sync() 

Source Link

Document

Synchronize file contents with disk.

Usage

From source file:com.fullcontact.cassandra.io.util.BufferedRandomAccessFileTest.java

License:Apache License

@Test
public void testReadAndWrite() throws Exception {
    SequentialWriter w = createTempFile("braf");

    // writting string of data to the file
    byte[] data = "Hello".getBytes();
    w.write(data);/* w w  w . j a v a 2  s  .co m*/
    assertEquals(data.length, w.length());
    assertEquals(data.length, w.getFilePointer());

    w.sync();

    // reading small amount of data from file, this is handled by initial buffer
    RandomAccessReader r = RandomAccessReader.open(w, fs);

    byte[] buffer = new byte[data.length];
    assertEquals(data.length, r.read(buffer));
    assertTrue(Arrays.equals(buffer, data)); // we read exactly what we wrote
    assertEquals(r.read(), -1); // nothing more to read EOF
    assert r.bytesRemaining() == 0 && r.isEOF();

    r.close();

    // writing buffer bigger than page size, which will trigger reBuffer()
    byte[] bigData = new byte[RandomAccessReader.DEFAULT_BUFFER_SIZE + 10];

    for (int i = 0; i < bigData.length; i++)
        bigData[i] = 'd';

    long initialPosition = w.getFilePointer();
    w.write(bigData); // writing data
    assertEquals(w.getFilePointer(), initialPosition + bigData.length);
    assertEquals(w.length(), initialPosition + bigData.length); // file size should equals to last position

    w.sync();

    r = RandomAccessReader.open(w, fs); // re-opening file in read-only mode

    // reading written buffer
    r.seek(initialPosition); // back to initial (before write) position
    data = new byte[bigData.length];
    long sizeRead = 0;
    for (int i = 0; i < data.length; i++) {
        data[i] = (byte) r.read();
        sizeRead++;
    }

    assertEquals(sizeRead, data.length); // read exactly data.length bytes
    assertEquals(r.getFilePointer(), initialPosition + data.length);
    assertEquals(r.length(), initialPosition + bigData.length);
    assertTrue(Arrays.equals(bigData, data));
    assertTrue(r.bytesRemaining() == 0 && r.isEOF()); // we are at the of the file

    // test readBytes(int) method
    r.seek(0);
    ByteBuffer fileContent = r.readBytes((int) w.length());
    assertEquals(fileContent.limit(), w.length());
    assert ByteBufferUtil.string(fileContent).equals("Hello" + new String(bigData));

    // read the same buffer but using readFully(int)
    data = new byte[bigData.length];
    r.seek(initialPosition);
    r.readFully(data);
    assert r.bytesRemaining() == 0 && r.isEOF(); // we should be at EOF
    assertTrue(Arrays.equals(bigData, data));

    // try to read past mark (all methods should return -1)
    data = new byte[10];
    assertEquals(r.read(), -1);
    assertEquals(r.read(data), -1);
    assertEquals(r.read(data, 0, data.length), -1);

    // test read(byte[], int, int)
    r.seek(0);
    data = new byte[20];
    assertEquals(15, r.read(data, 0, 15));
    assertTrue(new String(data).contains("Hellodddddddddd"));
    for (int i = 16; i < data.length; i++) {
        assert data[i] == 0;
    }

    w.close();
    r.close();
}

---

From source file:com.fullcontact.cassandra.io.util.BufferedRandomAccessFileTest.java

License:Apache License

@Test
public void testLength() throws IOException {
    File tmpFile = File.createTempFile("lengthtest", "bin");
    SequentialWriter w = SequentialWriter.open(tmpFile);
    assertEquals(0, w.length());/*  w  w w.  j  av  a  2s. c o  m*/

    // write a chunk smaller then our buffer, so will not be flushed
    // to disk
    byte[] lessThenBuffer = generateByteArray(RandomAccessReader.DEFAULT_BUFFER_SIZE / 2);
    w.write(lessThenBuffer);
    assertEquals(lessThenBuffer.length, w.length());

    // sync the data and check length
    w.sync();
    assertEquals(lessThenBuffer.length, w.length());

    // write more then the buffer can hold and check length
    byte[] biggerThenBuffer = generateByteArray(RandomAccessReader.DEFAULT_BUFFER_SIZE * 2);
    w.write(biggerThenBuffer);
    assertEquals(biggerThenBuffer.length + lessThenBuffer.length, w.length());

    w.close();

    // will use cachedlength
    RandomAccessReader r = RandomAccessReader.open(new Path(tmpFile.getPath()), fs);
    assertEquals(lessThenBuffer.length + biggerThenBuffer.length, r.length());
    r.close();
}

---

From source file:com.fullcontact.cassandra.io.util.BufferedRandomAccessFileTest.java

License:Apache License

@Test
public void testReadBytes() throws IOException {
    final SequentialWriter w = createTempFile("brafReadBytes");

    byte[] data = new byte[RandomAccessReader.DEFAULT_BUFFER_SIZE + 10];

    for (int i = 0; i < data.length; i++) {
        data[i] = 'c';
    }//from  ww w .j  a v a2s . co  m

    w.write(data);
    w.sync();

    final RandomAccessReader r = RandomAccessReader.open(w, fs);

    ByteBuffer content = r.readBytes((int) r.length());

    // after reading whole file we should be at EOF
    assertEquals(0, ByteBufferUtil.compare(content, data));
    assert r.bytesRemaining() == 0 && r.isEOF();

    r.seek(0);
    content = r.readBytes(10); // reading first 10 bytes
    assertEquals(ByteBufferUtil.compare(content, "cccccccccc".getBytes()), 0);
    assertEquals(r.bytesRemaining(), r.length() - content.limit());

    // trying to read more than file has right now
    expectEOF(new Callable<Object>() {
        public Object call() throws IOException {
            return r.readBytes((int) r.length() + 10);
        }
    });

    w.close();
    r.close();
}

---

From source file:com.fullcontact.cassandra.io.util.BufferedRandomAccessFileTest.java

License:Apache License

@Test
public void testGetFilePointer() throws IOException {
    final SequentialWriter w = createTempFile("brafGetFilePointer");

    assertEquals(w.getFilePointer(), 0); // initial position should be 0

    w.write(generateByteArray(20));/*  w  ww .  j a v a2 s . c  o  m*/
    assertEquals(w.getFilePointer(), 20); // position 20 after writing 20 bytes

    w.sync();

    RandomAccessReader r = RandomAccessReader.open(w, fs);

    // position should change after skip bytes
    r.seek(0);
    r.skipBytes(15);
    assertEquals(r.getFilePointer(), 15);

    r.read();
    assertEquals(r.getFilePointer(), 16);
    r.read(new byte[4]);
    assertEquals(r.getFilePointer(), 20);

    w.close();
    r.close();
}

---

From source file:com.fullcontact.cassandra.io.util.BufferedRandomAccessFileTest.java

License:Apache License

@Test
public void testBytesRemaining() throws IOException {
    SequentialWriter w = createTempFile("brafBytesRemaining");

    int toWrite = RandomAccessReader.DEFAULT_BUFFER_SIZE + 10;

    w.write(generateByteArray(toWrite));

    w.sync();

    RandomAccessReader r = RandomAccessReader.open(w, fs);

    assertEquals(r.bytesRemaining(), toWrite);

    for (int i = 1; i <= r.length(); i++) {
        r.read();//from   w w w  .  j a  va 2s  .c  o  m
        assertEquals(r.bytesRemaining(), r.length() - i);
    }

    r.seek(0);
    r.skipBytes(10);
    assertEquals(r.bytesRemaining(), r.length() - 10);

    w.close();
    r.close();
}

---

From source file:com.fullcontact.cassandra.io.util.BufferedRandomAccessFileTest.java

License:Apache License

@Test
public void testReadOnly() throws IOException {
    SequentialWriter file = createTempFile("brafReadOnlyTest");

    byte[] data = new byte[20];
    for (int i = 0; i < data.length; i++)
        data[i] = 'c';

    file.write(data);/*from ww w.  j  a v  a 2s  .c  o m*/
    file.sync(); // flushing file to the disk

    // read-only copy of the file, with fixed file length
    final RandomAccessReader copy = RandomAccessReader.open(new Path(file.getPath()), fs);

    copy.seek(copy.length());
    assertTrue(copy.bytesRemaining() == 0 && copy.isEOF());

    // can't seek past the end of the file for read-only files
    expectException(new Callable<Object>() {
        public Object call() {
            copy.seek(copy.length() + 1);
            return null;
        }
    }, IllegalArgumentException.class);

    // Any write() call should fail
    expectException(new Callable<Object>() {
        public Object call() throws IOException {
            copy.write(1);
            return null;
        }
    }, UnsupportedOperationException.class);

    expectException(new Callable<Object>() {
        public Object call() throws IOException {
            copy.write(new byte[1]);
            return null;
        }
    }, UnsupportedOperationException.class);

    expectException(new Callable<Object>() {
        public Object call() throws IOException {
            copy.write(new byte[3], 0, 2);
            return null;
        }
    }, UnsupportedOperationException.class);

    copy.seek(0);
    copy.skipBytes(5);

    assertEquals(copy.bytesRemaining(), 15);
    assertEquals(copy.getFilePointer(), 5);
    assertTrue(!copy.isEOF());

    copy.seek(0);
    ByteBuffer contents = copy.readBytes((int) copy.length());

    assertEquals(contents.limit(), copy.length());
    assertTrue(ByteBufferUtil.compare(contents, data) == 0);

    copy.seek(0);

    int count = 0;
    while (!copy.isEOF()) {
        assertEquals((byte) copy.read(), 'c');
        count++;
    }

    assertEquals(count, copy.length());

    copy.seek(0);
    byte[] content = new byte[10];
    copy.read(content);

    assertEquals(new String(content), "cccccccccc");

    file.close();
    copy.close();
}

---