Container for the parameters to the DescribeRegions operation. Describes one or more regions that are currently available to you.

For a list of the regions supported by Amazon EC2, see Regions and Endpoints.

Inheritance: AmazonEC2Request
 protected override void ProcessRecord()
 {
     AmazonEC2 client = base.GetClient();
     Amazon.EC2.Model.DescribeRegionsRequest request = new Amazon.EC2.Model.DescribeRegionsRequest();
     if (string.IsNullOrEmpty(this._RegionName))
     {
         request.RegionName.Add(this._RegionName);
     }
     Amazon.EC2.Model.DescribeRegionsResponse response = client.DescribeRegions(request);
     base.WriteObject(response.DescribeRegionsResult.Region, true);
 }
        /// <summary>
        /// The DescribeRegions operation describes regions zones that are currently available to the account.
        /// 
        /// </summary>
        /// <param name="service">Instance of AmazonEC2 service</param>
        /// <param name="request">DescribeRegionsRequest request</param>
        public static void InvokeDescribeRegions(AmazonEC2 service, DescribeRegionsRequest request)
        {
            try 
            {
                DescribeRegionsResponse response = service.DescribeRegions(request);
                
                
                Console.WriteLine ("Service Response");
                Console.WriteLine ("=============================================================================");
                Console.WriteLine ();

                Console.WriteLine("        DescribeRegionsResponse");
                if (response.IsSetResponseMetadata())
                {
                    Console.WriteLine("            ResponseMetadata");
                    ResponseMetadata  responseMetadata = response.ResponseMetadata;
                    if (responseMetadata.IsSetRequestId())
                    {
                        Console.WriteLine("                RequestId");
                        Console.WriteLine("                    {0}", responseMetadata.RequestId);
                    }
                }
                if (response.IsSetDescribeRegionsResult())
                {
                    Console.WriteLine("            DescribeRegionsResult");
                    DescribeRegionsResult  describeRegionsResult = response.DescribeRegionsResult;
                    List<Region> regionList = describeRegionsResult.Region;
                    foreach (Region region in regionList)
                    {
                        Console.WriteLine("                Region");
                        if (region.IsSetRegionName())
                        {
                            Console.WriteLine("                    RegionName");
                            Console.WriteLine("                        {0}", region.RegionName);
                        }
                        if (region.IsSetEndpoint())
                        {
                            Console.WriteLine("                    Endpoint");
                            Console.WriteLine("                        {0}", region.Endpoint);
                        }
                    }
                }

            } 
            catch (AmazonEC2Exception ex) 
            {
                Console.WriteLine("Caught Exception: " + ex.Message);
                Console.WriteLine("Response Status Code: " + ex.StatusCode);
                Console.WriteLine("Error Code: " + ex.ErrorCode);
                Console.WriteLine("Error Type: " + ex.ErrorType);
                Console.WriteLine("Request ID: " + ex.RequestId);
                Console.WriteLine("XML: " + ex.XML);
            }
        }
        public object Execute(ExecutorContext context)
        {
            var cmdletContext = context as CmdletContext;
            // create request
            var request = new Amazon.EC2.Model.DescribeRegionsRequest();

            if (cmdletContext.AllRegion != null)
            {
                request.AllRegions = cmdletContext.AllRegion.Value;
            }
            if (cmdletContext.Filter != null)
            {
                request.Filters = cmdletContext.Filter;
            }
            if (cmdletContext.RegionName != null)
            {
                request.RegionNames = cmdletContext.RegionName;
            }

            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);
        }
        /// <summary>
        /// Initiates the asynchronous execution of the DescribeRegions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions 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<DescribeRegionsResponse> DescribeRegionsAsync(DescribeRegionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeRegionsRequestMarshaller();
            var unmarshaller = DescribeRegionsResponseUnmarshaller.Instance;

            return InvokeAsync<DescribeRegionsRequest,DescribeRegionsResponse>(request, marshaller, 
                unmarshaller, cancellationToken);
        }
        /// <summary>
        /// Describes one or more regions that are currently available to you.
        /// 
        ///  
        /// <para>
        /// For a list of the regions supported by Amazon EC2, see <a href="http://docs.aws.amazon.com/general/latest/gr/rande.html#ec2_region">Regions
        /// and Endpoints</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions service method.</param>
        /// 
        /// <returns>The response from the DescribeRegions service method, as returned by EC2.</returns>
        public DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest request)
        {
            var marshaller = new DescribeRegionsRequestMarshaller();
            var unmarshaller = DescribeRegionsResponseUnmarshaller.Instance;

            return Invoke<DescribeRegionsRequest,DescribeRegionsResponse>(request, marshaller, unmarshaller);
        }
Example #6
0
        /// <summary>
        /// Initiates the asynchronous execution of the DescribeRegions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions operation on AmazonEC2Client.</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 EndDescribeRegions
        ///         operation.</returns>
        public IAsyncResult BeginDescribeRegions(DescribeRegionsRequest request, AsyncCallback callback, object state)
        {
            var marshaller = new DescribeRegionsRequestMarshaller();
            var unmarshaller = DescribeRegionsResponseUnmarshaller.Instance;

            return BeginInvoke<DescribeRegionsRequest>(request, marshaller, unmarshaller,
                callback, state);
        }
Example #7
0
 IAsyncResult invokeDescribeRegions(DescribeRegionsRequest describeRegionsRequest, AsyncCallback callback, object state, bool synchronized)
 {
     IRequest irequest = new DescribeRegionsRequestMarshaller().Marshall(describeRegionsRequest);
     var unmarshaller = DescribeRegionsResponseUnmarshaller.GetInstance();
     AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
     Invoke(result);
     return result;
 }
Example #8
0
 /// <summary>
 /// Initiates the asynchronous execution of the DescribeRegions operation.
 /// <seealso cref="Amazon.EC2.IAmazonEC2.DescribeRegions"/>
 /// </summary>
 /// 
 /// <param name="describeRegionsRequest">Container for the necessary parameters to execute the DescribeRegions operation on AmazonEC2.</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 EndDescribeRegions
 ///         operation.</returns>
 public IAsyncResult BeginDescribeRegions(DescribeRegionsRequest describeRegionsRequest, AsyncCallback callback, object state)
 {
     return invokeDescribeRegions(describeRegionsRequest, callback, state, false);
 }
Example #9
0
 /// <summary>
 /// <para>Describes one or more regions that are currently available to you.</para> <para>For a list of the regions supported by Amazon EC2, see
 /// <a href="http://docs.aws.amazon.com/general/latest/gr/rande.html#ec2_region" >Regions and Endpoints</a> .</para>
 /// </summary>
 /// 
 /// <param name="describeRegionsRequest">Container for the necessary parameters to execute the DescribeRegions service method on
 ///          AmazonEC2.</param>
 /// 
 /// <returns>The response from the DescribeRegions service method, as returned by AmazonEC2.</returns>
 /// 
 public DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest describeRegionsRequest)
 {
     IAsyncResult asyncResult = invokeDescribeRegions(describeRegionsRequest, null, null, true);
     return EndDescribeRegions(asyncResult);
 }
Example #10
0
        /// <summary>
        /// <para>Describes one or more regions that are currently available to you.</para> <para>For a list of the regions supported by Amazon EC2, see
        /// <a href="http://docs.aws.amazon.com/general/latest/gr/rande.html#ec2_region">Regions and Endpoints</a> .</para>
        /// </summary>
        /// 
        /// <param name="describeRegionsRequest">Container for the necessary parameters to execute the DescribeRegions service method on
        /// AmazonEC2.</param>
        /// 
        /// <returns>The response from the DescribeRegions service method, as returned by AmazonEC2.</returns>
        /// <param name="cancellationToken">
        ///     A cancellation token that can be used by other objects or threads to receive notice of cancellation.
        /// </param>
		public Task<DescribeRegionsResponse> DescribeRegionsAsync(DescribeRegionsRequest describeRegionsRequest, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeRegionsRequestMarshaller();
            var unmarshaller = DescribeRegionsResponseUnmarshaller.GetInstance();
            return Invoke<IRequest, DescribeRegionsRequest, DescribeRegionsResponse>(describeRegionsRequest, marshaller, unmarshaller, signer, cancellationToken);
        }
Example #11
0
		internal DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest request)
        {
            var task = DescribeRegionsAsync(request);
            try
            {
                return task.Result;
            }
            catch(AggregateException e)
            {
                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
                return null;
            }
        }
Example #12
0
        /// <summary>
        /// Initiates the asynchronous execution of the DescribeRegions operation.
        /// <seealso cref="Amazon.EC2.IAmazonEC2.DescribeRegions"/>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions 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 async Task<DescribeRegionsResponse> DescribeRegionsAsync(DescribeRegionsRequest request, CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller = new DescribeRegionsRequestMarshaller();
            var unmarshaller = DescribeRegionsResponseUnmarshaller.GetInstance();
            var response = await Invoke<IRequest, DescribeRegionsRequest, DescribeRegionsResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
                .ConfigureAwait(continueOnCapturedContext: false);
            return response;
        }
Example #13
0
        /// <summary>
        /// <para> The DescribeRegions operation describes regions zones that are currently available to the account. </para>
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions service method on
        /// AmazonEC2.</param>
        /// 
        /// <returns>The response from the DescribeRegions service method, as returned by AmazonEC2.</returns>
		public DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest request)
        {
            var task = DescribeRegionsAsync(request);
            try
            {
                return task.Result;
            }
            catch(AggregateException e)
            {
                throw e.InnerException;
            }
        }
        /// <summary>
        /// Auto Scaling Console load event handler
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ConsoleView_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                AmazonEC2Client ec2Client = new AmazonEC2Client();
                DescribeRegionsRequest rreq = new DescribeRegionsRequest();
                DescribeRegionsResponse rresp = ec2Client.DescribeRegions(rreq);
                ((ViewModel)this.DataContext).Regions.Clear();
                foreach (Region r in rresp.DescribeRegionsResult.Region)
                {
                    ((ViewModel)this.DataContext).Regions.Add(new Models.Region(r.RegionName));
                }

                ((ViewModel)this.DataContext).Region = ((ViewModel)this.DataContext).Regions.Where(o => o.Name.ToLower() == "us-east-1").FirstOrDefault();

                AmazonAutoScalingClient client = GetAutoScaleClient();
                if (client == null)
                {
                    MessageBoxResult mbr = MessageBox.Show(Window.GetWindow(this), "AWS Credentials and region must be defined in app.config file.");
                    Application.Current.Shutdown();
                }

            }
            catch (Exception ex)
            {
                LogManager.LogEntry(ex.Message);
                LogManager.LogEntry(ex.StackTrace);
                ((ViewModel)this.DataContext).IsBusy = false;
                MessageBox.Show(Window.GetWindow(this), "Error occured while setting credentials. Please ensure your credentials are correct in app.config.", "Error", MessageBoxButton.OK);
                Application.Current.Shutdown();
            }
        }
 private Amazon.EC2.Model.DescribeRegionsResponse CallAWSServiceOperation(IAmazonEC2 client, Amazon.EC2.Model.DescribeRegionsRequest request)
 {
     Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Elastic Compute Cloud (EC2)", "DescribeRegions");
     try
     {
         #if DESKTOP
         return(client.DescribeRegions(request));
         #elif CORECLR
         return(client.DescribeRegionsAsync(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;
     }
 }
Example #16
0
        public override List<NodeLocation> ListLocations()
        {
            DescribeRegionsRequest request = new DescribeRegionsRequest ();
            DescribeRegionsResponse response = Client.DescribeRegions (request);

            List<NodeLocation> res = new List<NodeLocation> ();
            foreach (var r in response.DescribeRegionsResult.Region) {
                res.Add (new NodeLocation (r.Endpoint, r.RegionName, String.Empty, this));
            }

            return res;
        }