Example #1
0
        internal virtual ListReservationsResponse ListReservations(ListReservationsRequest request)
        {
            var marshaller   = ListReservationsRequestMarshaller.Instance;
            var unmarshaller = ListReservationsResponseUnmarshaller.Instance;

            return(Invoke <ListReservationsRequest, ListReservationsResponse>(request, marshaller, unmarshaller));
        }
Example #2
0
        public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems)
        {
            AmazonMediaLiveConfig config = new AmazonMediaLiveConfig();

            config.RegionEndpoint = region;
            ConfigureClient(config);
            AmazonMediaLiveClient client = new AmazonMediaLiveClient(creds, config);

            ListReservationsResponse resp = new ListReservationsResponse();

            do
            {
                ListReservationsRequest req = new ListReservationsRequest
                {
                    NextToken = resp.NextToken
                    ,
                    MaxResults = maxItems
                };

                resp = client.ListReservations(req);
                CheckError(resp.HttpStatusCode, "200");

                foreach (var obj in resp.Reservations)
                {
                    AddObject(obj);
                }
            }while (!string.IsNullOrEmpty(resp.NextToken));
        }
Example #3
0
        /// <summary>
        /// Initiates the asynchronous execution of the ListReservations operation.
        /// </summary>
        ///
        /// <param name="request">Container for the necessary parameters to execute the ListReservations 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/medialive-2017-10-14/ListReservations">REST API Reference for ListReservations Operation</seealso>
        public virtual Task <ListReservationsResponse> ListReservationsAsync(ListReservationsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
        {
            var marshaller   = ListReservationsRequestMarshaller.Instance;
            var unmarshaller = ListReservationsResponseUnmarshaller.Instance;

            return(InvokeAsync <ListReservationsRequest, ListReservationsResponse>(request, marshaller,
                                                                                   unmarshaller, cancellationToken));
        }
Example #4
0
        /// <summary>Snippet for ListAsync</summary>
        public async Task ListRequestObjectAsync()
        {
            // Snippet: ListAsync(ListReservationsRequest, CallSettings)
            // Create client
            ReservationsClient reservationsClient = await ReservationsClient.CreateAsync();

            // Initialize request argument(s)
            ListReservationsRequest request = new ListReservationsRequest
            {
                Zone    = "",
                OrderBy = "",
                Project = "",
                Filter  = "",
                ReturnPartialSuccess = false,
            };
            // Make the request
            PagedAsyncEnumerable <ReservationList, Reservation> response = reservationsClient.ListAsync(request);

            // Iterate over all response items, lazily performing RPCs as required
            await response.ForEachAsync((Reservation item) =>
            {
                // Do something with each item
                Console.WriteLine(item);
            });

            // Or iterate over pages (of server-defined size), performing one RPC per page
            await response.AsRawResponses().ForEachAsync((ReservationList page) =>
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (Reservation item in page)
                {
                    // Do something with each item
                    Console.WriteLine(item);
                }
            });

            // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
            int pageSize = 10;
            Page <Reservation> singlePage = await response.ReadPageAsync(pageSize);

            // Do something with the page of items
            Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
            foreach (Reservation item in singlePage)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
            // Store the pageToken, for when the next page is required.
            string nextPageToken = singlePage.NextPageToken;
            // End snippet
        }
Example #5
0
        /// <summary>Snippet for ListReservationsAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public async Task ListReservationsRequestObjectAsync()
        {
            // Create client
            ReservationServiceClient reservationServiceClient = await ReservationServiceClient.CreateAsync();

            // Initialize request argument(s)
            ListReservationsRequest request = new ListReservationsRequest
            {
                ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
                Filter = "",
            };
            // Make the request
            PagedAsyncEnumerable <ListReservationsResponse, Reservation> response = reservationServiceClient.ListReservationsAsync(request);

            // Iterate over all response items, lazily performing RPCs as required
            await response.ForEachAsync((Reservation item) =>
            {
                // Do something with each item
                Console.WriteLine(item);
            });

            // Or iterate over pages (of server-defined size), performing one RPC per page
            await response.AsRawResponses().ForEachAsync((ListReservationsResponse page) =>
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (Reservation item in page)
                {
                    // Do something with each item
                    Console.WriteLine(item);
                }
            });

            // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
            int pageSize = 10;
            Page <Reservation> singlePage = await response.ReadPageAsync(pageSize);

            // Do something with the page of items
            Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
            foreach (Reservation item in singlePage)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
            // Store the pageToken, for when the next page is required.
            string nextPageToken = singlePage.NextPageToken;
        }
Example #6
0
 /// <summary>Snippet for List</summary>
 public void ListRequestObject()
 {
     // Snippet: List(ListReservationsRequest, CallSettings)
     // Create client
     ReservationsClient reservationsClient = ReservationsClient.Create();
     // Initialize request argument(s)
     ListReservationsRequest request = new ListReservationsRequest
     {
         Zone                 = "",
         PageToken            = "",
         MaxResults           = 0U,
         Filter               = "",
         OrderBy              = "",
         Project              = "",
         ReturnPartialSuccess = false,
     };
     // Make the request
     ReservationList response = reservationsClient.List(request);
     // End snippet
 }
Example #7
0
        /// <summary>Snippet for ListAsync</summary>
        public async Task ListRequestObjectAsync()
        {
            // Snippet: ListAsync(ListReservationsRequest, CallSettings)
            // Additional: ListAsync(ListReservationsRequest, CancellationToken)
            // Create client
            ReservationsClient reservationsClient = await ReservationsClient.CreateAsync();

            // Initialize request argument(s)
            ListReservationsRequest request = new ListReservationsRequest
            {
                Zone                 = "",
                PageToken            = "",
                MaxResults           = 0U,
                Filter               = "",
                OrderBy              = "",
                Project              = "",
                ReturnPartialSuccess = false,
            };
            // Make the request
            ReservationList response = await reservationsClient.ListAsync(request);

            // End snippet
        }