diff --git a/profiles/preview/preview/signalr/mgmt/signalr/models.go b/profiles/preview/preview/signalr/mgmt/signalr/models.go index 0a13a02e867f..8549eb48670f 100644 --- a/profiles/preview/preview/signalr/mgmt/signalr/models.go +++ b/profiles/preview/preview/signalr/mgmt/signalr/models.go @@ -83,8 +83,14 @@ type ServiceSpecification = original.ServiceSpecification type TrackedResource = original.TrackedResource type UpdateFuture = original.UpdateFuture type UpdateParameters = original.UpdateParameters +type Usage = original.Usage +type UsageList = original.UsageList +type UsageListIterator = original.UsageListIterator +type UsageListPage = original.UsageListPage +type UsageName = original.UsageName type OperationsClient = original.OperationsClient type Client = original.Client +type UsagesClient = original.UsagesClient func New(subscriptionID string) BaseClient { return original.New(subscriptionID) @@ -113,6 +119,12 @@ func NewClient(subscriptionID string) Client { func NewClientWithBaseURI(baseURI string, subscriptionID string) Client { return original.NewClientWithBaseURI(baseURI, subscriptionID) } +func NewUsagesClient(subscriptionID string) UsagesClient { + return original.NewUsagesClient(subscriptionID) +} +func NewUsagesClientWithBaseURI(baseURI string, subscriptionID string) UsagesClient { + return original.NewUsagesClientWithBaseURI(baseURI, subscriptionID) +} func UserAgent() string { return original.UserAgent() + " profiles/preview" } diff --git a/services/preview/signalr/mgmt/2018-03-01-preview/signalr/models.go b/services/preview/signalr/mgmt/2018-03-01-preview/signalr/models.go index ac395bbf0043..6a425cfc1e4f 100644 --- a/services/preview/signalr/mgmt/2018-03-01-preview/signalr/models.go +++ b/services/preview/signalr/mgmt/2018-03-01-preview/signalr/models.go @@ -757,3 +757,128 @@ func (up UpdateParameters) MarshalJSON() ([]byte, error) { } return json.Marshal(objectMap) } + +// Usage object that describes a specific usage of SignalR resources. +type Usage struct { + // ID - Fully qualified ARM resource id + ID *string `json:"id,omitempty"` + // CurrentValue - Current value for the usage quota. + CurrentValue *int64 `json:"currentValue,omitempty"` + // Limit - The maximum permitted value for the usage quota. If there is no limit, this value will be -1. + Limit *int64 `json:"limit,omitempty"` + // Name - Localizable String object containing the name and a localized value. + Name *UsageName `json:"name,omitempty"` + // Unit - Representing the units of the usage quota. Possible values are: Count, Bytes, Seconds, Percent, CountPerSecond, BytesPerSecond. + Unit *string `json:"unit,omitempty"` +} + +// UsageList object that includes an array of SignalR resource usages and a possible link for next set. +type UsageList struct { + autorest.Response `json:"-"` + // Value - List of SignalR usages + Value *[]Usage `json:"value,omitempty"` + // NextLink - The URL the client should use to fetch the next page (per server side paging). + // It's null for now, added for future use. + NextLink *string `json:"nextLink,omitempty"` +} + +// UsageListIterator provides access to a complete listing of Usage values. +type UsageListIterator struct { + i int + page UsageListPage +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *UsageListIterator) Next() error { + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err := iter.page.Next() + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter UsageListIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter UsageListIterator) Response() UsageList { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter UsageListIterator) Value() Usage { + if !iter.page.NotDone() { + return Usage{} + } + return iter.page.Values()[iter.i] +} + +// IsEmpty returns true if the ListResult contains no values. +func (ul UsageList) IsEmpty() bool { + return ul.Value == nil || len(*ul.Value) == 0 +} + +// usageListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (ul UsageList) usageListPreparer() (*http.Request, error) { + if ul.NextLink == nil || len(to.String(ul.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare(&http.Request{}, + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(ul.NextLink))) +} + +// UsageListPage contains a page of Usage values. +type UsageListPage struct { + fn func(UsageList) (UsageList, error) + ul UsageList +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *UsageListPage) Next() error { + next, err := page.fn(page.ul) + if err != nil { + return err + } + page.ul = next + return nil +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page UsageListPage) NotDone() bool { + return !page.ul.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page UsageListPage) Response() UsageList { + return page.ul +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page UsageListPage) Values() []Usage { + if page.ul.IsEmpty() { + return nil + } + return *page.ul.Value +} + +// UsageName localizable String object containing the name and a localized value. +type UsageName struct { + // Value - The indentifier of the usage. + Value *string `json:"value,omitempty"` + // LocalizedValue - Localized name of the usage. + LocalizedValue *string `json:"localizedValue,omitempty"` +} diff --git a/services/preview/signalr/mgmt/2018-03-01-preview/signalr/usages.go b/services/preview/signalr/mgmt/2018-03-01-preview/signalr/usages.go new file mode 100644 index 000000000000..9c67bf88fd60 --- /dev/null +++ b/services/preview/signalr/mgmt/2018-03-01-preview/signalr/usages.go @@ -0,0 +1,133 @@ +package signalr + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "net/http" +) + +// UsagesClient is the REST API for Azure SignalR Service +type UsagesClient struct { + BaseClient +} + +// NewUsagesClient creates an instance of the UsagesClient client. +func NewUsagesClient(subscriptionID string) UsagesClient { + return NewUsagesClientWithBaseURI(DefaultBaseURI, subscriptionID) +} + +// NewUsagesClientWithBaseURI creates an instance of the UsagesClient client. +func NewUsagesClientWithBaseURI(baseURI string, subscriptionID string) UsagesClient { + return UsagesClient{NewWithBaseURI(baseURI, subscriptionID)} +} + +// List list usage quotas for Azure SignalR service by location. +// Parameters: +// location - the location like "eastus" +func (client UsagesClient) List(ctx context.Context, location string) (result UsageListPage, err error) { + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx, location) + if err != nil { + err = autorest.NewErrorWithError(err, "signalr.UsagesClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.ul.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "signalr.UsagesClient", "List", resp, "Failure sending request") + return + } + + result.ul, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "signalr.UsagesClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client UsagesClient) ListPreparer(ctx context.Context, location string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "location": autorest.Encode("path", location), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2018-03-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.SignalRService/locations/{location}/usages", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client UsagesClient) ListSender(req *http.Request) (*http.Response, error) { + return autorest.SendWithSender(client, req, + azure.DoRetryWithRegistration(client.Client)) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client UsagesClient) ListResponder(resp *http.Response) (result UsageList, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listNextResults retrieves the next set of results, if any. +func (client UsagesClient) listNextResults(lastResults UsageList) (result UsageList, err error) { + req, err := lastResults.usageListPreparer() + if err != nil { + return result, autorest.NewErrorWithError(err, "signalr.UsagesClient", "listNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "signalr.UsagesClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "signalr.UsagesClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client UsagesClient) ListComplete(ctx context.Context, location string) (result UsageListIterator, err error) { + result.page, err = client.List(ctx, location) + return +}