public IHttpActionResult GetSubscription()
{
try
{
ConfigureNLog();
NLog.LogManager.GetLogger("aws").Info("GetSubscription Entered");
var endpoint = ConfigurationManager.AppSettings["SnsEndpoint"];
var topicarn = ConfigurationManager.AppSettings["SnsEventsTopicArn"];
var client = new Amazon.SimpleNotificationService.AmazonSimpleNotificationServiceClient();
var request = new AM.SubscribeRequest
{
Protocol = "https",
Endpoint = endpoint,
TopicArn = topicarn
};
var response = client.Subscribe(request);
NLog.LogManager.GetLogger("aws").Info("GetSubscription returned response SubscriptionArn=" + response.SubscriptionArn);
return(Ok(response.SubscriptionArn)); //TODO - stuff this in database, on PostConfirmation verify response topic is pending
}
catch (Exception ex)
{
string msg = ex.ToString();
try
{
NLog.LogManager.GetLogger("aws").Info("GetSubscription got error " + ex.ToString());
} catch (Exception ex2)
{
}
return(BadRequest("AN ERROR HAPEPNED: " + msg));
}
}
public static bool Add_SQS_Subscription(String topic_arn, String sqs_Q_listener_arn)
{
SubscribeRequest request = new SubscribeRequest();
request.Protocol = "SQS";
request.Endpoint = sqs_Q_listener_arn;
request.TopicArn = topic_arn;
SubscribeResponse response = sns_client.Subscribe(request);
return true;
}
public static void CreateEmailSubscription(string topicArn, string emailAddress)
{
using (var client = new AmazonSimpleNotificationServiceClient(Settings.AccessKey, Settings.Secret))
{
var request = new SubscribeRequest(topicArn, "email", emailAddress);
client.Subscribe(request);
}
}
public string SubscribeQueueToTopic(string queueArn, string topicArn)
{
queueArn.Requires("queueArn").IsNotNullOrWhiteSpace();
topicArn.Requires("topicArn").IsNotNullOrWhiteSpace();
var subScribeRequest = new SubscribeRequest(topicArn, SqsProtocol, queueArn);
using (var sns = amazonSnsFactory())
{
var response = sns.Subscribe(subScribeRequest);
return response?.SubscriptionArn;
}
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
// create request
var request = new Amazon.SimpleNotificationService.Model.SubscribeRequest();
if (cmdletContext.Attribute != null)
{
request.Attributes = cmdletContext.Attribute;
}
if (cmdletContext.Endpoint != null)
{
request.Endpoint = cmdletContext.Endpoint;
}
if (cmdletContext.Protocol != null)
{
request.Protocol = cmdletContext.Protocol;
}
if (cmdletContext.ReturnSubscriptionArn != null)
{
request.ReturnSubscriptionArn = cmdletContext.ReturnSubscriptionArn.Value;
}
if (cmdletContext.TopicArn != null)
{
request.TopicArn = cmdletContext.TopicArn;
}
CmdletOutput output;
// issue call
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
pipelineOutput = cmdletContext.Select(response, this);
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
}
catch (Exception e)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
return(output);
}
public string SubscribeQueueToTopic(string queueArn, string topicArn)
{
Validate.That(queueArn).IsNotNullOrEmpty();
Validate.That(topicArn).IsNotNullOrEmpty();
var subScribeRequest =
new SubscribeRequest().WithEndpoint(queueArn).WithProtocol(sqsProtocol).WithTopicArn(topicArn);
using (var sns = amazonSnsFactory())
{
var response = sns.Subscribe(subScribeRequest);
return response.SubscribeResult.SubscriptionArn;
}
}
public virtual void CreateSubscription(AmazonSimpleNotificationServiceClient snsClient, string queueArn,
string topicArn)
{
// Create the request
var subscriptionRequest = new SubscribeRequest
{
Endpoint = queueArn,
Protocol = "sqs",
TopicArn = topicArn
};
// Create the subscription
snsClient.Subscribe(subscriptionRequest);
}
public void subscribe_to_topic()
{
var getArnRequest = new GetQueueAttributesRequest().WithQueueUrl(_queueUrl).WithAttributeName("QueueArn");
var clientArn = _client.GetQueueAttributes(getArnRequest).GetQueueAttributesResult.Attribute[0].Value;
var sns = Amazon.AWSClientFactory.CreateAmazonSNSClient("AKIAIN2KJH4QJIUV7CGQ",
"18ypN0y7SGA+L0XDVMHm9lBVmQ2oF2bdm7CGIijA");
var subscriptionRequest = new SubscribeRequest()
.WithEndpoint(clientArn)
.WithProtocol("sqs")
.WithTopicArn("arn:aws:sns:us-east-1:451419498740:EventMessage");
var response = sns.Subscribe(subscriptionRequest);
Console.WriteLine(response.SubscribeResult.SubscriptionArn);
}
public void Subscribe()
{
SetPermissions();
var getArnRequest = new GetQueueAttributesRequest().WithQueueUrl(_config.SqsQueueUrl).WithAttributeName("QueueArn");
var clientArn = _client.GetQueueAttributes(getArnRequest).GetQueueAttributesResult.Attribute[0].Value;
var sns = AWSClientFactory.CreateAmazonSNSClient(_config.AccessKeyId,
_config.SecretKey);
var subscriptionRequest = new SubscribeRequest()
.WithEndpoint(clientArn)
.WithProtocol("sqs")
.WithTopicArn(_config.TopicAccessResourceName);
sns.Subscribe(subscriptionRequest);
}
public void create_sqs_queue()
{
GetUserNameAndPassword();
var sqsClient = Amazon.AWSClientFactory.CreateAmazonSQSClient(_key, _secret);
var snsTopic = Amazon.AWSClientFactory.CreateAmazonSNSClient(_key, _secret);
var topicArn = "arn:aws:sns:us-east-1:451419498740:Elliott-has-an-awesome-blog";
//Create a new SQS queue
var createQueueRequest = new CreateQueueRequest().WithQueueName("elliotts-blog");
var createQueueResponse = sqsClient.CreateQueue(createQueueRequest);
// keep the queueUrl handy
var queueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
// get the Access Resource Name so we can allow the SNS to put messages on it
var getQueueArnRequest = new GetQueueAttributesRequest()
.WithQueueUrl(queueUrl)
.WithAttributeName("QueueArn");
var getQueueArnResponse = sqsClient.GetQueueAttributes(getQueueArnRequest);
var queueArn = getQueueArnResponse.GetQueueAttributesResult.Attribute[0].Value;
//create a Policy for the SQS queue that allows SNS to publish to it
var allowSnsStatement = new Statement(Statement.StatementEffect.Allow)
.WithPrincipals(Principal.AllUsers)
.WithResources(new Resource(queueArn))
.WithConditions(ConditionFactory.NewSourceArnCondition(topicArn))
.WithActionIdentifiers(SQSActionIdentifiers.SendMessage);
var policy = new Policy("allow sns").WithStatements(new[] {allowSnsStatement});
var attribute = new Attribute().WithName("Policy").WithValue(policy.ToJson());
var setQueueAttributesRequest =
new SetQueueAttributesRequest().WithQueueUrl(queueUrl).WithAttribute(attribute);
sqsClient.SetQueueAttributes(setQueueAttributesRequest);
// ok, now lets create the subscription for sqs with the queueArn we created
var subscribeRequest = new SubscribeRequest()
.WithEndpoint(queueArn)
.WithTopicArn(topicArn)
.WithProtocol("sqs");
snsTopic.Subscribe(subscribeRequest);
}
/// <summary>
/// Creates a user account for SNS
/// </summary>
/// <param name="userName">The user to create a SNS account for</param>
/// <param name="number">The user's phone number</param>
private void CreateSNSAccount(String userName, String number)
{
AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient();
//Create topic first.
CreateTopicRequest request = new CreateTopicRequest
{
Name = userName
};
try
{
CreateTopicResponse response = client.CreateTopic(request);
CreateTopicResult result = response.CreateTopicResult;
String[] strings = new String[1];
strings[0] = "Success! Assigned ARN is: " + result.TopicArn + "\n";
TempData["result"] = strings;
}
catch (Exception e)
{
TempData["error"] = e.Message;
}
String arn = "arn:aws:sns:us-east-1:727060774285:" + userName;
SetTopicAttributesRequest request2 = new SetTopicAttributesRequest
{
AttributeName = "DisplayName",
AttributeValue = "Cookbook",
TopicArn = arn
};
try
{
SetTopicAttributesResponse response = client.SetTopicAttributes(request2);
ResponseMetadata result = response.ResponseMetadata;
Console.WriteLine(result.RequestId);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//Add SMS number to topic.
SubscribeRequest request3 = new SubscribeRequest
{
TopicArn = arn,
Endpoint = number,
Protocol = "sms"
};
try
{
SubscribeResponse response = client.Subscribe(request3);
SubscribeResult result = response.SubscribeResult;
string resultSubscribe = "Success! Subscription Arn is: " + result.SubscriptionArn + "\n";
Console.WriteLine(resultSubscribe);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/// <summary>
/// By subscribe your email account should get a message confirming the topic
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async void subscribe_Click(object sender, EventArgs ex)
{
try
{
var request = new SubscribeRequest()
{
TopicArn = _topicArn,
Protocol = "email",
Endpoint = _emailTextView.Text
};
await snsClient.SubscribeAsync(request);
_statusTextView.Text = "Subscription successful";
}
catch (Exception e)
{
_statusTextView.Text = string.Format("Error subscribing to topic: {0}", e.Message);
}
}
/// <summary>
/// Subscribe to a SNS Topic
/// </summary>
/// <param name="topicArn"></param>
/// <param name="protocol"></param>
/// <param name="endpoint"></param>
/// <returns></returns>
public string Subscribe(string topicArn, string protocol, string endpoint)
{
var request = new SubscribeRequest { TopicArn = topicArn, Protocol = protocol, Endpoint = endpoint };
SubscribeResponse response = Client.Subscribe(request);
Trace.WriteLine(response.SubscribeResult.SubscriptionArn, "SubscriptionArn");
return response.SubscribeResult.SubscriptionArn;
}
IAsyncResult invokeSubscribe(SubscribeRequest request, AsyncCallback callback, object state, bool synchronized)
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer);
}
/// <summary>
/// <para>The <c>Subscribe</c> action prepares to subscribe an endpoint by sending the endpoint a confirmation message. To actually create a
/// subscription, the endpoint owner must call the <c>ConfirmSubscription</c> action with the token from the confirmation message. Confirmation
/// tokens are valid for three days.</para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe service method on
/// AmazonSimpleNotificationService.</param>
///
/// <returns>The response from the Subscribe service method, as returned by AmazonSimpleNotificationService.</returns>
///
/// <exception cref="T:Amazon.SimpleNotificationService.Model.NotFoundException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.AuthorizationErrorException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.InternalErrorException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.InvalidParameterException" />
public SubscribeResponse Subscribe(SubscribeRequest request)
{
var task = SubscribeAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
/// <summary>
/// Prepares to subscribe an endpoint by sending the endpoint a confirmation message.
/// To actually create a subscription, the endpoint owner must call the <code>ConfirmSubscription</code>
/// action with the token from the confirmation message. Confirmation tokens are
/// valid for three days.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the Subscribe service method.</param>
///
/// <returns>The response from the Subscribe service method, as returned by SimpleNotificationService.</returns>
/// <exception cref="Amazon.SimpleNotificationService.Model.AuthorizationErrorException">
/// Indicates that the user has been denied access to the requested resource.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InternalErrorException">
/// Indicates an internal service error.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InvalidParameterException">
/// Indicates that a request parameter does not comply with the associated constraints.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.NotFoundException">
/// Indicates that the requested resource does not exist.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException">
/// Indicates that the customer already owns the maximum allowed number of subscriptions.
/// </exception>
public SubscribeResponse Subscribe(SubscribeRequest request)
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
return Invoke<SubscribeRequest,SubscribeResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// <para>The <c>Subscribe</c> action prepares to subscribe an endpoint by sending the endpoint a confirmation message. To actually create a
/// subscription, the endpoint owner must call the <c>ConfirmSubscription</c> action with the token from the confirmation message. Confirmation
/// tokens are valid for three days.</para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe service method on
/// AmazonSimpleNotificationService.</param>
///
/// <returns>The response from the Subscribe service method, as returned by AmazonSimpleNotificationService.</returns>
///
/// <exception cref="T:Amazon.SimpleNotificationService.Model.NotFoundException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.AuthorizationErrorException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.InternalErrorException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.InvalidParameterException" />
public SubscribeResponse Subscribe(SubscribeRequest request)
{
var task = SubscribeAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Prepares to subscribe an endpoint by sending the endpoint a confirmation message.
/// To actually create a subscription, the endpoint owner must call the <code>ConfirmSubscription</code>
/// action with the token from the confirmation message. Confirmation tokens are valid
/// for three days.
/// </summary>
/// <param name="topicArn">The ARN of the topic you want to subscribe to.</param>
/// <param name="protocol">The protocol you want to use. Supported protocols include: <ul> <li> <code>http</code> -- delivery of JSON-encoded message via HTTP POST </li> <li> <code>https</code> -- delivery of JSON-encoded message via HTTPS POST </li> <li> <code>email</code> -- delivery of message via SMTP </li> <li> <code>email-json</code> -- delivery of JSON-encoded message via SMTP </li> <li> <code>sms</code> -- delivery of message via SMS </li> <li> <code>sqs</code> -- delivery of JSON-encoded message to an Amazon SQS queue </li> <li> <code>application</code> -- delivery of JSON-encoded message to an EndpointArn for a mobile app and device. </li> <li> <code>lambda</code> -- delivery of JSON-encoded message to an AWS Lambda function. </li> </ul></param>
/// <param name="endpoint">The endpoint that you want to receive notifications. Endpoints vary by protocol: <ul> <li> For the <code>http</code> protocol, the endpoint is an URL beginning with "http://" </li> <li> For the <code>https</code> protocol, the endpoint is a URL beginning with "https://" </li> <li> For the <code>email</code> protocol, the endpoint is an email address </li> <li> For the <code>email-json</code> protocol, the endpoint is an email address </li> <li> For the <code>sms</code> protocol, the endpoint is a phone number of an SMS-enabled device </li> <li> For the <code>sqs</code> protocol, the endpoint is the ARN of an Amazon SQS queue </li> <li> For the <code>application</code> protocol, the endpoint is the EndpointArn of a mobile app and device. </li> <li> For the <code>lambda</code> protocol, the endpoint is the ARN of an AWS Lambda function. </li> </ul></param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">
/// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.
/// </param>
///
/// <returns>The response from the Subscribe service method, as returned by SimpleNotificationService.</returns>
/// <exception cref="Amazon.SimpleNotificationService.Model.AuthorizationErrorException">
/// Indicates that the user has been denied access to the requested resource.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InternalErrorException">
/// Indicates an internal service error.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InvalidParameterException">
/// Indicates that a request parameter does not comply with the associated constraints.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.NotFoundException">
/// Indicates that the requested resource does not exist.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException">
/// Indicates that the customer already owns the maximum allowed number of subscriptions.
/// </exception>
public void SubscribeAsync(string topicArn, string protocol, string endpoint, AmazonServiceCallback<SubscribeRequest, SubscribeResponse> callback, AsyncOptions options = null)
{
var request = new SubscribeRequest();
request.TopicArn = topicArn;
request.Protocol = protocol;
request.Endpoint = endpoint;
SubscribeAsync(request, callback, options);
}
/// <summary>
/// Initiates the asynchronous execution of the Subscribe operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe operation on AmazonSimpleNotificationServiceClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void SubscribeAsync(SubscribeRequest request, AmazonServiceCallback<SubscribeRequest, SubscribeResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<SubscribeRequest,SubscribeResponse> responseObject
= new AmazonServiceResult<SubscribeRequest,SubscribeResponse>((SubscribeRequest)req, (SubscribeResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<SubscribeRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// Initiates the asynchronous execution of the Subscribe operation.
/// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<SubscribeResponse> SubscribeAsync(SubscribeRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
return InvokeAsync<SubscribeRequest,SubscribeResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Prepares to subscribe an endpoint by sending the endpoint a confirmation message.
/// To actually create a subscription, the endpoint owner must call the <code>ConfirmSubscription</code>
/// action with the token from the confirmation message. Confirmation tokens are
/// valid for three days.
/// </summary>
/// <param name="topicArn">The ARN of the topic you want to subscribe to.</param>
/// <param name="protocol">The protocol you want to use. Supported protocols include: <ul> <li><code>http</code> -- delivery of JSON-encoded message via HTTP POST</li> <li><code>https</code> -- delivery of JSON-encoded message via HTTPS POST</li> <li><code>email</code> -- delivery of message via SMTP</li> <li><code>email-json</code> -- delivery of JSON-encoded message via SMTP</li> <li><code>sms</code> -- delivery of message via SMS</li> <li><code>sqs</code> -- delivery of JSON-encoded message to an Amazon SQS queue</li> <li><code>application</code> -- delivery of JSON-encoded message to an EndpointArn for a mobile app and device.</li> </ul></param>
/// <param name="endpoint">The endpoint that you want to receive notifications. Endpoints vary by protocol: <ul> <li>For the <code>http</code> protocol, the endpoint is an URL beginning with "http://"</li> <li>For the <code>https</code> protocol, the endpoint is a URL beginning with "https://"</li> <li>For the <code>email</code> protocol, the endpoint is an email address</li> <li>For the <code>email-json</code> protocol, the endpoint is an email address</li> <li>For the <code>sms</code> protocol, the endpoint is a phone number of an SMS-enabled device</li> <li>For the <code>sqs</code> protocol, the endpoint is the ARN of an Amazon SQS queue</li> <li>For the <code>application</code> protocol, the endpoint is the EndpointArn of a mobile app and device.</li> </ul></param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the Subscribe service method, as returned by SimpleNotificationService.</returns>
/// <exception cref="Amazon.SimpleNotificationService.Model.AuthorizationErrorException">
/// Indicates that the user has been denied access to the requested resource.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InternalErrorException">
/// Indicates an internal service error.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InvalidParameterException">
/// Indicates that a request parameter does not comply with the associated constraints.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.NotFoundException">
/// Indicates that the requested resource does not exist.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException">
/// Indicates that the customer already owns the maximum allowed number of subscriptions.
/// </exception>
public Task<SubscribeResponse> SubscribeAsync(string topicArn, string protocol, string endpoint, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new SubscribeRequest();
request.TopicArn = topicArn;
request.Protocol = protocol;
request.Endpoint = endpoint;
return SubscribeAsync(request, cancellationToken);
}
/// <summary>
/// Prepares to subscribe an endpoint by sending the endpoint a confirmation message.
/// To actually create a subscription, the endpoint owner must call the <code>ConfirmSubscription</code>
/// action with the token from the confirmation message. Confirmation tokens are
/// valid for three days.
/// </summary>
/// <param name="topicArn">The ARN of the topic you want to subscribe to.</param>
/// <param name="protocol">The protocol you want to use. Supported protocols include: <ul> <li><code>http</code> -- delivery of JSON-encoded message via HTTP POST</li> <li><code>https</code> -- delivery of JSON-encoded message via HTTPS POST</li> <li><code>email</code> -- delivery of message via SMTP</li> <li><code>email-json</code> -- delivery of JSON-encoded message via SMTP</li> <li><code>sms</code> -- delivery of message via SMS</li> <li><code>sqs</code> -- delivery of JSON-encoded message to an Amazon SQS queue</li> <li><code>application</code> -- delivery of JSON-encoded message to an EndpointArn for a mobile app and device.</li> </ul></param>
/// <param name="endpoint">The endpoint that you want to receive notifications. Endpoints vary by protocol: <ul> <li>For the <code>http</code> protocol, the endpoint is an URL beginning with "http://"</li> <li>For the <code>https</code> protocol, the endpoint is a URL beginning with "https://"</li> <li>For the <code>email</code> protocol, the endpoint is an email address</li> <li>For the <code>email-json</code> protocol, the endpoint is an email address</li> <li>For the <code>sms</code> protocol, the endpoint is a phone number of an SMS-enabled device</li> <li>For the <code>sqs</code> protocol, the endpoint is the ARN of an Amazon SQS queue</li> <li>For the <code>application</code> protocol, the endpoint is the EndpointArn of a mobile app and device.</li> </ul></param>
///
/// <returns>The response from the Subscribe service method, as returned by SimpleNotificationService.</returns>
/// <exception cref="Amazon.SimpleNotificationService.Model.AuthorizationErrorException">
/// Indicates that the user has been denied access to the requested resource.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InternalErrorException">
/// Indicates an internal service error.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.InvalidParameterException">
/// Indicates that a request parameter does not comply with the associated constraints.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.NotFoundException">
/// Indicates that the requested resource does not exist.
/// </exception>
/// <exception cref="Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException">
/// Indicates that the customer already owns the maximum allowed number of subscriptions.
/// </exception>
public SubscribeResponse Subscribe(string topicArn, string protocol, string endpoint)
{
var request = new SubscribeRequest();
request.TopicArn = topicArn;
request.Protocol = protocol;
request.Endpoint = endpoint;
return Subscribe(request);
}
/// <summary>
/// <para>The <c>Subscribe</c> action prepares to subscribe an endpoint by sending the endpoint a confirmation message. To actually create a
/// subscription, the endpoint owner must call the <c>ConfirmSubscription</c> action with the token from the confirmation message. Confirmation
/// tokens are valid for three days.</para>
/// </summary>
///
/// <param name="subscribeRequest">Container for the necessary parameters to execute the Subscribe service method on
/// AmazonSimpleNotificationService.</param>
///
/// <returns>The response from the Subscribe service method, as returned by AmazonSimpleNotificationService.</returns>
///
/// <exception cref="T:Amazon.SimpleNotificationService.Model.NotFoundException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.AuthorizationErrorException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.InternalErrorException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.SubscriptionLimitExceededException" />
/// <exception cref="T:Amazon.SimpleNotificationService.Model.InvalidParameterException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public async Task<SubscribeResponse> SubscribeAsync(SubscribeRequest subscribeRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, SubscribeRequest, SubscribeResponse>(subscribeRequest, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
/// <summary>
/// Initiates the asynchronous execution of the Subscribe operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe operation on AmazonSimpleNotificationServiceClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSubscribe
/// operation.</returns>
public IAsyncResult BeginSubscribe(SubscribeRequest request, AsyncCallback callback, object state)
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.Instance;
return BeginInvoke<SubscribeRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// <para>The <c>Subscribe</c> action prepares to subscribe an endpoint by sending the endpoint a confirmation message. To actually create a
/// subscription, the endpoint owner must call the <c>ConfirmSubscription</c> action with the token from the confirmation message. Confirmation
/// tokens are valid for three days.</para>
/// </summary>
///
/// <param name="subscribeRequest">Container for the necessary parameters to execute the Subscribe service method on
/// AmazonSimpleNotificationService.</param>
///
/// <returns>The response from the Subscribe service method, as returned by AmazonSimpleNotificationService.</returns>
///
/// <exception cref="NotFoundException"/>
/// <exception cref="AuthorizationErrorException"/>
/// <exception cref="InternalErrorException"/>
/// <exception cref="SubscriptionLimitExceededException"/>
/// <exception cref="InvalidParameterException"/>
public SubscribeResponse Subscribe(SubscribeRequest subscribeRequest)
{
IAsyncResult asyncResult = invokeSubscribe(subscribeRequest, null, null, true);
return EndSubscribe(asyncResult);
}
/// <summary>
/// Initiates the asynchronous execution of the Subscribe operation.
/// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService.Subscribe"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Subscribe operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<SubscribeResponse> SubscribeAsync(SubscribeRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new SubscribeRequestMarshaller();
var unmarshaller = SubscribeResponseUnmarshaller.GetInstance();
return Invoke<IRequest, SubscribeRequest, SubscribeResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the Subscribe operation.
/// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService.Subscribe"/>
/// </summary>
///
/// <param name="subscribeRequest">Container for the necessary parameters to execute the Subscribe operation on
/// AmazonSimpleNotificationService.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSubscribe
/// operation.</returns>
public IAsyncResult BeginSubscribe(SubscribeRequest subscribeRequest, AsyncCallback callback, object state)
{
return invokeSubscribe(subscribeRequest, callback, state, false);
}
private Amazon.SimpleNotificationService.Model.SubscribeResponse CallAWSServiceOperation(IAmazonSimpleNotificationService client, Amazon.SimpleNotificationService.Model.SubscribeRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Simple Notification Service (SNS)", "Subscribe");
try
{
#if DESKTOP
return(client.Subscribe(request));
#elif CORECLR
return(client.SubscribeAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
IAsyncResult invokeSubscribe(SubscribeRequest subscribeRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new SubscribeRequestMarshaller().Marshall(subscribeRequest);
var unmarshaller = SubscribeResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}