private static void deleteQueue(DmsClient client)
        {
            var req = new DeleteQueueRequest()
            {
                QueueId = queueId,
            };

            try
            {
                var resp = client.DeleteQueue(req);
                Console.WriteLine(resp.GetHttpBody());
            }
            catch (RequestTimeoutException requestTimeoutException)
            {
                Console.WriteLine(requestTimeoutException.ErrorMessage);
            }
            catch (ServiceResponseException clientRequestException)
            {
                Console.WriteLine(clientRequestException.HttpStatusCode);
                Console.WriteLine(clientRequestException.ErrorCode);
                Console.WriteLine(clientRequestException.ErrorMsg);
            }
            catch (ConnectionException connectionException)
            {
                Console.WriteLine(connectionException.ErrorMessage);
            }
        }
示例#2
0
        /**
         * Convert DeleteQueueRequest to name value pairs
         */
        private IDictionary <String, String> ConvertDeleteQueue(DeleteQueueRequest request)
        {
            IDictionary <String, String> parameters = new Dictionary <String, String>();

            parameters.Add("Action", "DeleteQueue");
            if (request.IsSetQueueUrl())
            {
                parameters.Add("QueueUrl", request.QueueUrl);
            }
            List <Attribute> deleteQueueRequestAttributeList = request.Attribute;
            int deleteQueueRequestAttributeListIndex         = 1;

            foreach (Attribute deleteQueueRequestAttribute in deleteQueueRequestAttributeList)
            {
                if (deleteQueueRequestAttribute.IsSetName())
                {
                    parameters.Add("Attribute" + "." + deleteQueueRequestAttributeListIndex + "." + "Name", deleteQueueRequestAttribute.Name);
                }
                if (deleteQueueRequestAttribute.IsSetValue())
                {
                    parameters.Add("Attribute" + "." + deleteQueueRequestAttributeListIndex + "." + "Value", deleteQueueRequestAttribute.Value);
                }

                deleteQueueRequestAttributeListIndex++;
            }

            return(parameters);
        }
示例#3
0
        /// <summary>
        /// Initiates the asynchronous execution of the DeleteQueue operation.
        /// <seealso cref="Amazon.SQS.IAmazonSQS"/>
        /// </summary>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteQueue 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 <DeleteQueueResponse> DeleteQueueAsync(DeleteQueueRequest request, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller   = new DeleteQueueRequestMarshaller();
            var unmarshaller = DeleteQueueResponseUnmarshaller.Instance;

            return(Invoke <IRequest, DeleteQueueRequest, DeleteQueueResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
        }
示例#4
0
        /**
         * Convert DeleteQueueRequest to name value pairs
         */
        private static IDictionary <string, string> ConvertDeleteQueue(DeleteQueueRequest request)
        {
            IDictionary <string, string> parameters = new Dictionary <string, string>();

            parameters["Action"] = "DeleteQueue";
            if (request.IsSetQueueUrl())
            {
                parameters["QueueUrl"] = request.QueueUrl;
            }
            List <Attribute> deleteQueueRequestAttributeList = request.Attribute;
            int deleteQueueRequestAttributeListIndex         = 1;

            foreach (Attribute deleteQueueRequestAttribute in deleteQueueRequestAttributeList)
            {
                if (deleteQueueRequestAttribute.IsSetName())
                {
                    parameters[String.Concat("Attribute", ".", deleteQueueRequestAttributeListIndex, ".", "Name")] = deleteQueueRequestAttribute.Name;
                }
                if (deleteQueueRequestAttribute.IsSetValue())
                {
                    parameters[String.Concat("Attribute", ".", deleteQueueRequestAttributeListIndex, ".", "Value")] = deleteQueueRequestAttribute.Value;
                }

                deleteQueueRequestAttributeListIndex++;
            }

            return(parameters);
        }
示例#5
0
 /// <inheritdoc/>
 public DeleteQueueResponse DeleteQueue(DeleteQueueRequest request)
 {
     return(AggregateExceptionExtract.Extract(() =>
     {
         return DeleteQueueAsync(request).Result;
     }));
 }
        private static IDictionary <string, string> ConvertDeleteQueue(DeleteQueueRequest request)
        {
            IDictionary <string, string> dictionary = new Dictionary <string, string>();

            dictionary["Action"] = "DeleteQueue";
            if (request.IsSetQueueUrl())
            {
                dictionary["QueueUrl"] = request.QueueUrl;
            }
            List <Amazon.SQS.Model.Attribute> list = request.Attribute;
            int num = 1;

            foreach (Amazon.SQS.Model.Attribute attribute in list)
            {
                if (attribute.IsSetName())
                {
                    dictionary[string.Concat(new object[] { "Attribute", ".", num, ".", "Name" })] = attribute.Name;
                }
                if (attribute.IsSetValue())
                {
                    dictionary[string.Concat(new object[] { "Attribute", ".", num, ".", "Value" })] = attribute.Value;
                }
                num++;
            }
            return(dictionary);
        }
示例#7
0
        public void DeleteQueue()
        {
            var request = new DeleteQueueRequest();

            request.QueueUrl = QueueUrl;
            _sqsClient.DeleteQueue(request);
        }
示例#8
0
        public async Task <DeleteQueueResponse> DeleteQueueAsync(DeleteQueueRequest request)
        {
            var marshaller   = new DeleteQueueRequestMarshaller();
            var unmarshaller = DeleteQueueResponseUnmarshaller.Instance;

            return(await InvokeAsync <DeleteQueueRequest, DeleteQueueResponse>(request, marshaller, unmarshaller).ConfigureAwait(false));
        }
示例#9
0
        /// <inheritdoc/>
        public DeleteQueueResponse DeleteQueue(DeleteQueueRequest request)
        {
            var marshaller   = new DeleteQueueRequestMarshaller();
            var unmarshaller = DeleteQueueResponseUnmarshaller.Instance;

            return(Invoke <DeleteQueueRequest, DeleteQueueResponse>(request, marshaller, unmarshaller));
        }
示例#10
0
        internal virtual DeleteQueueResponse DeleteQueue(DeleteQueueRequest request)
        {
            var marshaller   = DeleteQueueRequestMarshaller.Instance;
            var unmarshaller = DeleteQueueResponseUnmarshaller.Instance;

            return(Invoke <DeleteQueueRequest, DeleteQueueResponse>(request, marshaller, unmarshaller));
        }
        public override void DeleteQueue()
        {
            var deleteQueueRequest = new DeleteQueueRequest();

            deleteQueueRequest.QueueUrl = Address;
            _sqsClient.DeleteQueue(deleteQueueRequest);
        }
示例#12
0
        public void DeleteQueue()
        {
            var sqsDeleRequest = new DeleteQueueRequest {
                QueueUrl = _queueUrl
            };

            _sqs.DeleteQueue(sqsDeleRequest);
        }
示例#13
0
        public void DeleteQueue()
        {
            var sqsDeleRequest = new DeleteQueueRequest {
                QueueUrl = _queueUrl
            };

            _sqs.DeleteQueueAsync(sqsDeleRequest).Wait();
        }
示例#14
0
        /// <inheritdoc/>
        public IAsyncResult BeginDeleteQueue(DeleteQueueRequest request, AsyncCallback callback, object state)
        {
            var marshaller   = new DeleteQueueRequestMarshaller();
            var unmarshaller = DeleteQueueResponseUnmarshaller.Instance;

            return(BeginInvoke <DeleteQueueRequest>(request, marshaller, unmarshaller,
                                                    callback, state));
        }
示例#15
0
        /// <inheritdoc/>
        public DeleteQueueResponse DeleteQueue(string queueName)
        {
            var request = new DeleteQueueRequest {
                QueueName = queueName
            };

            return(DeleteQueue(request));
        }
示例#16
0
        /// <summary>
        /// Initiates the asynchronous execution of the DeleteQueue operation.
        /// </summary>
        ///
        /// <param name="request">Container for the necessary parameters to execute the DeleteQueue 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>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/mediaconvert-2017-08-29/DeleteQueue">REST API Reference for DeleteQueue Operation</seealso>
        public virtual Task <DeleteQueueResponse> DeleteQueueAsync(DeleteQueueRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller   = new DeleteQueueRequestMarshaller();
            var unmarshaller = DeleteQueueResponseUnmarshaller.Instance;

            return(InvokeAsync <DeleteQueueRequest, DeleteQueueResponse>(request, marshaller,
                                                                         unmarshaller, cancellationToken));
        }
示例#17
0
        public async Task <DeleteQueueResponse> DeleteQueueAsync(string queueName)
        {
            var request = new DeleteQueueRequest {
                QueueName = queueName
            };

            return(await DeleteQueueAsync(request).ConfigureAwait(false));
        }
示例#18
0
        public DeleteQueueResponse DeleteQueue(DeleteQueueRequest request)
        {
            FakeSqsQueue q;

            queues.TryRemove(request.QueueUrl, out q);

            return(new DeleteQueueResponse());
        }
示例#19
0
        public void DeleteQueue(string url)
        {
            var req = new DeleteQueueRequest()
            {
                QueueUrl = url
            };

            client.DeleteQueue(req);
        }
示例#20
0
        public virtual void DeleteQueue(AmazonSQSClient sqsClient, string queueUrl)
        {
            var deleteQueueRequest = new DeleteQueueRequest
            {
                QueueUrl = queueUrl
            };

            // Delete the queue
            sqsClient.DeleteQueue(deleteQueueRequest);
        }
示例#21
0
        /// <summary>
        /// Deletes a SQS message queue.
        /// </summary>
        /// <param name="deleteQueueRequest">The delete queue request.</param>
        /// <returns>The delete queue response.</returns>
        public virtual DeleteQueueResponse DeleteQueue(DeleteQueueRequest deleteQueueRequest)
        {
            if (deleteQueueRequest == null)
            {
                throw new ArgumentNullException("deleteQueueRequest");
            }

            // Log.DebugFormat("SqsClient: Deleting queue: {0}.", deleteQueueRequest.QueueUrl);
            return(this.Client.DeleteQueue(deleteQueueRequest));
        }
示例#22
0
        public async Task DeleteGPQueueAsync()
        {
            DeleteQueueRequest  request  = new DeleteQueueRequest(this.gpQueueUrl);
            DeleteQueueResponse response = await this.client.DeleteQueueAsync(request);

            if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
            {
                throw new Exception($"failed to delete queue: {this.gpQueueUrl} with code: {response.HttpStatusCode}");
            }
        }
        public override void DeleteQueue()
        {
            var deleteQueueRequest  = new DeleteQueueRequest(MessageAddress.Address);
            var deleteQueueResponse = _sqsClient.DeleteQueue(deleteQueueRequest);

            if (deleteQueueResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
            {
                // throw or log something
            }
        }
        public async Task <ActionResult> DeleteQueue(string queueName)
        {
            GetQueueUrlRequest  getQueueUrlRequest = new GetQueueUrlRequest(queueName);
            GetQueueUrlResponse getUrlResponse     = await _amazonSQS.GetQueueUrlAsync(getQueueUrlRequest);

            DeleteQueueRequest deleteQueueRequest = new DeleteQueueRequest(getUrlResponse.QueueUrl);

            var response = await _amazonSQS.DeleteQueueAsync(deleteQueueRequest);

            return(Ok($"Queue {queueName} is deleted"));
        }
示例#25
0
        public void DeleteQueueExample()
        {
            AmazonSQSClient client = new AmazonSQSClient();

            var request = new DeleteQueueRequest
            {
                QueueUrl = "SQS_QUEUE_URL"
            };

            client.DeleteQueue(request);
        }
示例#26
0
        /// <summary>
        /// 删除指定队列
        /// </summary>
        public async Task <DeleteQueueResponse> DeleteQueueAsync(DeleteQueueRequest deleteQueueRequest)
        {
            Dictionary <string, string> urlParam = new Dictionary <string, string>();

            urlParam.Add("queue_id", deleteQueueRequest.QueueId.ToString());
            string              urlPath  = HttpUtils.AddUrlPath("/v2/{project_id}/queues/{queue_id}", urlParam);
            SdkRequest          request  = HttpUtils.InitSdkRequest(urlPath, "application/json", deleteQueueRequest);
            HttpResponseMessage response = await DoHttpRequestAsync("DELETE", request);

            return(JsonUtils.DeSerializeNull <DeleteQueueResponse>(response));
        }
示例#27
0
        private void DeleteQueue(SqsQueueName queueName, string queueUrl)
        {
            var request = new DeleteQueueRequest
            {
                QueueUrl = queueUrl
            };

            var response = SqsClient.DeleteQueue(request);

            queueNameMap.TryRemove(queueName.QueueName, out _);
        }
示例#28
0
        /// <summary>
        /// Deletes a queue with the specified name
        /// </summary>
        /// <param name="queueName">The name of the queue</param>
        /// <returns></returns>
        public async Task <bool> DeleteQueueAsync(string queueName)
        {
            var queueUrl = await GetQueueUrlAsync(queueName);

            var request  = new DeleteQueueRequest(queueUrl);
            var response = await _client.DeleteQueueAsync(request);

            var success = (int)response.HttpStatusCode >= 200 && (int)response.HttpStatusCode <= 299;

            return(success);
        }
示例#29
0
        public IRequestContext Marshall(DeleteQueueRequest input)
        {
            IRequestContext context = new RequestContext();

            context.AddParametr("Action", input.ActionName);
            context.AddParametr("Version", YandexMqConfig.DEFAULT_SERVICE_VERSION);

            context.AddParametr("QueueUrl", input.QueueUrl);

            return(context);
        }
示例#30
0
        public void Dispose()
        {
            //delete subscription
            _snsClient.UnsubscribeAsync(_subscriptionArn);
            Console.WriteLine("Unsubscribed from topic.");

            //Delete Queue
            var deleteQueueRequest = new DeleteQueueRequest(QueueUrl);

            _sqsClient.DeleteQueueAsync(deleteQueueRequest);
            Console.WriteLine("Queue deleted.");
        }
 public async Task DeleteQueueAsync(string queueName)
 {
     var request = new DeleteQueueRequest(_account, queueName);
     await request.ExecuteAsync(_optionalRetryPolicy);
 }
 public void DeleteQueue(string queueName)
 {
     var request = new DeleteQueueRequest(_account, queueName);
     request.Execute(_optionalRetryPolicy);
 }