@Override protected Object getStorage(long bucketSize, int recordCount) { return new MemLogStorage(bucketSize, recordCount); }
@Test public void addLogRecordTest() { addLogRecordTestHelper(10, 2); addLogRecordTestHelper(14, 10); addLogRecordTestHelper(2, 10); addLogRecordTestHelper(10, 1); }
@Override public BucketInfo addLogRecord(LogRecord record) { LOG.trace("Adding new log record with size {}", record.getSize()); if (record.getSize() > maxBucketSize) { throw new IllegalArgumentException("Record size(" + record.getSize() + ") is bigger than max bucket size (" + maxBucketSize + ")!"); } synchronized (buckets) { if (consumedVolume + record.getSize() > maxStorageSize) { throw new IllegalStateException("Storage is full!"); } if (currentBucket == null || currentBucket.getState() != MemBucketState.FREE) { currentBucket = new MemBucket(bucketIdSeq.getAndIncrement(), maxBucketSize, maxBucketRecordCount); buckets.put(currentBucket.getId(), currentBucket); } if (!currentBucket.addRecord(record)) { LOG.trace("Current bucket is full. Creating new one."); currentBucket.setState(MemBucketState.FULL); currentBucket = new MemBucket(bucketIdSeq.getAndIncrement(), maxBucketSize, maxBucketRecordCount); buckets.put(currentBucket.getId(), currentBucket); currentBucket.addRecord(record); } recordCount++; consumedVolume += record.getSize(); } LOG.trace("Added a new log record to bucket [{}]", currentBucket.getId()); return new BucketInfo(currentBucket.getId(), currentBucket.getCount()); }
@Override public LogBucket getNextBucket() { LOG.trace("Getting new record block with block"); LogBucket result = null; MemBucket bucketCandidate = null; synchronized (buckets) { for (MemBucket bucket : buckets.values()) { if (bucket.getState() == MemBucketState.FREE) { bucketCandidate = bucket; } if (bucket.getState() == MemBucketState.FULL) { bucket.setState(MemBucketState.PENDING); bucketCandidate = bucket; break; } } if (bucketCandidate != null) { consumedVolume -= bucketCandidate.getSize(); recordCount -= bucketCandidate.getCount(); if (bucketCandidate.getState() == MemBucketState.FREE) { LOG.trace("Only a bucket with state FREE found: [{}]. Changing its state to PENDING", bucketCandidate.getId()); bucketCandidate.setState(MemBucketState.PENDING); } result = new LogBucket(bucketCandidate.getId(), bucketCandidate.getRecords()); LOG.debug("Return record block with records count: [{}]", bucketCandidate.getCount()); } } return result; }
@Test public void shrinkToSizeTest() { MemBucket bucket = new MemBucket(1, 100, 100); addNRecordsToBucket(bucket, 10); List<LogRecord> overSize = bucket.shrinkToSize(10, 4); Assert.assertEquals(3, bucket.getCount()); Assert.assertEquals(9, bucket.getSize()); Assert.assertEquals(7, overSize.size()); bucket = new MemBucket(1, 100, 100); addNRecordsToBucket(bucket, 10); overSize = bucket.shrinkToSize(10, 2); Assert.assertEquals(2, bucket.getCount()); Assert.assertEquals(6, bucket.getSize()); Assert.assertEquals(8, overSize.size()); overSize = bucket.shrinkToSize(400, 400); Assert.assertEquals(0, overSize.size()); }
public void addLogRecordTestHelper(int maxSize, int maxRecordCount) { MemBucket bucket = new MemBucket(1, maxSize, maxRecordCount); int curSize = 0; int curRecordCount = 0; LogRecord record = new LogRecord(); while (curSize + record.getSize() <= maxSize && curRecordCount < maxRecordCount) { Assert.assertTrue(bucket.addRecord(record)); curRecordCount++; curSize += 3; } Assert.assertFalse(bucket.addRecord(record)); }
/** * Adds a record to a bucket. * * @param record record * @return true if record is added otherwise false */ public boolean addRecord(LogRecord record) { if (size + record.getSize() > maxSize) { LOG.trace("No space left in bucket. Current size: {}, record size: {}, max size: {}", size, record.getSize(), maxSize); return false; } if (getCount() + 1 > maxRecordCount) { LOG.trace("No space left in bucket. Current count: {}, max count: {}", getCount(), maxRecordCount); return false; } records.add(record); size += record.getSize(); return true; }
private void addNRecordsToBucket(MemBucket bucket, int n) { while (n-- > 0) { bucket.addRecord(new LogRecord()); } } }
/** * All-args constructor. */ public AbstractLogCollector(LogTransport transport, ExecutorContext executorContext, KaaChannelManager channelManager, FailoverManager failoverManager) { this.strategy = new DefaultLogUploadStrategy(); this.storage = new MemLogStorage(); this.controller = new DefaultLogUploadController(); this.channelManager = channelManager; this.transport = transport; this.executorContext = executorContext; this.failoverManager = failoverManager; }
/** * Shrinks current bucket to the newSize. * * @param newSize expected max size of a bucket inclusively * @param newCount the new count * @return removed from the bucket records */ public List<LogRecord> shrinkToSize(long newSize, int newCount) { LOG.trace("Shrinking {} bucket to the new size: [{}] and count [{}]", this, newSize, newCount); if (newSize < 0 || newCount < 0) { throw new IllegalArgumentException("New size and count values must be non-negative"); } if (newSize >= size && newCount >= getCount()) { return Collections.emptyList(); } List<LogRecord> overSize = new ArrayList<>(); int lastIndex = records.size() - 1; while ((size > newSize || getCount() > newCount) && lastIndex > 0) { LogRecord curRecord = records.remove(lastIndex--); overSize.add(curRecord); size -= curRecord.getSize(); } LOG.trace("Shrink over-sized elements: [{}]. New bucket size: [{}] and count [{}]", overSize.size(), size, getCount()); return overSize; }