/** * Joins the information from the other storage descriptor if possible. This method will return * true if the join was successfully done, and false if no join was done. The join is possible * only if the two descriptors are actually describing the data in the same channel that are * next to each other. There is no difference if the other descriptor is pointing to the data * after or before this descriptor. After successful join the joined data descriptor will be * represented by this descriptor. * * @param other * Descriptor information to join. * @return This method will return true if the join was successfully done, and false if no join * was done. */ public boolean join(IStorageDescriptor other) { if (this.getChannelId() != other.getChannelId()) { return false; } else { return join(other.getPosition(), other.getSize()); } }
/** * Signals to the {@link StorageIndexingTreeHandler} that the write has been successful with * correct information about write position and size. * <p> * Internally this method will update the {@link IStorageDescriptor} for the given * {@link DefaultData} object in the write task, and remove the task from the set of tasks being * currently processed. * * @param writeTask * Write task that succeeded. * @param position * Write position. * @param size * Write size. */ public void writeSuccessful(WriteTask writeTask, long position, long size) { // get the data from the map TreeDescriptorPair treeDescriptorPair = writeTasksInProcess.get(writeTask); if (null != treeDescriptorPair) { IStorageDescriptor storageDescriptor = treeDescriptorPair.getStorageDescriptor(); // update the descriptor with the information provided if (null != storageDescriptor) { storageDescriptor.setPositionAndSize(position, size); } } // remove the entry in map after the data has been updated in indexing tree writeTasksInProcess.remove(writeTask); }
/** * Constructor that uses the {@link IStorageDescriptor} to initiate the initial values. * * @param storageDescriptor * Storage descriptor that will be used to denote the range. */ public RangeDescriptor(IStorageDescriptor storageDescriptor) { start = storageDescriptor.getPosition(); end = (storageDescriptor.getPosition() + storageDescriptor.getSize()) - 1; }
when(defaultData.getId()).thenReturn(i); IStorageDescriptor storageDescriptor = leafWithNoDescriptors.put(defaultData); storageDescriptor.setPositionAndSize(totalSize, i); totalSize += i; i++; long totalReturnedSize = 0; for (IStorageDescriptor storageDescriptor : results) { totalReturnedSize += storageDescriptor.getSize(); totalReturnedSize = 0; for (IStorageDescriptor storageDescriptor : resultsForkJoin) { totalReturnedSize += storageDescriptor.getSize();
/** * Returns the URL location of the file on the server where the descriptor is pointing to, * without ip and port information. * <p> * Example locations is: /storageId/descriptorId.itdata * * @param storageData * {@link StorageData} * @param descriptor * {@link StorageDescriptor} * @return URL location without ip and port. */ public String getHttpFileLocation(IStorageData storageData, IStorageDescriptor descriptor) { return this.getHttpFileLocation(storageData, Integer.valueOf(descriptor.getChannelId())); }
@Test public void failedWrite() throws IndexingException { IStorageDescriptor storageDescriptor = mock(IStorageDescriptor.class); when(storageDescriptor.getChannelId()).thenReturn(1); DefaultData defaultData = mock(DefaultData.class); when(indexingTree.put(defaultData)).thenReturn(storageDescriptor); WriteTask writeTask = mock(WriteTask.class); when(writeTask.getData()).thenReturn(defaultData); int channel = indexingTreeHandler.startWrite(writeTask); assertThat(channel, is(1)); assertThat(indexingTreeHandler.getWriteTaskInProgressCount(), is(1)); indexingTreeHandler.writeFailed(writeTask); assertThat(indexingTreeHandler.getWriteTaskInProgressCount(), is(0)); verify(storageDescriptor, times(0)).setPositionAndSize(anyLong(), anyLong()); }
/** * Prepares the stream for read. Must be called before any read operation is executed. * * @throws IOException * if preparation fails due to inability to obtain defined number of byte buffers */ @Override public void prepare() throws IOException { super.prepare(); // set total size long totalSize = 0; for (IStorageDescriptor descriptor : descriptors) { totalSize += descriptor.getSize(); } setTotalSize(totalSize); executorService.execute(new ReadTask()); }
long readPosition = storageDescriptor.getPosition(); long descriptorTotalSize = storageDescriptor.getSize(); long descriptorReadSize = 0;
when(defaultData.getId()).thenReturn(i); IStorageDescriptor storageDescriptor = arrayBasedStorageLeaf.put(defaultData); storageDescriptor.setPositionAndSize(totalSize, i); totalSize += i; i++; assertThat(results.size(), is(equalTo(entries - 1))); for (IStorageDescriptor storageDescriptor : results) { assertThat(storageDescriptor.getSize(), is(not(equalTo(removeId)))); assertThat(resultsForkJoin.size(), is(equalTo(entries - 1))); for (IStorageDescriptor storageDescriptor : resultsForkJoin) { assertThat(storageDescriptor.getSize(), is(not(equalTo(removeId))));
Map<Integer, List<IStorageDescriptor>> filesMap = new HashMap<>(); for (IStorageDescriptor storageDescriptor : descriptors) { Integer channelId = Integer.valueOf(storageDescriptor.getChannelId()); List<IStorageDescriptor> oneFileList = filesMap.get(channelId); if (null == oneFileList) {
@Test public void successfulWrite() throws IndexingException { IStorageDescriptor storageDescriptor = mock(IStorageDescriptor.class); when(storageDescriptor.getChannelId()).thenReturn(1); DefaultData defaultData = mock(DefaultData.class); when(indexingTree.put(defaultData)).thenReturn(storageDescriptor); WriteTask writeTask = mock(WriteTask.class); when(writeTask.getData()).thenReturn(defaultData); int channel = indexingTreeHandler.startWrite(writeTask); assertThat(channel, is(1)); assertThat(indexingTreeHandler.getWriteTaskInProgressCount(), is(1)); long position = 20L; long size = 30L; indexingTreeHandler.writeSuccessful(writeTask, position, size); assertThat(indexingTreeHandler.getWriteTaskInProgressCount(), is(0)); verify(storageDescriptor, times(1)).setPositionAndSize(position, size); }
size += storageDescriptor.getSize(); limitedDescriptors.add(storageDescriptor);
/** * {@inheritDoc} */ @Override public int compareTo(IStorageDescriptor other) { if ((this.getChannelId() - other.getChannelId()) != 0) { return this.getChannelId() - other.getChannelId(); } if ((this.getPosition() - other.getPosition()) != 0) { return (int) (this.getPosition() - other.getPosition()); } if ((this.getSize() - other.getSize()) != 0) { return (int) (this.getSize() - other.getSize()); } return 0; }
if (null == storageDescriptor) { storageDescriptor = new StorageDescriptor(entry.getKey()); storageDescriptor.setPositionAndSize(descriptor.getPosition(), descriptor.getSize()); } else { if (!storageDescriptor.join(descriptor)) { optimizedDescriptors.add(storageDescriptor); storageDescriptor = new StorageDescriptor(entry.getKey()); storageDescriptor.setPositionAndSize(descriptor.getPosition(), descriptor.getSize());
when(defaultData1.getId()).thenReturn(1L); IStorageDescriptor storageDescriptor1 = rootBranch.put(defaultData1); storageDescriptor1.setPositionAndSize(0L, 100L); storageDescriptor2.setPositionAndSize(0L, 200L); assertThat(results.size(), is(equalTo(1))); for (IStorageDescriptor result : results) { assertThat(result.getSize(), is(equalTo(100L))); assertThat(resultsForkJoin.size(), is(equalTo(1))); for (IStorageDescriptor result : resultsForkJoin) { assertThat(result.getSize(), is(equalTo(100L)));
/** * Returns the {@link Path} of the channel for given {@link StorageData} and * {@link StorageDescriptor}. * * @param storageData * {@link IStorageData} object. * @param descriptor * {@link StorageDescriptor} object. * @return {@link Path} that can be used in IO operations. */ public Path getChannelPath(IStorageData storageData, IStorageDescriptor descriptor) { return getStoragePath(storageData).resolve(descriptor.getChannelId() + StorageFileType.DATA_FILE.getExtension()); }
/** * Test tree with empty query. All elements should be returned. * * @throws IndexingException * If {@link IndexingException} occurs. */ @Test public void emptyQueryTest() throws IndexingException { IStorageTreeComponent<DefaultData> rootBranch = new StorageBranch<>(new StorageBranchIndexer<>(new ObjectTypeIndexer<>(), false)); DefaultData defaultData = mock(DefaultData.class); when(defaultData.getId()).thenReturn(1L); IStorageDescriptor storageDescriptor1 = rootBranch.put(defaultData); storageDescriptor1.setPositionAndSize(0, 1); SqlStatementData defaultData2 = mock(SqlStatementData.class); when(defaultData2.getId()).thenReturn(2L); IStorageDescriptor storageDescriptor2 = rootBranch.put(defaultData2); storageDescriptor2.setPositionAndSize(2, 1); List<IStorageDescriptor> results = rootBranch.query(storageIndexQuery); assertThat(results.size(), is(equalTo(2))); // Test for forkJoinPool List<IStorageDescriptor> resultsForkJoin = rootBranch.query(storageIndexQuery, forkJoinPool); assertThat(resultsForkJoin.size(), is(equalTo(2))); }
assertThat("Amount of descriptors is less than the amount of invocations saved.", descriptors.size(), is(equalTo(createdInvocations.size()))); for (IStorageDescriptor descriptor : descriptors) { assertThat("position of descriptor is negative.", descriptor.getPosition(), is(greaterThanOrEqualTo(0L))); assertThat("Size of the descriptor is wrong.", descriptor.getSize(), is(greaterThan(0L))); Path absolutePath = storageManager.getChannelPath(storageData, desc.getChannelId()).toAbsolutePath(); allPaths.add(absolutePath);
rangeDescriptor = new RangeDescriptor(descriptor); } else { if ((rangeDescriptor.getEnd() + 1) == descriptor.getPosition()) { rangeDescriptor.setEnd((descriptor.getPosition() + descriptor.getSize()) - 1); } else { rangeHeader.append(rangeDescriptor.toString());
when(defaultData1.getTimeStamp()).thenReturn(new Timestamp(new Date().getTime())); IStorageDescriptor storageDescriptor1 = rootBranch.put(defaultData1); storageDescriptor1.setPositionAndSize(0L, 100L); when(defaultData2.getTimeStamp()).thenReturn(plusHour); IStorageDescriptor storageDescriptor2 = rootBranch.put(defaultData2); storageDescriptor2.setPositionAndSize(0L, 200L); assertThat(results.size(), is(equalTo(1))); for (IStorageDescriptor result : results) { assertThat(result.getSize(), is(equalTo(200L))); assertThat(resultsForkJoin.size(), is(equalTo(1))); for (IStorageDescriptor result : resultsForkJoin) { assertThat(result.getSize(), is(equalTo(200L)));