com.amazonaws.services.sns.model.ListTopicsResult Java Examples

@Override
public Optional<MetaData> meta(Map<String, Object> parameters) {
    final String accessKey = ConnectorOptions.extractOption(parameters, "accessKey");
    final String secretKey = ConnectorOptions.extractOption(parameters, "secretKey");
    final String region = ConnectorOptions.extractOption(parameters, "region");
    AmazonSNSClientBuilder clientBuilder;
    AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
    AWSCredentialsProvider credentialsProvider = new AWSStaticCredentialsProvider(credentials);
    clientBuilder = AmazonSNSClientBuilder.standard().withCredentials(credentialsProvider);
    clientBuilder = clientBuilder.withRegion(Regions.valueOf(region));
    AmazonSNS sqsClient = clientBuilder.build();
    try {
        ListTopicsResult result = sqsClient.listTopics();
        Set<String> setTopic = new HashSet<String>();
        if (result.getTopics() != null) {
            for (Topic entry : result.getTopics()) {
            	setTopic.add(entry.getTopicArn());
            }
        }
        return Optional.of(MetaDataBuilder.on(getCamelContext()).withAttribute(MetaData.CONTENT_TYPE, "text/plain").withAttribute(MetaData.JAVA_TYPE, String.class)
            .withPayload(setTopic).build());
    } catch (Exception e) {
        throw new IllegalStateException("Get information about existing topics with has failed.", e);
    }
}
 

@Test
public void shouldCreateSnsTopicResource_withName() throws Exception {
    // Given
    final String name = randomString();
    final String topicArn = topicArnForName(name);
    final List<Topic> topics = Arrays.asList(randomTopic(), randomTopic(), topicForArn(topicArn), randomTopic());
    final ListTopicsResult mockListTopicsResult = mock(ListTopicsResult.class);
    when(mockListTopicsResult.getTopics()).thenReturn(topics);
    when(mockListTopicsResult.getNextToken()).thenReturn(null);
    final String nextToken = null;
    when(mockAmazonSnsClient.listTopics(nextToken)).thenReturn(mockListTopicsResult);
    final SnsTopicResource mockSnsTopicResource = mock(SnsTopicResource.class);
    whenNew(SnsTopicResource.class).withArguments(name, topicArn, mockAmazonSnsClient)
            .thenReturn(mockSnsTopicResource);

    // When
    final SnsTopicResource result = factory.createSnsTopicResource(name);

    // Then
    assertSame(mockSnsTopicResource, result);
}
 

private String getTopicResourceName(String marker, String topicName) {
	ListTopicsResult listTopicsResult = this.amazonSns
			.listTopics(new ListTopicsRequest(marker));
	for (Topic topic : listTopicsResult.getTopics()) {
		AmazonResourceName resourceName = AmazonResourceName
				.fromString(topic.getTopicArn());
		if (resourceName.getResourceType().equals(topicName)) {
			return topic.getTopicArn();
		}
	}

	if (StringUtils.hasText(listTopicsResult.getNextToken())) {
		return getTopicResourceName(listTopicsResult.getNextToken(), topicName);
	}
	else {
		throw new IllegalArgumentException(
				"No topic found for name :'" + topicName + "'");
	}
}
 

@Test
void resolveDestination_withNonExistentTopicAndWithoutMarkerReturnedOnListTopics_shouldThrowIllegalArgumentException()
		throws Exception {
	// @checkstyle:on
	// Arrange
	AmazonSNS sns = mock(AmazonSNS.class);
	when(sns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult());

	DynamicTopicDestinationResolver resolver = new DynamicTopicDestinationResolver(
			sns);

	// Assert
	assertThatThrownBy(() -> resolver.resolveDestination("test"))
			.isInstanceOf(IllegalArgumentException.class)
			.hasMessageContaining("No topic found for name :'test'");
}
 

@Test
void resolveDestination_withNonExistentTopicAndWithMarkerReturnedOnListTopics_shouldCallListMultipleTimeWithMarkerAndThrowIllegalArgumentException()
		// @checkstyle:on
		throws Exception {
	// Arrange
	AmazonSNS sns = mock(AmazonSNS.class);
	when(sns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult().withNextToken("foo"));
	when(sns.listTopics(new ListTopicsRequest("foo")))
			.thenReturn(new ListTopicsResult());

	DynamicTopicDestinationResolver resolver = new DynamicTopicDestinationResolver(
			sns);

	// Assert
	assertThatThrownBy(() -> resolver.resolveDestination("test"))
			.isInstanceOf(IllegalArgumentException.class)
			.hasMessageContaining("No topic found for name :'test'");
}
 

@Test
void resolveDestination_withExistentTopic_returnsTopicArnFoundWhileListingTopic()
		throws Exception {
	// Arrange
	String topicArn = "arn:aws:sns:eu-west:123456789012:test";

	AmazonSNS sns = mock(AmazonSNS.class);
	when(sns.listTopics(new ListTopicsRequest(null))).thenReturn(
			new ListTopicsResult().withTopics(new Topic().withTopicArn(topicArn)));

	DynamicTopicDestinationResolver resolver = new DynamicTopicDestinationResolver(
			sns);

	// Act
	String resolvedDestinationName = resolver.resolveDestination("test");

	// Assert
	assertThat(resolvedDestinationName).isEqualTo(topicArn);
}
 

@Test
void resolveDestination_withExistentTopicAndMarker_returnsTopicArnFoundWhileListingTopic()
		throws Exception {
	// Arrange

	AmazonSNS sns = mock(AmazonSNS.class);
	when(sns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult().withNextToken("mark"));

	String topicArn = "arn:aws:sns:eu-west:123456789012:test";
	when(sns.listTopics(new ListTopicsRequest("mark"))).thenReturn(
			new ListTopicsResult().withTopics(new Topic().withTopicArn(topicArn)));

	DynamicTopicDestinationResolver resolver = new DynamicTopicDestinationResolver(
			sns);

	// Act
	String resolvedDestinationName = resolver.resolveDestination("test");

	// Assert
	assertThat(resolvedDestinationName).isEqualTo(topicArn);
}
 

@Test
void resolveDestination_withResourceIdResolver_shouldCallIt() throws Exception {
	// Arrange
	String physicalTopicName = "arn:aws:sns:eu-west:123456789012:myTopic";
	String logicalTopicName = "myTopic";

	ResourceIdResolver resourceIdResolver = mock(ResourceIdResolver.class);
	when(resourceIdResolver.resolveToPhysicalResourceId(logicalTopicName))
			.thenReturn(physicalTopicName);

	AmazonSNS sns = mock(AmazonSNS.class);
	when(sns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult()
					.withTopics(new Topic().withTopicArn(physicalTopicName)));

	DynamicTopicDestinationResolver resolver = new DynamicTopicDestinationResolver(
			sns, resourceIdResolver);

	// Assert
	String resolvedDestinationName = resolver.resolveDestination(logicalTopicName);

	// Assert
	assertThat(resolvedDestinationName).isEqualTo(physicalTopicName);
}
 

@Test
void send_validTextMessage_usesTopicChannel() throws Exception {
	// Arrange
	AmazonSNS amazonSns = mock(AmazonSNS.class);
	NotificationMessagingTemplate notificationMessagingTemplate = new NotificationMessagingTemplate(
			amazonSns);
	String physicalTopicName = "arn:aws:sns:eu-west:123456789012:test";
	when(amazonSns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult()
					.withTopics(new Topic().withTopicArn(physicalTopicName)));
	notificationMessagingTemplate.setDefaultDestinationName(physicalTopicName);

	// Act
	notificationMessagingTemplate
			.send(MessageBuilder.withPayload("Message content").build());

	// Assert
	verify(amazonSns)
			.publish(new PublishRequest(physicalTopicName, "Message content", null)
					.withMessageAttributes(isNotNull()));
}
 

@Test
void convertAndSend_withDestinationPayloadAndSubject_shouldSetSubject()
		throws Exception {
	// Arrange
	AmazonSNS amazonSns = mock(AmazonSNS.class);
	NotificationMessagingTemplate notificationMessagingTemplate = new NotificationMessagingTemplate(
			amazonSns);
	String physicalTopicName = "arn:aws:sns:eu-west:123456789012:test";
	when(amazonSns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult()
					.withTopics(new Topic().withTopicArn(physicalTopicName)));

	// Act
	notificationMessagingTemplate.sendNotification(physicalTopicName, "My message",
			"My subject");

	// Assert
	verify(amazonSns)
			.publish(new PublishRequest(physicalTopicName, "My message", "My subject")
					.withMessageAttributes(isNotNull()));
}
 

@Test
void convertAndSend_withPayloadAndSubject_shouldSetSubject() throws Exception {
	// Arrange
	AmazonSNS amazonSns = mock(AmazonSNS.class);
	NotificationMessagingTemplate notificationMessagingTemplate = new NotificationMessagingTemplate(
			amazonSns);
	String physicalTopicName = "arn:aws:sns:eu-west:123456789012:test";
	when(amazonSns.listTopics(new ListTopicsRequest(null)))
			.thenReturn(new ListTopicsResult()
					.withTopics(new Topic().withTopicArn(physicalTopicName)));
	notificationMessagingTemplate.setDefaultDestinationName(physicalTopicName);

	// Act
	notificationMessagingTemplate.sendNotification("My message", "My subject");

	// Assert
	verify(amazonSns)
			.publish(new PublishRequest(physicalTopicName, "My message", "My subject")
					.withMessageAttributes(isNotNull()));
}
 

private String getSnsTopicArn(AmazonSNS amazonSNS, String topicName) {
  ListTopicsResult listTopicsResult = amazonSNS.listTopics();
  String nextToken = listTopicsResult.getNextToken();
  List<Topic> topics = listTopicsResult.getTopics();

  while (nextToken != null) {
    listTopicsResult = amazonSNS.listTopics(nextToken);
    nextToken = listTopicsResult.getNextToken();
    topics.addAll(listTopicsResult.getTopics());
  }

  return topics.stream()
      .filter(t -> t.getTopicArn().toLowerCase().endsWith(":" + topicName.toLowerCase()))
      .map(Topic::getTopicArn)
      .findFirst()
      .orElseThrow(
          () ->
              new IllegalArgumentException("No SNS topic found (topicName: " + topicName + ")"));
}
 

private String topicArnForName(final String name) {
    String nextToken = null;
    String topicArn = null;
    while (topicArn == null) {
        final ListTopicsResult listTopicsResult = amazonSnsClient.listTopics(nextToken);
        topicArn = topicArnForNameInTopics(name, listTopicsResult.getTopics());
        nextToken = listTopicsResult.getNextToken();
        if (nextToken == null) {
            break;
        }
    }
    return topicArn;
}
 

public void connectToTopic(boolean callerIsMaster, int maxAttempts, String userAccountPrincipalId, String userARN) throws Exception {
	
	
	// try up to max attempts to connect to pre-existing topic
	for (int i=0; i<maxAttempts; i++) {
		
		logger.debug("connectToTopic() attempt: " + (i+1));
		
		ListTopicsResult listResult = snsClient.listTopics();
		List<Topic> topics = listResult.getTopics();
		
		while(topics != null) {
			
			for (Topic topic : topics) {

				// note we do index of match....
				if (topic.getTopicArn().indexOf(snsControlTopicName) != -1) {
					snsTopicARN = topic.getTopicArn();
					logger.info("Found existing SNS topic by name: "+snsControlTopicName + " @ " + snsTopicARN);
					break;
				}
			}

			String nextToken = listResult.getNextToken();
			
			if (nextToken != null && snsTopicARN == null) {
				listResult = snsClient.listTopics(nextToken);
				topics = listResult.getTopics();
				
			} else {
				break;
			}
		}
		
		// if consumer, retry, otherwise is master, so just exit quick to create...
		if (snsTopicARN == null && !callerIsMaster) {
			Thread.currentThread().sleep(1000);
			continue;
		} else {
			break; // exit;
		}
	}
	
	
	
	// if master only he can create...
	if (snsTopicARN == null && callerIsMaster) {
		this.snsControlTopicName = this.snsControlTopicName.substring(0,(snsControlTopicName.length() > 80 ? 80 : this.snsControlTopicName.length()));
		
		logger.info("Attempting to create new SNS control channel topic by name: "+this.snsControlTopicName);
		
		CreateTopicResult createTopicResult = snsClient.createTopic(this.snsControlTopicName);
		snsTopicARN = createTopicResult.getTopicArn();
		snsClient.addPermission(snsTopicARN, "Permit_SNSAdd", 
								Arrays.asList(new String[]{userARN}), 
								Arrays.asList(new String[]{"Publish","Subscribe","Receive"}));
		logger.info("Created new SNS control channel topic by name: "+this.snsControlTopicName + " @ " + snsTopicARN);
		
	} else if (snsTopicARN == null) {
		throw new Exception("Worker() cannot start, snsControlTopicName has yet to be created by master?: " + this.snsControlTopicName);
	}
	
	// http://www.jorgjanke.com/2013/01/aws-sns-topic-subscriptions-with-sqs.html
	
	// create SQS queue to get SNS notifications (max 80 len)
	String prefix =  ("s3bktLoaderCC_" + mySourceIdentifier);
	String sqsQueueName = prefix.substring(0,(prefix.length() > 80 ? 80 : prefix.length()));
	
	CreateQueueResult createQueueResult = sqsClient.createQueue(sqsQueueName);
	this.sqsQueueUrl = createQueueResult.getQueueUrl();
	this.sqsQueueARN = sqsClient.getQueueAttributes(sqsQueueUrl, Arrays.asList(new String[]{"QueueArn"})).getAttributes().get("QueueArn");

	Statement statement = new Statement(Effect.Allow)
							.withActions(SQSActions.SendMessage)
							 .withPrincipals(new Principal("*"))
							 .withConditions(ConditionFactory.newSourceArnCondition(snsTopicARN))
							 .withResources(new Resource(sqsQueueARN));
	Policy policy = new Policy("SubscriptionPermission").withStatements(statement);

	HashMap<String, String> attributes = new HashMap<String, String>();
	attributes.put("Policy", policy.toJson());
	SetQueueAttributesRequest request = new SetQueueAttributesRequest(sqsQueueUrl, attributes);
	sqsClient.setQueueAttributes(request);

	logger.info("Created SQS queue: " + sqsQueueARN + " @ " + sqsQueueUrl);
	
	// subscribe our SQS queue to the SNS:s3MountTest topic
	SubscribeResult subscribeResult = snsClient.subscribe(snsTopicARN,"sqs",sqsQueueARN);
	snsSubscriptionARN = subscribeResult.getSubscriptionArn();
	logger.info("Subscribed for messages from SNS control channel:" + snsTopicARN + " ----> SQS: "+sqsQueueARN);
	logger.info("Subscription ARN: " + snsSubscriptionARN);
	
	this.consumerThread = new Thread(this,"ControlChannel msg consumer thread");
	this.consumerThread.start();

	logger.info("\n-------------------------------------------\n" +
				"CONTROL CHANNEL: ALL SNS/SQS resources hooked up OK\n" +
				"-------------------------------------------\n");
}
 

public static String getTopicArn( final AmazonSNSClient sns, final String queueName, final boolean createOnMissing )
    throws Exception {

    if ( logger.isTraceEnabled() ) {
        logger.trace( "Looking up Topic ARN: {}", queueName );
    }

    ListTopicsResult listTopicsResult = sns.listTopics();
    String topicArn = null;

    for ( Topic topic : listTopicsResult.getTopics() ) {
        String arn = topic.getTopicArn();

        if ( queueName.equals( arn.substring( arn.lastIndexOf( ':' ) ) ) ) {
            topicArn = arn;

            if (logger.isTraceEnabled()) {
                logger.trace( "Found existing topic arn=[{}] for queue=[{}]", topicArn, queueName );
            }
        }
    }

    if ( topicArn == null && createOnMissing ) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating topic for queue=[{}]...", queueName);
        }

        CreateTopicResult createTopicResult = sns.createTopic( queueName );
        topicArn = createTopicResult.getTopicArn();

        if (logger.isTraceEnabled()) {
            logger.trace("Successfully created topic with name {} and arn {}", queueName, topicArn);
        }
    }
    else {
        logger.error( "Error looking up topic ARN for queue=[{}] and createOnMissing=[{}]", queueName,
            createOnMissing );
    }

    if ( logger.isTraceEnabled() ) {
        logger.trace( "Returning Topic ARN=[{}] for Queue=[{}]", topicArn, queueName );
    }


    return topicArn;
}