Container for the parameters to the ListHostedZonesByName operation. Retrieves a list of your hosted zones in lexicographic order. Send a GET request to the /2013-04-01/hostedzonesbyname resource. The response includes a HostedZones child element for each hosted zone created by the current AWS account.

ListHostedZonesByName sorts hosted zones by name with the labels reversed. For example:

  • com.example.www.

Note the trailing dot, which can change the sort order in some circumstances.

If the domain name includes escape characters or Punycode, ListHostedZonesByName alphabetizes the domain name using the escaped or Punycoded value, which is the format that Amazon Route 53 saves in its database. For example, to create a hosted zone for example.com, specify ex\344mple.com for the domain name. ListHostedZonesByName alphabetizes it as:

  • com.ex\344mple.

The labels are reversed and alphabetized using the escaped value. For more information about valid domain name formats, including internationalized domain names, see DNS Domain Name Format in the Amazon Route 53 Developer Guide.

Amazon Route 53 returns up to 100 items in each response. If you have a lot of hosted zones, use the MaxItems parameter to list them in groups of up to 100. The response includes values that help navigate from one group of MaxItems hosted zones to the next:

  • The DNSName and HostedZoneId elements in the response contain the values, if any, specified for the dnsname and hostedzoneid parameters in the request that produced the current response.

  • The MaxItems element in the response contains the value, if any, that you specified for the maxitems parameter in the request that produced the current response.

  • If the value of IsTruncated in the response is true, there are more hosted zones associated with the current AWS account.

    If IsTruncated is false, this response includes the last hosted zone that is associated with the current account. The NextDNSName element and NextHostedZoneId elements are omitted from the response.

  • The NextDNSName and NextHostedZoneId elements in the response contain the domain name and the hosted zone ID of the next hosted zone that is associated with the current AWS account. If you want to list more hosted zones, make another call to ListHostedZonesByName, and specify the value of NextDNSName and NextHostedZoneId in the dnsname and hostedzoneid parameters, respectively.

Inheritance: AmazonRoute53Request
コード例 #1
0
        /// <summary>
        /// Initiates the asynchronous execution of the ListHostedZonesByName operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ListHostedZonesByName 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<ListHostedZonesByNameResponse> ListHostedZonesByNameAsync(ListHostedZonesByNameRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new ListHostedZonesByNameRequestMarshaller();
            var unmarshaller = ListHostedZonesByNameResponseUnmarshaller.Instance;

            return InvokeAsync<ListHostedZonesByNameRequest,ListHostedZonesByNameResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
コード例 #2
0
        /// <summary>
        /// To retrieve a list of your hosted zones in lexicographic order, send a <code>GET</code>
        /// request to the <code>2013-04-01/hostedzonesbyname</code> resource. The response to
        /// this request includes a <code>HostedZones</code> element with zero or more <code>HostedZone</code>
        /// child elements lexicographically ordered by DNS name. By default, the list of hosted
        /// zones is displayed on a single page. You can control the length of the page that is
        /// displayed by using the <code>MaxItems</code> parameter. You can use the <code>DNSName</code>
        /// and <code>HostedZoneId</code> parameters to control the hosted zone that the list
        /// begins with.
        /// 
        ///  <note> Amazon Route 53 returns a maximum of 100 items. If you set MaxItems to a value
        /// greater than 100, Amazon Route 53 returns only the first 100.</note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ListHostedZonesByName service method.</param>
        /// 
        /// <returns>The response from the ListHostedZonesByName service method, as returned by Route53.</returns>
        /// <exception cref="Amazon.Route53.Model.InvalidDomainNameException">
        /// This error indicates that the specified domain name is not valid.
        /// </exception>
        /// <exception cref="Amazon.Route53.Model.InvalidInputException">
        /// Some value specified in the request is invalid or the XML document is malformed.
        /// </exception>
        public ListHostedZonesByNameResponse ListHostedZonesByName(ListHostedZonesByNameRequest request)
        {
            var marshaller = new ListHostedZonesByNameRequestMarshaller();
            var unmarshaller = ListHostedZonesByNameResponseUnmarshaller.Instance;

            return Invoke<ListHostedZonesByNameRequest,ListHostedZonesByNameResponse>(request, marshaller, unmarshaller);
        }
コード例 #3
0
        private Amazon.Route53.Model.ListHostedZonesByNameResponse CallAWSServiceOperation(IAmazonRoute53 client, Amazon.Route53.Model.ListHostedZonesByNameRequest request)
        {
            Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Route 53", "ListHostedZonesByName");
            try
            {
#if DESKTOP
                return(client.ListHostedZonesByName(request));
#elif CORECLR
                return(client.ListHostedZonesByNameAsync(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;
            }
        }
コード例 #4
0
        public object Execute(ExecutorContext context)
        {
            var cmdletContext      = context as CmdletContext;
            var useParameterSelect = this.Select.StartsWith(".");

            // create request and set iteration invariants
            var request = new Amazon.Route53.Model.ListHostedZonesByNameRequest();

            // Initialize loop variants and commence piping
            string _nextDNSName      = null;
            string _nextHostedZoneId = null;
            int?   _emitLimit        = null;
            int    _retrievedSoFar   = 0;

            if (AutoIterationHelpers.HasValue(cmdletContext.DNSName) || AutoIterationHelpers.HasValue(cmdletContext.HostedZoneId))
            {
                _nextDNSName      = cmdletContext.DNSName;
                _nextHostedZoneId = cmdletContext.HostedZoneId;
            }
            if (AutoIterationHelpers.HasValue(cmdletContext.MaxItem))
            {
                // The service has a maximum page size of 100. If the user has
                // asked for more items than page max, and there is no page size
                // configured, we rely on the service ignoring the set maximum
                // and giving us 100 items back. If a page size is set, that will
                // be used to configure the pagination.
                // We'll make further calls to satisfy the user's request.
                _emitLimit = cmdletContext.MaxItem;
            }
            var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.DNSName)) || ParameterWasBound(nameof(this.HostedZoneId));

            try
            {
                var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
                do
                {
                    request.DNSName      = _nextDNSName;
                    request.HostedZoneId = _nextHostedZoneId;
                    if (_emitLimit.HasValue)
                    {
                        int correctPageSize = Math.Min(100, _emitLimit.Value);
                        request.MaxItems = AutoIterationHelpers.ConvertEmitLimitToString(correctPageSize);
                    }

                    CmdletOutput output;

                    try
                    {
                        var    response       = CallAWSServiceOperation(client, request);
                        object pipelineOutput = null;
                        if (!useParameterSelect)
                        {
                            pipelineOutput = cmdletContext.Select(response, this);
                        }
                        output = new CmdletOutput
                        {
                            PipelineOutput  = pipelineOutput,
                            ServiceResponse = response
                        };
                        int _receivedThisCall = response.HostedZones.Count;
                        if (_userControllingPaging)
                        {
                            WriteProgressRecord("Retrieving", $"Retrieved {_receivedThisCall} records starting from marker '{request.DNSName ?? "null"}, {request.HostedZoneId ?? "null"}'");
                        }

                        _nextDNSName      = response.NextDNSName;
                        _nextHostedZoneId = response.NextHostedZoneId;
                        _retrievedSoFar  += _receivedThisCall;
                        if (_emitLimit.HasValue)
                        {
                            _emitLimit -= _receivedThisCall;
                        }
                    }
                    catch (Exception e)
                    {
                        if (_retrievedSoFar == 0 || !_emitLimit.HasValue)
                        {
                            output = new CmdletOutput {
                                ErrorResponse = e
                            };
                        }
                        else
                        {
                            break;
                        }
                    }

                    ProcessOutput(output);
                } while (!_userControllingPaging && (AutoIterationHelpers.HasValue(_nextDNSName) || AutoIterationHelpers.HasValue(_nextHostedZoneId)) && (!_emitLimit.HasValue || _emitLimit.Value >= 1));
            }
            finally
            {
            }

            if (useParameterSelect)
            {
                WriteObject(cmdletContext.Select(null, this));
            }


            return(null);
        }
コード例 #5
0
        public object Execute(ExecutorContext context)
        {
            var cmdletContext      = context as CmdletContext;
            var useParameterSelect = this.Select.StartsWith(".");

            // create request and set iteration invariants
            var request = new Amazon.Route53.Model.ListHostedZonesByNameRequest();

            if (cmdletContext.MaxItem != null)
            {
                request.MaxItems = AutoIterationHelpers.ConvertEmitLimitToServiceTypeString(cmdletContext.MaxItem.Value);
            }

            // Initialize loop variant and commence piping
            string _nextDNSName           = cmdletContext.DNSName;
            string _nextHostedZoneId      = cmdletContext.HostedZoneId;
            var    _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.DNSName)) || ParameterWasBound(nameof(this.HostedZoneId));

            try
            {
                var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
                do
                {
                    request.DNSName      = _nextDNSName;
                    request.HostedZoneId = _nextHostedZoneId;

                    CmdletOutput output;

                    try
                    {
                        var response = CallAWSServiceOperation(client, request);

                        object pipelineOutput = null;
                        if (!useParameterSelect)
                        {
                            pipelineOutput = cmdletContext.Select(response, this);
                        }
                        output = new CmdletOutput
                        {
                            PipelineOutput  = pipelineOutput,
                            ServiceResponse = response
                        };
                        if (_userControllingPaging)
                        {
                            int _receivedThisCall = (pipelineOutput as System.Collections.ICollection)?.Count ?? 1;
                            WriteProgressRecord("Retrieving", $"Retrieved {_receivedThisCall} records starting from marker '{request.DNSName ?? "null"}, {request.HostedZoneId ?? "null"}'");
                        }

                        _nextDNSName      = response.NextDNSName;
                        _nextHostedZoneId = response.NextHostedZoneId;
                    }
                    catch (Exception e)
                    {
                        output = new CmdletOutput {
                            ErrorResponse = e
                        };
                    }

                    ProcessOutput(output);
                } while (!_userControllingPaging && (AutoIterationHelpers.HasValue(_nextDNSName) || AutoIterationHelpers.HasValue(_nextHostedZoneId)));
            }
            finally
            {
                if (_userControllingPaging)
                {
                    WriteProgressCompleteRecord("Retrieving", "Retrieved records");
                }
            }

            if (useParameterSelect)
            {
                WriteObject(cmdletContext.Select(null, this));
            }


            return(null);
        }
コード例 #6
0
        /// <summary>
        /// Initiates the asynchronous execution of the ListHostedZonesByName operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ListHostedZonesByName operation on AmazonRoute53Client.</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 EndListHostedZonesByName
        ///         operation.</returns>
        public IAsyncResult BeginListHostedZonesByName(ListHostedZonesByNameRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new ListHostedZonesByNameRequestMarshaller();
            var unmarshaller = ListHostedZonesByNameResponseUnmarshaller.Instance;

            return BeginInvoke<ListHostedZonesByNameRequest>(request, marshaller, unmarshaller,
                callback, state);
        }