public static StaticBuffer getBuffer(int no) { return BufferUtil.getLongBuffer(no + idOffset); }
public TransactionLogHeader(long transactionId, Instant txTimestamp, TimestampProvider times) { this.transactionId = transactionId; this.txTimestamp = txTimestamp; this.times = times; Preconditions.checkArgument(this.transactionId > 0); Preconditions.checkNotNull(this.txTimestamp); logKey = HashingUtil.hashPrefixKey(HashingUtil.HashLength.SHORT, BufferUtil.getLongBuffer(transactionId)); }
private void writeSetting(String identifier, final StaticBuffer column, long value) { final StaticBuffer key = getSettingKey(identifier); final Entry add = StaticArrayEntry.of(column, BufferUtil.getLongBuffer(value)); Boolean status = BackendOperation.execute(new BackendOperation.Transactional<Boolean>() { @Override public Boolean call(StoreTransaction txh) throws BackendException { store.mutate(key,ImmutableList.of(add),KeyColumnValueStore.NO_DELETIONS,txh); return Boolean.TRUE; } @Override public String toString() { return "writingLogSetting"; } },this, times, maxWriteTime); Preconditions.checkState(status); }
public StaticBuffer getKey(long vertexId) { if (VertexIDType.Schema.is(vertexId)) { //No partition for schema vertices return BufferUtil.getLongBuffer(vertexId); } else { assert isUserVertexId(vertexId); VertexIDType type = getUserVertexIDType(vertexId); assert type.offset()==USERVERTEX_PADDING_BITWIDTH; long partition = getPartitionId(vertexId); long count = vertexId>>>(partitionBits+USERVERTEX_PADDING_BITWIDTH); assert count>0; long keyId = (partition<<partitionOffset) | type.addPadding(count); return BufferUtil.getLongBuffer(keyId); } }
@Test public void testReadMarkerResumesInMiddleOfLog() throws Exception { Log log1 = manager.openLog("test1"); log1.add(BufferUtil.getLongBuffer(1L)); log1.close(); log1 = manager.openLog("test1"); CountingReader count = new CountingReader(1, true); log1.registerReader(ReadMarker.fromNow(),count); log1.add(BufferUtil.getLongBuffer(2L)); count.await(TIMEOUT_MS); assertEquals(1, count.totalMsg.get()); assertEquals(2, count.totalValue.get()); }
@Test public void testLogIsDurableAcrossReopenSerial() throws Exception { final long past = System.currentTimeMillis() - 10L; Log l; l = manager.openLog("durable"); l.add(BufferUtil.getLongBuffer(1L)); manager.close(); l = manager.openLog("durable"); l.add(BufferUtil.getLongBuffer(2L)); l.close(); l = manager.openLog("durable"); CountingReader count = new CountingReader(2, true); l.registerReader(ReadMarker.fromTime(Instant.ofEpochMilli(past)),count); count.await(TIMEOUT_MS); assertEquals(2, count.totalMsg.get()); assertEquals(3L, count.totalValue.get()); }
expected.add(BufferUtil.getLongBuffer(l)); StaticBuffer keyStart = BufferUtil.getLongBuffer(start); StaticBuffer keyEnd = BufferUtil.getLongBuffer(end); KeyRangeQuery krq = new KeyRangeQuery(keyStart, keyEnd, sq); expected.add(BufferUtil.getLongBuffer(l));
@Test public void testUnregisterReaderSerial() throws Exception { Log log = manager.openLog("test1"); // Register two readers and verify they receive messages. CountingReader reader1 = new CountingReader(1, true); CountingReader reader2 = new CountingReader(2, true); log.registerReader(ReadMarker.fromNow(),reader1, reader2); log.add(BufferUtil.getLongBuffer(1L)); reader1.await(TIMEOUT_MS); // Unregister one reader. It should no longer receive messages. The other reader should // continue to receive messages. log.unregisterReader(reader1); log.add(BufferUtil.getLongBuffer(2L)); reader2.await(TIMEOUT_MS); assertEquals(1, reader1.totalMsg.get()); assertEquals(1, reader1.totalValue.get()); assertEquals(2, reader2.totalMsg.get()); assertEquals(3, reader2.totalValue.get()); }
@Test public void testSeparateReadersAndLogsInSharedManager() throws Exception { final int n = 5; Log logs[] = new Log[n]; CountingReader counts[] = new CountingReader[n]; for (int i = 0; i < n; i++) { counts[i] = new CountingReader(1, true); logs[i] = manager.openLog("loner" + i); } for (int i = 0; i < n; i++) { logs[i].registerReader(ReadMarker.fromNow(),counts[i]); logs[i].add(BufferUtil.getLongBuffer(1L << (i + 1))); } // Check message receipt. for (int i = 0; i < n; i++) { log.debug("Awaiting CountingReader[{}]", i); counts[i].await(TIMEOUT_MS); assertEquals(1L << (i + 1), counts[i].totalValue.get()); assertEquals(1, counts[i].totalMsg.get()); } }
KeySliceQuery query = new KeySliceQuery(logKey, BufferUtil.getLongBuffer(times.getTime(messageTimeStart)), BufferUtil.getLongBuffer(times.getTime(messageTimeEnd))); query.setLimit(maxReadMsg); log.trace("Converted MessagePuller time window to {}", query); log.debug("Extended time window to {}", messageTimeEnd); query = new KeySliceQuery(logKey, BufferUtil.nextBiggerBuffer(lastEntry.getColumn()), BufferUtil.getLongBuffer(times.getTime(messageTimeEnd))); log.debug("Converted extended MessagePuller time window to {}", query); List<Entry> extraEntries = BackendOperation.execute(getOperation(query),KCVSLog.this,times,maxReadTime);
final StaticBuffer key = BufferUtil.getLongBuffer(1); final StaticBuffer col = BufferUtil.getLongBuffer(2); final StaticBuffer val2 = BufferUtil.getLongBuffer(8);
keys = store.getKeys(new KeyRangeQuery(BufferUtil.getLongBuffer(minKey), BufferUtil.getLongBuffer(maxKey), columnSlice), tx); assertEquals(expectedKeyCount, KeyValueStoreUtil.count(keys)); keys = store.getKeys(new KeyRangeQuery(BufferUtil.getLongBuffer(minKey), BufferUtil.getLongBuffer(maxKey), columnSlice), tx); assertEquals(expectedKeyCount, KeyValueStoreUtil.count(keys));
public void sendReceive(int readers, int numMessages, int delayMS, boolean expectMessageOrder, long timeoutMS) throws Exception { Preconditions.checkState(0 < readers); Log log1 = manager.openLog("test1"); assertEquals("test1",log1.getName()); CountingReader counts[] = new CountingReader[readers]; for (int i = 0; i < counts.length; i++) { counts[i] = new CountingReader(numMessages, expectMessageOrder); log1.registerReader(ReadMarker.fromNow(),counts[i]); } for (long i=1;i<=numMessages;i++) { log1.add(BufferUtil.getLongBuffer(i)); // System.out.println("Wrote message: " + i); Thread.sleep(delayMS); } for (int i = 0; i < counts.length; i++) { CountingReader count = counts[i]; count.await(timeoutMS); assertEquals("counter index " + i + " message count mismatch", numMessages, count.totalMsg.get()); assertEquals("counter index " + i + " value mismatch", numMessages*(numMessages+1)/2,count.totalValue.get()); assertTrue(log1.unregisterReader(count)); } log1.close(); }
@Test public void testMultipleLogsWithSingleReaderSerial() throws Exception { final int nl = 3; Log logs[] = new Log[nl]; CountingReader count = new CountingReader(3, false); // Open all logs up front. This gets any ColumnFamily creation overhead // out of the way. This is particularly useful on HBase. for (int i = 0; i < nl; i++) { logs[i] = manager.openLog("ml" + i); } // Register readers for (int i = 0; i < nl; i++) { logs[i].registerReader(ReadMarker.fromNow(),count); } // Send messages long value = 1L; for (int i = 0; i < nl; i++) { logs[i].add(BufferUtil.getLongBuffer(value)); value <<= 1; } // Await receipt count.await(TIMEOUT_MS); assertEquals(3, count.totalMsg.get()); assertEquals(value - 1, count.totalValue.get()); }