use of org.apache.nifi.registry.client.BucketClient in project nifi by apache.
the class RestBasedFlowRegistry method getBucketClient.
private BucketClient getBucketClient(final NiFiUser user) {
final String identity = getIdentity(user);
final NiFiRegistryClient registryClient = getRegistryClient();
final BucketClient bucketClient = identity == null ? registryClient.getBucketClient() : registryClient.getBucketClient(identity);
return bucketClient;
}
use of org.apache.nifi.registry.client.BucketClient in project nifi-registry by apache.
the class SecureNiFiRegistryClientIT method testCreatedBucketWithProxiedEntity.
@Test
public void testCreatedBucketWithProxiedEntity() throws IOException, NiFiRegistryException {
final String proxiedEntity = "user2";
final BucketClient bucketClient = client.getBucketClient(proxiedEntity);
final Bucket bucket = new Bucket();
bucket.setName("Bucket 1");
bucket.setDescription("This is bucket 1");
try {
bucketClient.create(bucket);
Assert.fail("Shouldn't have been able to create a bucket");
} catch (Exception e) {
}
}
use of org.apache.nifi.registry.client.BucketClient in project nifi-registry by apache.
the class UnsecuredNiFiRegistryClientIT method testNiFiRegistryClient.
@Test
public void testNiFiRegistryClient() throws IOException, NiFiRegistryException {
// ---------------------- TEST BUCKETS --------------------------//
final BucketClient bucketClient = client.getBucketClient();
// create buckets
final int numBuckets = 10;
final List<Bucket> createdBuckets = new ArrayList<>();
for (int i = 0; i < numBuckets; i++) {
final Bucket createdBucket = createBucket(bucketClient, i);
LOGGER.info("Created bucket # " + i + " with id " + createdBucket.getIdentifier());
createdBuckets.add(createdBucket);
}
// get each bucket
for (final Bucket bucket : createdBuckets) {
final Bucket retrievedBucket = bucketClient.get(bucket.getIdentifier());
Assert.assertNotNull(retrievedBucket);
LOGGER.info("Retrieved bucket " + retrievedBucket.getIdentifier());
}
// final Bucket nonExistentBucket = bucketClient.get("does-not-exist");
// Assert.assertNull(nonExistentBucket);
// get bucket fields
final Fields bucketFields = bucketClient.getFields();
Assert.assertNotNull(bucketFields);
LOGGER.info("Retrieved bucket fields, size = " + bucketFields.getFields().size());
Assert.assertTrue(bucketFields.getFields().size() > 0);
// get all buckets
final List<Bucket> allBuckets = bucketClient.getAll();
LOGGER.info("Retrieved buckets, size = " + allBuckets.size());
Assert.assertEquals(numBuckets, allBuckets.size());
allBuckets.stream().forEach(b -> System.out.println("Retrieve bucket " + b.getIdentifier()));
// update each bucket
for (final Bucket bucket : createdBuckets) {
final Bucket bucketUpdate = new Bucket();
bucketUpdate.setIdentifier(bucket.getIdentifier());
bucketUpdate.setDescription(bucket.getDescription() + " UPDATE");
final Bucket updatedBucket = bucketClient.update(bucketUpdate);
Assert.assertNotNull(updatedBucket);
LOGGER.info("Updated bucket " + updatedBucket.getIdentifier());
}
// ---------------------- TEST FLOWS --------------------------//
final FlowClient flowClient = client.getFlowClient();
// create flows
final Bucket flowsBucket = createdBuckets.get(0);
final VersionedFlow flow1 = createFlow(flowClient, flowsBucket, 1);
LOGGER.info("Created flow # 1 with id " + flow1.getIdentifier());
final VersionedFlow flow2 = createFlow(flowClient, flowsBucket, 2);
LOGGER.info("Created flow # 2 with id " + flow2.getIdentifier());
// get flow
final VersionedFlow retrievedFlow1 = flowClient.get(flowsBucket.getIdentifier(), flow1.getIdentifier());
Assert.assertNotNull(retrievedFlow1);
LOGGER.info("Retrieved flow # 1 with id " + retrievedFlow1.getIdentifier());
final VersionedFlow retrievedFlow2 = flowClient.get(flowsBucket.getIdentifier(), flow2.getIdentifier());
Assert.assertNotNull(retrievedFlow2);
LOGGER.info("Retrieved flow # 2 with id " + retrievedFlow2.getIdentifier());
// update flows
final VersionedFlow flow1Update = new VersionedFlow();
flow1Update.setIdentifier(flow1.getIdentifier());
flow1Update.setName(flow1.getName() + " UPDATED");
final VersionedFlow updatedFlow1 = flowClient.update(flowsBucket.getIdentifier(), flow1Update);
Assert.assertNotNull(updatedFlow1);
LOGGER.info("Updated flow # 1 with id " + updatedFlow1.getIdentifier());
// get flow fields
final Fields flowFields = flowClient.getFields();
Assert.assertNotNull(flowFields);
LOGGER.info("Retrieved flow fields, size = " + flowFields.getFields().size());
Assert.assertTrue(flowFields.getFields().size() > 0);
// get flows in bucket
final List<VersionedFlow> flowsInBucket = flowClient.getByBucket(flowsBucket.getIdentifier());
Assert.assertNotNull(flowsInBucket);
Assert.assertEquals(2, flowsInBucket.size());
flowsInBucket.stream().forEach(f -> LOGGER.info("Flow in bucket, flow id " + f.getIdentifier()));
// ---------------------- TEST SNAPSHOTS --------------------------//
final FlowSnapshotClient snapshotClient = client.getFlowSnapshotClient();
// create snapshots
final VersionedFlow snapshotFlow = flow1;
final VersionedFlowSnapshot snapshot1 = createSnapshot(snapshotClient, snapshotFlow, 1);
LOGGER.info("Created snapshot # 1 with version " + snapshot1.getSnapshotMetadata().getVersion());
final VersionedFlowSnapshot snapshot2 = createSnapshot(snapshotClient, snapshotFlow, 2);
LOGGER.info("Created snapshot # 2 with version " + snapshot2.getSnapshotMetadata().getVersion());
// get snapshot
final VersionedFlowSnapshot retrievedSnapshot1 = snapshotClient.get(snapshotFlow.getBucketIdentifier(), snapshotFlow.getIdentifier(), 1);
Assert.assertNotNull(retrievedSnapshot1);
Assert.assertFalse(retrievedSnapshot1.isLatest());
LOGGER.info("Retrieved snapshot # 1 with version " + retrievedSnapshot1.getSnapshotMetadata().getVersion());
final VersionedFlowSnapshot retrievedSnapshot2 = snapshotClient.get(snapshotFlow.getBucketIdentifier(), snapshotFlow.getIdentifier(), 2);
Assert.assertNotNull(retrievedSnapshot2);
Assert.assertTrue(retrievedSnapshot2.isLatest());
LOGGER.info("Retrieved snapshot # 2 with version " + retrievedSnapshot2.getSnapshotMetadata().getVersion());
// get latest
final VersionedFlowSnapshot retrievedSnapshotLatest = snapshotClient.getLatest(snapshotFlow.getBucketIdentifier(), snapshotFlow.getIdentifier());
Assert.assertNotNull(retrievedSnapshotLatest);
Assert.assertEquals(snapshot2.getSnapshotMetadata().getVersion(), retrievedSnapshotLatest.getSnapshotMetadata().getVersion());
Assert.assertTrue(retrievedSnapshotLatest.isLatest());
LOGGER.info("Retrieved latest snapshot with version " + retrievedSnapshotLatest.getSnapshotMetadata().getVersion());
// get metadata
final List<VersionedFlowSnapshotMetadata> retrievedMetadata = snapshotClient.getSnapshotMetadata(snapshotFlow.getBucketIdentifier(), snapshotFlow.getIdentifier());
Assert.assertNotNull(retrievedMetadata);
Assert.assertEquals(2, retrievedMetadata.size());
Assert.assertEquals(2, retrievedMetadata.get(0).getVersion());
Assert.assertEquals(1, retrievedMetadata.get(1).getVersion());
retrievedMetadata.stream().forEach(s -> LOGGER.info("Retrieved snapshot metadata " + s.getVersion()));
// get latest metadata
final VersionedFlowSnapshotMetadata latestMetadata = snapshotClient.getLatestMetadata(snapshotFlow.getBucketIdentifier(), snapshotFlow.getIdentifier());
Assert.assertNotNull(latestMetadata);
Assert.assertEquals(2, latestMetadata.getVersion());
// get latest metadata that doesn't exist
try {
snapshotClient.getLatestMetadata(snapshotFlow.getBucketIdentifier(), "DOES-NOT-EXIST");
Assert.fail("Should have thrown exception");
} catch (NiFiRegistryException nfe) {
Assert.assertEquals("Error retrieving latest snapshot metadata: The specified flow ID does not exist in this bucket.", nfe.getMessage());
}
// ---------------------- TEST ITEMS --------------------------//
final ItemsClient itemsClient = client.getItemsClient();
// get fields
final Fields itemFields = itemsClient.getFields();
Assert.assertNotNull(itemFields.getFields());
Assert.assertTrue(itemFields.getFields().size() > 0);
// get all items
final List<BucketItem> allItems = itemsClient.getAll();
Assert.assertEquals(2, allItems.size());
allItems.stream().forEach(i -> Assert.assertNotNull(i.getBucketName()));
allItems.stream().forEach(i -> LOGGER.info("All items, item " + i.getIdentifier()));
// get items for bucket
final List<BucketItem> bucketItems = itemsClient.getByBucket(flowsBucket.getIdentifier());
Assert.assertEquals(2, bucketItems.size());
allItems.stream().forEach(i -> Assert.assertNotNull(i.getBucketName()));
bucketItems.stream().forEach(i -> LOGGER.info("Items in bucket, item " + i.getIdentifier()));
// ----------------------- TEST DIFF ---------------------------//
final VersionedFlowSnapshot snapshot3 = buildSnapshot(snapshotFlow, 3);
final VersionedProcessGroup newlyAddedPG = new VersionedProcessGroup();
newlyAddedPG.setIdentifier("new-pg");
newlyAddedPG.setName("NEW Process Group");
snapshot3.getFlowContents().getProcessGroups().add(newlyAddedPG);
snapshotClient.create(snapshot3);
VersionedFlowDifference diff = flowClient.diff(snapshotFlow.getBucketIdentifier(), snapshotFlow.getIdentifier(), 3, 2);
Assert.assertNotNull(diff);
Assert.assertEquals(1, diff.getComponentDifferenceGroups().size());
// ---------------------- DELETE DATA --------------------------//
final VersionedFlow deletedFlow1 = flowClient.delete(flowsBucket.getIdentifier(), flow1.getIdentifier());
Assert.assertNotNull(deletedFlow1);
LOGGER.info("Deleted flow " + deletedFlow1.getIdentifier());
final VersionedFlow deletedFlow2 = flowClient.delete(flowsBucket.getIdentifier(), flow2.getIdentifier());
Assert.assertNotNull(deletedFlow2);
LOGGER.info("Deleted flow " + deletedFlow2.getIdentifier());
// delete each bucket
for (final Bucket bucket : createdBuckets) {
final Bucket deletedBucket = bucketClient.delete(bucket.getIdentifier());
Assert.assertNotNull(deletedBucket);
LOGGER.info("Deleted bucket " + deletedBucket.getIdentifier());
}
Assert.assertEquals(0, bucketClient.getAll().size());
LOGGER.info("!!! SUCCESS !!!");
}
use of org.apache.nifi.registry.client.BucketClient in project nifi by apache.
the class CreateBucket method doExecute.
@Override
public StringResult doExecute(final NiFiRegistryClient client, final Properties properties) throws IOException, NiFiRegistryException, MissingOptionException {
final String bucketName = getRequiredArg(properties, CommandOption.BUCKET_NAME);
final String bucketDesc = getArg(properties, CommandOption.BUCKET_DESC);
final Bucket bucket = new Bucket();
bucket.setName(bucketName);
bucket.setDescription(bucketDesc);
final BucketClient bucketClient = client.getBucketClient();
final Bucket createdBucket = bucketClient.create(bucket);
return new StringResult(createdBucket.getIdentifier(), getContext().isInteractive());
}
use of org.apache.nifi.registry.client.BucketClient in project nifi by apache.
the class DeleteBucket method doExecute.
@Override
public OkResult doExecute(final NiFiRegistryClient client, final Properties properties) throws IOException, NiFiRegistryException, ParseException {
final String bucketId = getRequiredArg(properties, CommandOption.BUCKET_ID);
final boolean forceDelete = properties.containsKey(CommandOption.FORCE.getLongName());
final FlowClient flowClient = client.getFlowClient();
final List<VersionedFlow> flowsInBucket = flowClient.getByBucket(bucketId);
if (flowsInBucket != null && flowsInBucket.size() > 0 && !forceDelete) {
throw new NiFiRegistryException("Bucket is not empty, use --" + CommandOption.FORCE.getLongName() + " to delete");
} else {
final BucketClient bucketClient = client.getBucketClient();
bucketClient.delete(bucketId);
return new OkResult(getContext().isInteractive());
}
}
Aggregations