Example usage for com.amazonaws.services.sns AmazonSNSClient subscribe

List of usage examples for com.amazonaws.services.sns AmazonSNSClient subscribe

  1. HOME
  2. Java
  3. com.amazonaws
  4. com.amazonaws.services.sns.*
  5. AmazonSNSClient
  6. subscribe

Introduction

In this page you can find the example usage for com.amazonaws.services.sns AmazonSNSClient subscribe.

Prototype

@Override
public SubscribeResult subscribe(SubscribeRequest request)

Source Link

Document

Prepares to subscribe an endpoint by sending the endpoint a confirmation message.

Usage

From source file:awslabs.lab31.SolutionCode.java

License:Open Source License

@Override
public void createSubscription(AmazonSNSClient snsClient, String queueArn, String topicArn) {
    // TODO: Construct a SubscribeRequest object using the "sqs" protocol for the specified queue ARN endpoint and
    // topic ARN.
    SubscribeRequest subscribeRequest = new SubscribeRequest().withEndpoint(queueArn).withProtocol("sqs")
            .withTopicArn(topicArn);/*from   w  w  w  . ja  va2 s . c  o m*/

    // TODO: Submit the request using the subscribe method of the snsClient object.
    snsClient.subscribe(subscribeRequest);
}

From source file:awslabs.lab31.StudentCode.java

License:Open Source License

/**
 * Create an SNS subscription that publishes notifications to an SQS queue. Hint: Use the subscribe() method of the
 * client object. The subscription endpoint is provided to you in the queueArn parameter.
 * //from ww w .  j av a 2s. c o  m
 * @param snsClient The SNS client object.
 * @param queueArn The ARN for the queue that will be used as the subscription endpoint.
 * @param topicArn The ARN for the topic to subscribe to.
 */
@Override
public void createSubscription(AmazonSNSClient snsClient, String queueArn, String topicArn) {
    SubscribeRequest request = new SubscribeRequest().withEndpoint(queueArn).withProtocol("sqs")
            .withTopicArn(topicArn);

    snsClient.subscribe(request);
}

From source file:com.comcast.cmb.test.tools.CMBTutorial.java

License:Apache License

public static void main(String[] args) {

    try {//from w w  w.  j av  a  2 s  .co m

        Util.initLog4jTest();

        //TODO: set user id and credentials for two distinct users

        // user "cqs_test_1"

        //BasicAWSCredentials user1Credentials = new BasicAWSCredentials("<access_key>", "<secret_key>");

        BasicAWSCredentials user1Credentials = new BasicAWSCredentials("Z2DVBFRNZ2C2SSXDWS5F",
                "bH2UQiJkpctBaE3eaDob19fj5J9Q1FVafrZantBp");

        // user "cqs_test_2"

        //String user2Id = "<user_id>";
        String user2Id = "389653920093";

        //BasicAWSCredentials user2Credentials = new BasicAWSCredentials("<access_key>", "<secret_key>");

        BasicAWSCredentials user2Credentials = new BasicAWSCredentials("QL8Q1VOBCSJC5FZ2DMIU",
                "n6a82gyJZ04Z+Xqp7OgfqPtbbKqVc3UbuOTNrF+7");

        // service urls

        //TODO: add service URLs

        //String cqsServerUrl = "http://<host>:<port>";
        //String cnsServerUrl = "http://<host>:<port>";

        String cqsServerUrl = "http://localhost:6059";
        String cnsServerUrl = "http://localhost:6061";

        // initialize service

        AmazonSQSClient sqs = new AmazonSQSClient(user1Credentials);
        sqs.setEndpoint(cqsServerUrl);

        AmazonSNSClient sns = new AmazonSNSClient(user2Credentials);
        sns.setEndpoint(cnsServerUrl);

        // create queue

        Random randomGenerator = new Random();

        String queueName = QUEUE_PREFIX + randomGenerator.nextLong();

        HashMap<String, String> attributeParams = new HashMap<String, String>();
        CreateQueueRequest createQueueRequest = new CreateQueueRequest(queueName);
        createQueueRequest.setAttributes(attributeParams);
        String queueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();

        AddPermissionRequest addPermissionRequest = new AddPermissionRequest();
        addPermissionRequest.setQueueUrl(queueUrl);
        addPermissionRequest.setActions(Arrays.asList("SendMessage"));
        addPermissionRequest.setLabel(UUID.randomUUID().toString());
        addPermissionRequest.setAWSAccountIds(Arrays.asList(user2Id));
        sqs.addPermission(addPermissionRequest);

        // create topic

        String topicName = "TSTT" + randomGenerator.nextLong();

        CreateTopicRequest createTopicRequest = new CreateTopicRequest(topicName);
        CreateTopicResult createTopicResult = sns.createTopic(createTopicRequest);
        String topicArn = createTopicResult.getTopicArn();

        // subscribe and confirm cqs endpoint

        SubscribeRequest subscribeRequest = new SubscribeRequest();
        String queueArn = getArnForQueueUrl(queueUrl);
        subscribeRequest.setEndpoint(queueArn);
        subscribeRequest.setProtocol("cqs");
        subscribeRequest.setTopicArn(topicArn);
        SubscribeResult subscribeResult = sns.subscribe(subscribeRequest);
        String subscriptionArn = subscribeResult.getSubscriptionArn();

        if (subscriptionArn.equals("pending confirmation")) {

            Thread.sleep(500);

            ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
            receiveMessageRequest.setQueueUrl(queueUrl);
            receiveMessageRequest.setMaxNumberOfMessages(1);
            ReceiveMessageResult receiveMessageResult = sqs.receiveMessage(receiveMessageRequest);

            List<Message> messages = receiveMessageResult.getMessages();

            if (messages != null && messages.size() == 1) {

                JSONObject o = new JSONObject(messages.get(0).getBody());

                if (!o.has("SubscribeURL")) {
                    throw new Exception("message is not a confirmation messsage");
                }

                String subscriptionUrl = o.getString("SubscribeURL");
                httpGet(subscriptionUrl);

                DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest();
                deleteMessageRequest.setReceiptHandle(messages.get(0).getReceiptHandle());
                deleteMessageRequest.setQueueUrl(queueUrl);
                sqs.deleteMessage(deleteMessageRequest);

            } else {
                throw new Exception("no confirmation message found");
            }
        }

        // publish and receive message

        PublishRequest publishRequest = new PublishRequest();
        String messageText = "quamvis sint sub aqua, sub aqua maledicere temptant";
        publishRequest.setMessage(messageText);
        publishRequest.setSubject("unit test message");
        publishRequest.setTopicArn(topicArn);
        sns.publish(publishRequest);

        Thread.sleep(500);

        ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
        receiveMessageRequest.setQueueUrl(queueUrl);
        receiveMessageRequest.setMaxNumberOfMessages(1);
        ReceiveMessageResult receiveMessageResult = sqs.receiveMessage(receiveMessageRequest);

        List<Message> messages = receiveMessageResult.getMessages();

        if (messages != null && messages.size() == 1) {

            String messageBody = messages.get(0).getBody();

            if (!messageBody.contains(messageText)) {
                throw new Exception("message text not found");
            }

            DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest();
            deleteMessageRequest.setReceiptHandle(messages.get(0).getReceiptHandle());
            deleteMessageRequest.setQueueUrl(queueUrl);
            sqs.deleteMessage(deleteMessageRequest);

        } else {
            throw new Exception("no messages found");
        }

        // subscribe and confirm http endpoint

        String id = randomGenerator.nextLong() + "";
        String endPointUrl = CMBTestingConstants.HTTP_ENDPOINT_BASE_URL + "recv/" + id;
        String lastMessageUrl = CMBTestingConstants.HTTP_ENDPOINT_BASE_URL + "info/" + id + "?showLast=true";

        subscribeRequest = new SubscribeRequest();
        subscribeRequest.setEndpoint(endPointUrl);
        subscribeRequest.setProtocol("http");
        subscribeRequest.setTopicArn(topicArn);
        subscribeResult = sns.subscribe(subscribeRequest);
        subscriptionArn = subscribeResult.getSubscriptionArn();

        if (subscriptionArn.equals("pending confirmation")) {

            Thread.sleep(500);

            String response = httpGet(lastMessageUrl);

            JSONObject o = new JSONObject(response);

            if (!o.has("SubscribeURL")) {
                throw new Exception("message is not a confirmation messsage");
            }

            String subscriptionUrl = o.getString("SubscribeURL");

            response = httpGet(subscriptionUrl);
        }

        // publish and receive message

        publishRequest = new PublishRequest();
        publishRequest.setMessage(messageText);
        publishRequest.setSubject("unit test message");
        publishRequest.setTopicArn(topicArn);
        sns.publish(publishRequest);

        Thread.sleep(500);

        String response = httpGet(lastMessageUrl);

        if (response != null && response.length() > 0) {

            if (!response.contains(messageText)) {
                throw new Exception("message text not found");
            }

        } else {
            throw new Exception("no messages found");
        }

        // delete queue and topic

        DeleteTopicRequest deleteTopicRequest = new DeleteTopicRequest(topicArn);
        sns.deleteTopic(deleteTopicRequest);

        sqs.deleteQueue(new DeleteQueueRequest(queueUrl));

        System.out.println("OK");

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

From source file:com.connexience.server.model.archive.glacier.SetupUtils.java

License:Open Source License

public static String setupSNS(String accessKey, String secretKey, String domainName, String vaultName,
        String queueARN) {/*from   www.  j  a v a 2  s .co m*/
    String topicARN = null;
    try {
        AWSCredentials awsCredentials = new BasicAWSCredentials(accessKey, secretKey);

        AmazonSNSClient amazonSNSClient = new AmazonSNSClient(awsCredentials);
        amazonSNSClient.setEndpoint("https://sns." + domainName + ".amazonaws.com/");

        String topicName = vaultName + "-inkspot_glacier-topic";
        CreateTopicRequest createTopicRequest = new CreateTopicRequest();
        createTopicRequest.withName(topicName);

        CreateTopicResult createTopicResult = amazonSNSClient.createTopic(createTopicRequest);
        if (createTopicResult != null) {
            topicARN = createTopicResult.getTopicArn();

            SubscribeRequest subscribeRequest = new SubscribeRequest();
            subscribeRequest.withTopicArn(topicARN);
            subscribeRequest.withProtocol("sqs");
            subscribeRequest.withEndpoint(queueARN);

            SubscribeResult subscribeResult = amazonSNSClient.subscribe(subscribeRequest);
            if (subscribeResult == null)
                logger.warn("Unable to subscribe topic: \"" + topicName + "\" to queue: \"" + queueARN + "\"");
        } else
            logger.warn("Unable to create topic: \"" + topicName + "\"");

        amazonSNSClient.shutdown();
    } catch (AmazonServiceException amazonServiceException) {
        logger.warn("AmazonServiceException: " + amazonServiceException);
        logger.debug(amazonServiceException);
    } catch (IllegalArgumentException illegalArgumentException) {
        logger.warn("IllegalArgumentException: " + illegalArgumentException);
        logger.debug(illegalArgumentException);
    } catch (AmazonClientException amazonClientException) {
        logger.warn("AmazonClientException: " + amazonClientException);
        logger.debug(amazonClientException);
    } catch (Throwable throwable) {
        logger.warn("Throwable: " + throwable);
        logger.debug(throwable);
    }

    return topicARN;
}

From source file:org.apache.usergrid.persistence.queue.impl.SNSQueueManagerImpl.java

License:Apache License

private String setupTopics(final String queueName) throws Exception {

    logger.info("Setting up setupTopics SNS/SQS...");

    String primaryTopicArn = AmazonNotificationUtils.getTopicArn(sns, queueName, true);

    if (logger.isTraceEnabled()) {
        logger.trace("SNS/SQS Setup: primaryTopicArn={}", primaryTopicArn);
    }//from   w w  w .  j a v a 2  s .  c  om

    String queueUrl = AmazonNotificationUtils.getQueueUrlByName(sqs, queueName);
    String primaryQueueArn = AmazonNotificationUtils.getQueueArnByName(sqs, queueName);

    if (logger.isTraceEnabled()) {
        logger.trace("SNS/SQS Setup: primaryQueueArn={}", primaryQueueArn);
    }

    if (primaryQueueArn == null) {
        if (logger.isTraceEnabled()) {
            logger.trace("SNS/SQS Setup: primaryQueueArn is null, creating queue...");
        }

        queueUrl = AmazonNotificationUtils.createQueue(sqs, queueName, fig);
        primaryQueueArn = AmazonNotificationUtils.getQueueArnByUrl(sqs, queueUrl);

        if (logger.isTraceEnabled()) {
            logger.trace("SNS/SQS Setup: New Queue URL=[{}] ARN=[{}]", queueUrl, primaryQueueArn);
        }
    }

    try {

        SubscribeRequest primarySubscribeRequest = new SubscribeRequest(primaryTopicArn, "sqs",
                primaryQueueArn);
        sns.subscribe(primarySubscribeRequest);

        // ensure the SNS primary topic has permission to send to the primary SQS queue
        List<String> primaryTopicArnList = new ArrayList<>();
        primaryTopicArnList.add(primaryTopicArn);
        AmazonNotificationUtils.setQueuePermissionsToReceive(sqs, queueUrl, primaryTopicArnList);
    } catch (AmazonServiceException e) {
        logger.error("Unable to subscribe PRIMARY queue=[{}] to topic=[{}]", queueUrl, primaryTopicArn, e);
    }

    if (fig.isMultiRegion() && scope.getRegionImplementation() == LegacyQueueScope.RegionImplementation.ALL) {

        String multiRegion = fig.getRegionList();

        if (logger.isTraceEnabled()) {
            logger.trace("MultiRegion Setup specified, regions: [{}]", multiRegion);
        }

        String[] regionNames = multiRegion.split(",");

        final Map<String, String> arrQueueArns = new HashMap<>(regionNames.length + 1);
        final Map<String, String> topicArns = new HashMap<>(regionNames.length + 1);

        arrQueueArns.put(primaryQueueArn, fig.getPrimaryRegion());
        topicArns.put(primaryTopicArn, fig.getPrimaryRegion());

        for (String regionName : regionNames) {

            regionName = regionName.trim();
            Regions regions = Regions.fromName(regionName);
            Region region = Region.getRegion(regions);

            AmazonSQSClient sqsClient = createSQSClient(region);
            AmazonSNSClient snsClient = createSNSClient(region); // do this stuff synchronously

            // getTopicArn will create the SNS topic if it doesn't exist
            String topicArn = AmazonNotificationUtils.getTopicArn(snsClient, queueName, true);
            topicArns.put(topicArn, regionName);

            // create the SQS queue if it doesn't exist
            String queueArn = AmazonNotificationUtils.getQueueArnByName(sqsClient, queueName);
            if (queueArn == null) {
                queueUrl = AmazonNotificationUtils.createQueue(sqsClient, queueName, fig);
                queueArn = AmazonNotificationUtils.getQueueArnByUrl(sqsClient, queueUrl);
            }

            arrQueueArns.put(queueArn, regionName);
        }

        if (logger.isTraceEnabled()) {
            logger.trace("Creating Subscriptions...");
        }

        for (Map.Entry<String, String> queueArnEntry : arrQueueArns.entrySet()) {
            String queueARN = queueArnEntry.getKey();
            String strSqsRegion = queueArnEntry.getValue();

            Regions sqsRegions = Regions.fromName(strSqsRegion);
            Region sqsRegion = Region.getRegion(sqsRegions);

            AmazonSQSClient subscribeSqsClient = createSQSClient(sqsRegion);

            // ensure the URL used to subscribe is for the correct name/region
            String subscribeQueueUrl = AmazonNotificationUtils.getQueueUrlByName(subscribeSqsClient, queueName);

            // this list used later for adding permissions to queues
            List<String> topicArnList = new ArrayList<>();

            for (Map.Entry<String, String> topicArnEntry : topicArns.entrySet()) {

                String topicARN = topicArnEntry.getKey();
                topicArnList.add(topicARN);

                String strSnsRegion = topicArnEntry.getValue();
                Regions snsRegions = Regions.fromName(strSnsRegion);
                Region snsRegion = Region.getRegion(snsRegions);

                AmazonSNSClient subscribeSnsClient = createSNSClient(snsRegion); // do this stuff synchronously
                SubscribeRequest subscribeRequest = new SubscribeRequest(topicARN, "sqs", queueARN);

                try {

                    logger.info("Subscribing Queue ARN/Region=[{} / {}] and Topic ARN/Region=[{} / {}]",
                            queueARN, strSqsRegion, topicARN, strSnsRegion);

                    SubscribeResult subscribeResult = subscribeSnsClient.subscribe(subscribeRequest);
                    String subscriptionARN = subscribeResult.getSubscriptionArn();
                    if (logger.isTraceEnabled()) {
                        logger.trace(
                                "Successfully subscribed Queue ARN=[{}] to Topic ARN=[{}], subscription ARN=[{}]",
                                queueARN, topicARN, subscriptionARN);
                    }
                } catch (Exception e) {
                    logger.error("ERROR Subscribing Queue ARN/Region=[{} / {}] and Topic ARN/Region=[{} / {}]",
                            queueARN, strSqsRegion, topicARN, strSnsRegion, e);
                }
            }

            if (logger.isTraceEnabled()) {
                logger.trace("Adding permission to receive messages...");
            }
            // add permission to each queue, providing a list of topics that it's subscribed to
            AmazonNotificationUtils.setQueuePermissionsToReceive(subscribeSqsClient, subscribeQueueUrl,
                    topicArnList);
        }
    }

    return primaryTopicArn;
}

From source file:shnakkydoodle.notifying.provider.aws.AwsProvider.java

License:Open Source License

/**
 * Insert a notificaition subscription// www . j  a  va  2s . c  om
 * 
 * @param topicName
 * @param protocol
 * @param endpoint
 * 
 */
@Override
public void insertNotificationSubscription(String topicName, String protocol, String endpoint) {
    AmazonSNSClient snsClient = getSNSClient();
    NotificationTopic notificationTopic = this.retrieveNotificationTopic(topicName);
    if (notificationTopic == null) {
        this.insertNotificationTopic(topicName, "");
    }
    notificationTopic = this.retrieveNotificationTopic(topicName);
    SubscribeRequest subRequest = new SubscribeRequest(notificationTopic.getTopicId(), protocol, endpoint);
    snsClient.subscribe(subRequest);
}