Azure
/
ARO-RP
зеркало из https://github.com/Azure/ARO-RP.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

make client

This commit is contained in:
Jim Minter 2020-03-07 13:45:52 -06:00
Родитель 330472b767
Коммит cbc8275766
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 0730CBDA10D1A2D3
13 изменённых файлов: 990 добавлений и 388 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
.sha256sum
Просмотреть файл

@ -1 +1 @@
b36ae9eb376fc94a86f6adc6bdd0359eb30178c7a25c7234913277af94a1245c swagger/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/preview/2019-12-31-preview/redhatopenshift.json
8278cc89e7a95b160d1abdab6ee52759f796fb1848487e55e130264cef1d6ea1 swagger/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/preview/2019-12-31-preview/redhatopenshift.json

409
pkg/client/services/preview/redhatopenshift/mgmt/2019-12-31-preview/redhatopenshift/models.go
Просмотреть файл

@ -24,6 +24,8 @@ import (
"github.com/Azure/go-autorest/autorest"
"github.com/Azure/go-autorest/autorest/azure"
"github.com/Azure/go-autorest/autorest/to"
"github.com/Azure/go-autorest/tracing"
)
// The package's fully qualified name.
@ -156,7 +158,7 @@ type CloudErrorBody struct {
Details *[]CloudErrorBody `json:"details,omitempty"`
}
// ClusterProfile ...
// ClusterProfile clusterProfile represents a cluster profile.
type ClusterProfile struct {
// Domain - The domain for the cluster (immutable).
Domain *string `json:"domain,omitempty"`
@ -166,7 +168,7 @@ type ClusterProfile struct {
ResourceGroupID *string `json:"resourceGroupId,omitempty"`
}
// ConsoleProfile ...
// ConsoleProfile consoleProfile represents a console profile.
type ConsoleProfile struct {
// URL - The URL to access the cluster console (immutable).
URL *string `json:"url,omitempty"`
@ -213,12 +215,12 @@ type NetworkProfile struct {
// OpenShiftCluster openShiftCluster represents an Azure Red Hat OpenShift cluster.
type OpenShiftCluster struct {
autorest.Response `json:"-"`
// OpenShiftClusterProperties - The cluster properties.
*OpenShiftClusterProperties `json:"properties,omitempty"`
// Tags - Resource tags.
Tags map[string]*string `json:"tags"`
// Location - The geo-location where the resource lives
Location *string `json:"location,omitempty"`
// Properties - The cluster properties.
*Properties `json:"properties,omitempty"`
// ID - READ-ONLY; Fully qualified resource Id for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
ID *string `json:"id,omitempty"`
// Name - READ-ONLY; The name of the resource
@ -230,15 +232,15 @@ type OpenShiftCluster struct {
// MarshalJSON is the custom marshaler for OpenShiftCluster.
func (osc OpenShiftCluster) MarshalJSON() ([]byte, error) {
objectMap := make(map[string]interface{})
if osc.OpenShiftClusterProperties != nil {
objectMap["properties"] = osc.OpenShiftClusterProperties
}
if osc.Tags != nil {
objectMap["tags"] = osc.Tags
}
if osc.Location != nil {
objectMap["location"] = osc.Location
}
if osc.Properties != nil {
objectMap["properties"] = osc.Properties
}
return json.Marshal(objectMap)
}
@ -251,6 +253,15 @@ func (osc *OpenShiftCluster) UnmarshalJSON(body []byte) error {
}
for k, v := range m {
switch k {
case "properties":
if v != nil {
var openShiftClusterProperties OpenShiftClusterProperties
err = json.Unmarshal(*v, &openShiftClusterProperties)
if err != nil {
return err
}
osc.OpenShiftClusterProperties = &openShiftClusterProperties
}
case "tags":
if v != nil {
var tags map[string]*string
@ -269,15 +280,6 @@ func (osc *OpenShiftCluster) UnmarshalJSON(body []byte) error {
}
osc.Location = &location
}
case "properties":
if v != nil {
var properties Properties
err = json.Unmarshal(*v, &properties)
if err != nil {
return err
}
osc.Properties = &properties
}
case "id":
if v != nil {
var ID string
@ -325,6 +327,167 @@ type OpenShiftClusterList struct {
autorest.Response `json:"-"`
// Value - The list of OpenShift clusters.
Value *[]OpenShiftCluster `json:"value,omitempty"`
// NextLink - The link used to get the next page of operations.
NextLink *string `json:"nextLink,omitempty"`
}
// OpenShiftClusterListIterator provides access to a complete listing of OpenShiftCluster values.
type OpenShiftClusterListIterator struct {
i int
page OpenShiftClusterListPage
}
// NextWithContext 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 *OpenShiftClusterListIterator) NextWithContext(ctx context.Context) (err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClusterListIterator.NextWithContext")
defer func() {
sc := -1
if iter.Response().Response.Response != nil {
sc = iter.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
iter.i++
if iter.i < len(iter.page.Values()) {
return nil
}
err = iter.page.NextWithContext(ctx)
if err != nil {
iter.i--
return err
}
iter.i = 0
return nil
}
// Next advances to the next value. If there was an error making
// the request the iterator does not advance and the error is returned.
// Deprecated: Use NextWithContext() instead.
func (iter *OpenShiftClusterListIterator) Next() error {
return iter.NextWithContext(context.Background())
}
// NotDone returns true if the enumeration should be started or is not yet complete.
func (iter OpenShiftClusterListIterator) 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 OpenShiftClusterListIterator) Response() OpenShiftClusterList {
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 OpenShiftClusterListIterator) Value() OpenShiftCluster {
if !iter.page.NotDone() {
return OpenShiftCluster{}
}
return iter.page.Values()[iter.i]
}
// Creates a new instance of the OpenShiftClusterListIterator type.
func NewOpenShiftClusterListIterator(page OpenShiftClusterListPage) OpenShiftClusterListIterator {
return OpenShiftClusterListIterator{page: page}
}
// IsEmpty returns true if the ListResult contains no values.
func (oscl OpenShiftClusterList) IsEmpty() bool {
return oscl.Value == nil || len(*oscl.Value) == 0
}
// openShiftClusterListPreparer prepares a request to retrieve the next set of results.
// It returns nil if no more results exist.
func (oscl OpenShiftClusterList) openShiftClusterListPreparer(ctx context.Context) (*http.Request, error) {
if oscl.NextLink == nil || len(to.String(oscl.NextLink)) < 1 {
return nil, nil
}
return autorest.Prepare((&http.Request{}).WithContext(ctx),
autorest.AsJSON(),
autorest.AsGet(),
autorest.WithBaseURL(to.String(oscl.NextLink)))
}
// OpenShiftClusterListPage contains a page of OpenShiftCluster values.
type OpenShiftClusterListPage struct {
fn func(context.Context, OpenShiftClusterList) (OpenShiftClusterList, error)
oscl OpenShiftClusterList
}
// NextWithContext 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 *OpenShiftClusterListPage) NextWithContext(ctx context.Context) (err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClusterListPage.NextWithContext")
defer func() {
sc := -1
if page.Response().Response.Response != nil {
sc = page.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
next, err := page.fn(ctx, page.oscl)
if err != nil {
return err
}
page.oscl = next
return nil
}
// 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.
// Deprecated: Use NextWithContext() instead.
func (page *OpenShiftClusterListPage) Next() error {
return page.NextWithContext(context.Background())
}
// NotDone returns true if the page enumeration should be started or is not yet complete.
func (page OpenShiftClusterListPage) NotDone() bool {
return !page.oscl.IsEmpty()
}
// Response returns the raw server response from the last page request.
func (page OpenShiftClusterListPage) Response() OpenShiftClusterList {
return page.oscl
}
// Values returns the slice of values for the current page or nil if there are no values.
func (page OpenShiftClusterListPage) Values() []OpenShiftCluster {
if page.oscl.IsEmpty() {
return nil
}
return *page.oscl.Value
}
// Creates a new instance of the OpenShiftClusterListPage type.
func NewOpenShiftClusterListPage(getNextPage func(context.Context, OpenShiftClusterList) (OpenShiftClusterList, error)) OpenShiftClusterListPage {
return OpenShiftClusterListPage{fn: getNextPage}
}
// OpenShiftClusterProperties openShiftClusterProperties represents an OpenShift cluster's properties.
type OpenShiftClusterProperties struct {
// ProvisioningState - The cluster provisioning state (immutable). Possible values include: 'AdminUpdating', 'Creating', 'Deleting', 'Failed', 'Succeeded', 'Updating'
ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
// ClusterProfile - The cluster profile.
ClusterProfile *ClusterProfile `json:"clusterProfile,omitempty"`
// ConsoleProfile - The console profile.
ConsoleProfile *ConsoleProfile `json:"consoleProfile,omitempty"`
// ServicePrincipalProfile - The cluster service principal profile.
ServicePrincipalProfile *ServicePrincipalProfile `json:"servicePrincipalProfile,omitempty"`
// NetworkProfile - The cluster network profile.
NetworkProfile *NetworkProfile `json:"networkProfile,omitempty"`
// MasterProfile - The cluster master profile.
MasterProfile *MasterProfile `json:"masterProfile,omitempty"`
// WorkerProfiles - The cluster worker profiles.
WorkerProfiles *[]WorkerProfile `json:"workerProfiles,omitempty"`
// ApiserverProfile - The cluster API server profile.
ApiserverProfile *APIServerProfile `json:"apiserverProfile,omitempty"`
// IngressProfiles - The cluster ingress profiles.
IngressProfiles *[]IngressProfile `json:"ingressProfiles,omitempty"`
}
// OpenShiftClustersCreateOrUpdateFuture an abstraction for monitoring and retrieving the results of a
@ -408,7 +571,60 @@ func (future *OpenShiftClustersUpdateFuture) Result(client OpenShiftClustersClie
return
}
// Operation operation represents an operation.
// OpenShiftClusterUpdate openShiftCluster represents an Azure Red Hat OpenShift cluster.
type OpenShiftClusterUpdate struct {
// Tags - The resource tags.
Tags map[string]*string `json:"tags"`
// OpenShiftClusterProperties - The cluster properties.
*OpenShiftClusterProperties `json:"properties,omitempty"`
}
// MarshalJSON is the custom marshaler for OpenShiftClusterUpdate.
func (oscu OpenShiftClusterUpdate) MarshalJSON() ([]byte, error) {
objectMap := make(map[string]interface{})
if oscu.Tags != nil {
objectMap["tags"] = oscu.Tags
}
if oscu.OpenShiftClusterProperties != nil {
objectMap["properties"] = oscu.OpenShiftClusterProperties
}
return json.Marshal(objectMap)
}
// UnmarshalJSON is the custom unmarshaler for OpenShiftClusterUpdate struct.
func (oscu *OpenShiftClusterUpdate) UnmarshalJSON(body []byte) error {
var m map[string]*json.RawMessage
err := json.Unmarshal(body, &m)
if err != nil {
return err
}
for k, v := range m {
switch k {
case "tags":
if v != nil {
var tags map[string]*string
err = json.Unmarshal(*v, &tags)
if err != nil {
return err
}
oscu.Tags = tags
}
case "properties":
if v != nil {
var openShiftClusterProperties OpenShiftClusterProperties
err = json.Unmarshal(*v, &openShiftClusterProperties)
if err != nil {
return err
}
oscu.OpenShiftClusterProperties = &openShiftClusterProperties
}
}
}
return nil
}
// Operation operation represents an RP operation.
type Operation struct {
// Name - Operation name: {provider}/{resource}/{operation}.
Name *string `json:"name,omitempty"`
@ -416,33 +632,150 @@ type Operation struct {
Display *Display `json:"display,omitempty"`
}
// OperationList operationList represents an operation list.
// OperationList operationList represents an RP operation list.
type OperationList struct {
autorest.Response `json:"-"`
// Value - List of operations supported by the resource provider.
Value *[]Operation `json:"value,omitempty"`
// NextLink - The link used to get the next page of operations.
NextLink *string `json:"nextLink,omitempty"`
}
// Properties properties represents an OpenShift cluster's properties.
type Properties struct {
// ProvisioningState - The cluster provisioning state (immutable). Possible values include: 'AdminUpdating', 'Creating', 'Deleting', 'Failed', 'Succeeded', 'Updating'
ProvisioningState ProvisioningState `json:"provisioningState,omitempty"`
// ClusterProfile - The cluster profile.
ClusterProfile *ClusterProfile `json:"clusterProfile,omitempty"`
// ConsoleProfile - The console profile.
ConsoleProfile *ConsoleProfile `json:"consoleProfile,omitempty"`
// ServicePrincipalProfile - The cluster service principal profile.
ServicePrincipalProfile *ServicePrincipalProfile `json:"servicePrincipalProfile,omitempty"`
// NetworkProfile - The cluster network profile.
NetworkProfile *NetworkProfile `json:"networkProfile,omitempty"`
// MasterProfile - The cluster master profile.
MasterProfile *MasterProfile `json:"masterProfile,omitempty"`
// WorkerProfiles - The cluster worker profiles.
WorkerProfiles *[]WorkerProfile `json:"workerProfiles,omitempty"`
// ApiserverProfile - The cluster API server profile.
ApiserverProfile *APIServerProfile `json:"apiserverProfile,omitempty"`
// IngressProfiles - The cluster ingress profiles.
IngressProfiles *[]IngressProfile `json:"ingressProfiles,omitempty"`
// OperationListIterator provides access to a complete listing of Operation values.
type OperationListIterator struct {
i int
page OperationListPage
}
// NextWithContext 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 *OperationListIterator) NextWithContext(ctx context.Context) (err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OperationListIterator.NextWithContext")
defer func() {
sc := -1
if iter.Response().Response.Response != nil {
sc = iter.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
iter.i++
if iter.i < len(iter.page.Values()) {
return nil
}
err = iter.page.NextWithContext(ctx)
if err != nil {
iter.i--
return err
}
iter.i = 0
return nil
}
// Next advances to the next value. If there was an error making
// the request the iterator does not advance and the error is returned.
// Deprecated: Use NextWithContext() instead.
func (iter *OperationListIterator) Next() error {
return iter.NextWithContext(context.Background())
}
// NotDone returns true if the enumeration should be started or is not yet complete.
func (iter OperationListIterator) 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 OperationListIterator) Response() OperationList {
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 OperationListIterator) Value() Operation {
if !iter.page.NotDone() {
return Operation{}
}
return iter.page.Values()[iter.i]
}
// Creates a new instance of the OperationListIterator type.
func NewOperationListIterator(page OperationListPage) OperationListIterator {
return OperationListIterator{page: page}
}
// IsEmpty returns true if the ListResult contains no values.
func (ol OperationList) IsEmpty() bool {
return ol.Value == nil || len(*ol.Value) == 0
}
// operationListPreparer prepares a request to retrieve the next set of results.
// It returns nil if no more results exist.
func (ol OperationList) operationListPreparer(ctx context.Context) (*http.Request, error) {
if ol.NextLink == nil || len(to.String(ol.NextLink)) < 1 {
return nil, nil
}
return autorest.Prepare((&http.Request{}).WithContext(ctx),
autorest.AsJSON(),
autorest.AsGet(),
autorest.WithBaseURL(to.String(ol.NextLink)))
}
// OperationListPage contains a page of Operation values.
type OperationListPage struct {
fn func(context.Context, OperationList) (OperationList, error)
ol OperationList
}
// NextWithContext 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 *OperationListPage) NextWithContext(ctx context.Context) (err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OperationListPage.NextWithContext")
defer func() {
sc := -1
if page.Response().Response.Response != nil {
sc = page.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
next, err := page.fn(ctx, page.ol)
if err != nil {
return err
}
page.ol = next
return nil
}
// 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.
// Deprecated: Use NextWithContext() instead.
func (page *OperationListPage) Next() error {
return page.NextWithContext(context.Background())
}
// NotDone returns true if the page enumeration should be started or is not yet complete.
func (page OperationListPage) NotDone() bool {
return !page.ol.IsEmpty()
}
// Response returns the raw server response from the last page request.
func (page OperationListPage) Response() OperationList {
return page.ol
}
// Values returns the slice of values for the current page or nil if there are no values.
func (page OperationListPage) Values() []Operation {
if page.ol.IsEmpty() {
return nil
}
return *page.ol.Value
}
// Creates a new instance of the OperationListPage type.
func NewOperationListPage(getNextPage func(context.Context, OperationList) (OperationList, error)) OperationListPage {
return OperationListPage{fn: getNextPage}
}
// ProxyResource the resource model definition for a ARM proxy resource. It will have everything other than

121
pkg/client/services/preview/redhatopenshift/mgmt/2019-12-31-preview/redhatopenshift/openshiftclusters.go
Просмотреть файл

@ -112,9 +112,8 @@ func (client OpenShiftClustersClient) CreateOrUpdatePreparer(ctx context.Context
// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) CreateOrUpdateSender(req *http.Request) (future OpenShiftClustersCreateOrUpdateFuture, err error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
var resp *http.Response
resp, err = autorest.SendWithSender(client, req, sd...)
resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
if err != nil {
return
}
@ -200,9 +199,8 @@ func (client OpenShiftClustersClient) DeletePreparer(ctx context.Context, resour
// DeleteSender sends the Delete request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) DeleteSender(req *http.Request) (future OpenShiftClustersDeleteFuture, err error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
var resp *http.Response
resp, err = autorest.SendWithSender(client, req, sd...)
resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
if err != nil {
return
}
@ -293,8 +291,7 @@ func (client OpenShiftClustersClient) GetPreparer(ctx context.Context, resourceG
// GetSender sends the Get request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) GetSender(req *http.Request) (*http.Response, error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
return autorest.SendWithSender(client, req, sd...)
return client.Send(req, azure.DoRetryWithRegistration(client.Client))
}
// GetResponder handles the response to the Get request. The method always
@ -312,13 +309,13 @@ func (client OpenShiftClustersClient) GetResponder(resp *http.Response) (result
// List lists OpenShift clusters in the specified subscription. The operation returns properties of each OpenShift
// cluster.
func (client OpenShiftClustersClient) List(ctx context.Context) (result OpenShiftClusterList, err error) {
func (client OpenShiftClustersClient) List(ctx context.Context) (result OpenShiftClusterListPage, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClustersClient.List")
defer func() {
sc := -1
if result.Response.Response != nil {
sc = result.Response.Response.StatusCode
if result.oscl.Response.Response != nil {
sc = result.oscl.Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
@ -329,6 +326,7 @@ func (client OpenShiftClustersClient) List(ctx context.Context) (result OpenShif
return result, validation.NewError("redhatopenshift.OpenShiftClustersClient", "List", err.Error())
}
result.fn = client.listNextResults
req, err := client.ListPreparer(ctx)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "List", nil, "Failure preparing request")
@ -337,12 +335,12 @@ func (client OpenShiftClustersClient) List(ctx context.Context) (result OpenShif
resp, err := client.ListSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
result.oscl.Response = autorest.Response{Response: resp}
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "List", resp, "Failure sending request")
return
}
result, err = client.ListResponder(resp)
result.oscl, err = client.ListResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "List", resp, "Failure responding to request")
}
@ -372,8 +370,7 @@ func (client OpenShiftClustersClient) ListPreparer(ctx context.Context) (*http.R
// ListSender sends the List request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) ListSender(req *http.Request) (*http.Response, error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
return autorest.SendWithSender(client, req, sd...)
return client.Send(req, azure.DoRetryWithRegistration(client.Client))
}
// ListResponder handles the response to the List request. The method always
@ -389,17 +386,54 @@ func (client OpenShiftClustersClient) ListResponder(resp *http.Response) (result
return
}
// listNextResults retrieves the next set of results, if any.
func (client OpenShiftClustersClient) listNextResults(ctx context.Context, lastResults OpenShiftClusterList) (result OpenShiftClusterList, err error) {
req, err := lastResults.openShiftClusterListPreparer(ctx)
if err != nil {
return result, autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "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, "redhatopenshift.OpenShiftClustersClient", "listNextResults", resp, "Failure sending next results request")
}
result, err = client.ListResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "listNextResults", resp, "Failure responding to next results request")
}
return
}
// ListComplete enumerates all values, automatically crossing page boundaries as required.
func (client OpenShiftClustersClient) ListComplete(ctx context.Context) (result OpenShiftClusterListIterator, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClustersClient.List")
defer func() {
sc := -1
if result.Response().Response.Response != nil {
sc = result.page.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
result.page, err = client.List(ctx)
return
}
// ListByResourceGroup lists OpenShift clusters in the specified subscription and resource group. The operation
// returns properties of each OpenShift cluster.
// Parameters:
// resourceGroupName - the name of the resource group. The name is case insensitive.
func (client OpenShiftClustersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result OpenShiftClusterList, err error) {
func (client OpenShiftClustersClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result OpenShiftClusterListPage, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClustersClient.ListByResourceGroup")
defer func() {
sc := -1
if result.Response.Response != nil {
sc = result.Response.Response.StatusCode
if result.oscl.Response.Response != nil {
sc = result.oscl.Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
@ -414,6 +448,7 @@ func (client OpenShiftClustersClient) ListByResourceGroup(ctx context.Context, r
return result, validation.NewError("redhatopenshift.OpenShiftClustersClient", "ListByResourceGroup", err.Error())
}
result.fn = client.listByResourceGroupNextResults
req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "ListByResourceGroup", nil, "Failure preparing request")
@ -422,12 +457,12 @@ func (client OpenShiftClustersClient) ListByResourceGroup(ctx context.Context, r
resp, err := client.ListByResourceGroupSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
result.oscl.Response = autorest.Response{Response: resp}
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "ListByResourceGroup", resp, "Failure sending request")
return
}
result, err = client.ListByResourceGroupResponder(resp)
result.oscl, err = client.ListByResourceGroupResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "ListByResourceGroup", resp, "Failure responding to request")
}
@ -458,8 +493,7 @@ func (client OpenShiftClustersClient) ListByResourceGroupPreparer(ctx context.Co
// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
return autorest.SendWithSender(client, req, sd...)
return client.Send(req, azure.DoRetryWithRegistration(client.Client))
}
// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
@ -475,6 +509,43 @@ func (client OpenShiftClustersClient) ListByResourceGroupResponder(resp *http.Re
return
}
// listByResourceGroupNextResults retrieves the next set of results, if any.
func (client OpenShiftClustersClient) listByResourceGroupNextResults(ctx context.Context, lastResults OpenShiftClusterList) (result OpenShiftClusterList, err error) {
req, err := lastResults.openShiftClusterListPreparer(ctx)
if err != nil {
return result, autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
}
if req == nil {
return
}
resp, err := client.ListByResourceGroupSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
return result, autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
}
result, err = client.ListByResourceGroupResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OpenShiftClustersClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
}
return
}
// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
func (client OpenShiftClustersClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result OpenShiftClusterListIterator, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClustersClient.ListByResourceGroup")
defer func() {
sc := -1
if result.Response().Response.Response != nil {
sc = result.page.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
return
}
// ListCredentials lists credentials of an OpenShift cluster with the specified subscription, resource group and
// resource name. The operation returns the credentials.
// Parameters:
@ -546,8 +617,7 @@ func (client OpenShiftClustersClient) ListCredentialsPreparer(ctx context.Contex
// ListCredentialsSender sends the ListCredentials request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) ListCredentialsSender(req *http.Request) (*http.Response, error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
return autorest.SendWithSender(client, req, sd...)
return client.Send(req, azure.DoRetryWithRegistration(client.Client))
}
// ListCredentialsResponder handles the response to the ListCredentials request. The method always
@ -569,7 +639,7 @@ func (client OpenShiftClustersClient) ListCredentialsResponder(resp *http.Respon
// resourceGroupName - the name of the resource group. The name is case insensitive.
// resourceName - the name of the OpenShift cluster resource.
// parameters - the OpenShift cluster resource.
func (client OpenShiftClustersClient) Update(ctx context.Context, resourceGroupName string, resourceName string, parameters OpenShiftCluster) (result OpenShiftClustersUpdateFuture, err error) {
func (client OpenShiftClustersClient) Update(ctx context.Context, resourceGroupName string, resourceName string, parameters OpenShiftClusterUpdate) (result OpenShiftClustersUpdateFuture, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OpenShiftClustersClient.Update")
defer func() {
@ -606,7 +676,7 @@ func (client OpenShiftClustersClient) Update(ctx context.Context, resourceGroupN
}
// UpdatePreparer prepares the Update request.
func (client OpenShiftClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters OpenShiftCluster) (*http.Request, error) {
func (client OpenShiftClustersClient) UpdatePreparer(ctx context.Context, resourceGroupName string, resourceName string, parameters OpenShiftClusterUpdate) (*http.Request, error) {
pathParameters := map[string]interface{}{
"resourceGroupName": autorest.Encode("path", resourceGroupName),
"resourceName": autorest.Encode("path", resourceName),
@ -631,9 +701,8 @@ func (client OpenShiftClustersClient) UpdatePreparer(ctx context.Context, resour
// UpdateSender sends the Update request. The method will close the
// http.Response Body if it receives an error.
func (client OpenShiftClustersClient) UpdateSender(req *http.Request) (future OpenShiftClustersUpdateFuture, err error) {
sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client))
var resp *http.Response
resp, err = autorest.SendWithSender(client, req, sd...)
resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
if err != nil {
return
}

53
pkg/client/services/preview/redhatopenshift/mgmt/2019-12-31-preview/redhatopenshift/operations.go
Просмотреть файл

@ -42,18 +42,19 @@ func NewOperationsClientWithBaseURI(baseURI string, subscriptionID string) Opera
return OperationsClient{NewWithBaseURI(baseURI, subscriptionID)}
}
// List lists all of the available RP operations. The operation returns the operations.
func (client OperationsClient) List(ctx context.Context) (result OperationList, err error) {
// List lists all of the available RP operations. The operation returns the RP operations.
func (client OperationsClient) List(ctx context.Context) (result OperationListPage, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
defer func() {
sc := -1
if result.Response.Response != nil {
sc = result.Response.Response.StatusCode
if result.ol.Response.Response != nil {
sc = result.ol.Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
result.fn = client.listNextResults
req, err := client.ListPreparer(ctx)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OperationsClient", "List", nil, "Failure preparing request")
@ -62,12 +63,12 @@ func (client OperationsClient) List(ctx context.Context) (result OperationList,
resp, err := client.ListSender(req)
if err != nil {
result.Response = autorest.Response{Response: resp}
result.ol.Response = autorest.Response{Response: resp}
err = autorest.NewErrorWithError(err, "redhatopenshift.OperationsClient", "List", resp, "Failure sending request")
return
}
result, err = client.ListResponder(resp)
result.ol, err = client.ListResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OperationsClient", "List", resp, "Failure responding to request")
}
@ -93,8 +94,7 @@ func (client OperationsClient) ListPreparer(ctx context.Context) (*http.Request,
// ListSender sends the List request. The method will close the
// http.Response Body if it receives an error.
func (client OperationsClient) ListSender(req *http.Request) (*http.Response, error) {
sd := autorest.GetSendDecorators(req.Context(), autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
return autorest.SendWithSender(client, req, sd...)
return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
}
// ListResponder handles the response to the List request. The method always
@ -109,3 +109,40 @@ func (client OperationsClient) ListResponder(resp *http.Response) (result Operat
result.Response = autorest.Response{Response: resp}
return
}
// listNextResults retrieves the next set of results, if any.
func (client OperationsClient) listNextResults(ctx context.Context, lastResults OperationList) (result OperationList, err error) {
req, err := lastResults.operationListPreparer(ctx)
if err != nil {
return result, autorest.NewErrorWithError(err, "redhatopenshift.OperationsClient", "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, "redhatopenshift.OperationsClient", "listNextResults", resp, "Failure sending next results request")
}
result, err = client.ListResponder(resp)
if err != nil {
err = autorest.NewErrorWithError(err, "redhatopenshift.OperationsClient", "listNextResults", resp, "Failure responding to next results request")
}
return
}
// ListComplete enumerates all values, automatically crossing page boundaries as required.
func (client OperationsClient) ListComplete(ctx context.Context) (result OperationListIterator, err error) {
if tracing.IsEnabled() {
ctx = tracing.StartSpan(ctx, fqdn+"/OperationsClient.List")
defer func() {
sc := -1
if result.Response().Response.Response != nil {
sc = result.page.Response().Response.Response.StatusCode
}
tracing.EndSpan(ctx, sc, err)
}()
}
result.page, err = client.List(ctx)
return
}

11
pkg/client/services/preview/redhatopenshift/mgmt/2019-12-31-preview/redhatopenshift/redhatopenshiftapi/interfaces.go
Просмотреть файл

@ -25,7 +25,8 @@ import (
// OperationsClientAPI contains the set of methods on the OperationsClient type.
type OperationsClientAPI interface {
List(ctx context.Context) (result redhatopenshift.OperationList, err error)
List(ctx context.Context) (result redhatopenshift.OperationListPage, err error)
ListComplete(ctx context.Context) (result redhatopenshift.OperationListIterator, err error)
}
var _ OperationsClientAPI = (*redhatopenshift.OperationsClient)(nil)
@ -35,10 +36,12 @@ type OpenShiftClustersClientAPI interface {
CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters redhatopenshift.OpenShiftCluster) (result redhatopenshift.OpenShiftClustersCreateOrUpdateFuture, err error)
Delete(ctx context.Context, resourceGroupName string, resourceName string) (result redhatopenshift.OpenShiftClustersDeleteFuture, err error)
Get(ctx context.Context, resourceGroupName string, resourceName string) (result redhatopenshift.OpenShiftCluster, err error)
List(ctx context.Context) (result redhatopenshift.OpenShiftClusterList, err error)
ListByResourceGroup(ctx context.Context, resourceGroupName string) (result redhatopenshift.OpenShiftClusterList, err error)
List(ctx context.Context) (result redhatopenshift.OpenShiftClusterListPage, err error)
ListComplete(ctx context.Context) (result redhatopenshift.OpenShiftClusterListIterator, err error)
ListByResourceGroup(ctx context.Context, resourceGroupName string) (result redhatopenshift.OpenShiftClusterListPage, err error)
ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result redhatopenshift.OpenShiftClusterListIterator, err error)
ListCredentials(ctx context.Context, resourceGroupName string, resourceName string) (result redhatopenshift.OpenShiftClusterCredentials, err error)
Update(ctx context.Context, resourceGroupName string, resourceName string, parameters redhatopenshift.OpenShiftCluster) (result redhatopenshift.OpenShiftClustersUpdateFuture, err error)
Update(ctx context.Context, resourceGroupName string, resourceName string, parameters redhatopenshift.OpenShiftClusterUpdate) (result redhatopenshift.OpenShiftClustersUpdateFuture, err error)
}
var _ OpenShiftClustersClientAPI = (*redhatopenshift.OpenShiftClustersClient)(nil)

13
python/client/azure/mgmt/redhatopenshift/v2019_12_31_preview/models/__init__.py
Просмотреть файл

@ -32,9 +32,8 @@ try:
from ._models_py3 import NetworkProfile
from ._models_py3 import OpenShiftCluster
from ._models_py3 import OpenShiftClusterCredentials
from ._models_py3 import OpenShiftClusterList
from ._models_py3 import OpenShiftClusterUpdate
from ._models_py3 import Operation
from ._models_py3 import OperationList
from ._models_py3 import ProxyResource
from ._models_py3 import Resource
from ._models_py3 import ServicePrincipalProfile
@ -53,14 +52,15 @@ except (SyntaxError, ImportError):
from ._models import NetworkProfile
from ._models import OpenShiftCluster
from ._models import OpenShiftClusterCredentials
from ._models import OpenShiftClusterList
from ._models import OpenShiftClusterUpdate
from ._models import Operation
from ._models import OperationList
from ._models import ProxyResource
from ._models import Resource
from ._models import ServicePrincipalProfile
from ._models import TrackedResource
from ._models import WorkerProfile
from ._paged_models import OpenShiftClusterPaged
from ._paged_models import OperationPaged
__all__ = [
'APIServerProfile',
@ -75,12 +75,13 @@ __all__ = [
'NetworkProfile',
'OpenShiftCluster',
'OpenShiftClusterCredentials',
'OpenShiftClusterList',
'OpenShiftClusterUpdate',
'Operation',
'OperationList',
'ProxyResource',
'Resource',
'ServicePrincipalProfile',
'TrackedResource',
'WorkerProfile',
'OperationPaged',
'OpenShiftClusterPaged',
]

182
python/client/azure/mgmt/redhatopenshift/v2019_12_31_preview/models/_models.py
Просмотреть файл

@ -184,7 +184,7 @@ class CloudErrorBody(Model):
class ClusterProfile(Model):
"""ClusterProfile.
"""ClusterProfile represents a cluster profile.
:param domain: The domain for the cluster (immutable).
:type domain: str
@ -209,7 +209,7 @@ class ClusterProfile(Model):
class ConsoleProfile(Model):
"""ConsoleProfile.
"""ConsoleProfile represents a console profile.
:param url: The URL to access the cluster console (immutable).
:type url: str
@ -322,12 +322,14 @@ class NetworkProfile(Model):
self.service_cidr = kwargs.get('service_cidr', None)
class OpenShiftCluster(Resource):
"""OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
class TrackedResource(Resource):
"""The resource model definition for a ARM tracked top level resource.
Variables are only populated by the server, and will be ignored when
sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
:vartype id: str
@ -338,7 +340,50 @@ class OpenShiftCluster(Resource):
:vartype type: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param location: The geo-location where the resource lives
:param location: Required. The geo-location where the resource lives
:type location: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'location': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'location': {'key': 'location', 'type': 'str'},
}
def __init__(self, **kwargs):
super(TrackedResource, self).__init__(**kwargs)
self.tags = kwargs.get('tags', None)
self.location = kwargs.get('location', None)
class OpenShiftCluster(TrackedResource):
"""OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
Variables are only populated by the server, and will be ignored when
sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
:vartype id: str
:ivar name: The name of the resource
:vartype name: str
:ivar type: The type of the resource. Ex-
Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
:vartype type: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param location: Required. The geo-location where the resource lives
:type location: str
:param provisioning_state: The cluster provisioning state (immutable).
Possible values include: 'AdminUpdating', 'Creating', 'Deleting',
@ -375,6 +420,7 @@ class OpenShiftCluster(Resource):
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'location': {'required': True},
}
_attribute_map = {
@ -396,8 +442,6 @@ class OpenShiftCluster(Resource):
def __init__(self, **kwargs):
super(OpenShiftCluster, self).__init__(**kwargs)
self.tags = kwargs.get('tags', None)
self.location = kwargs.get('location', None)
self.provisioning_state = kwargs.get('provisioning_state', None)
self.cluster_profile = kwargs.get('cluster_profile', None)
self.console_profile = kwargs.get('console_profile', None)
@ -429,25 +473,71 @@ class OpenShiftClusterCredentials(Model):
self.kubeadmin_password = kwargs.get('kubeadmin_password', None)
class OpenShiftClusterList(Model):
"""OpenShiftClusterList represents a list of OpenShift clusters.
class OpenShiftClusterUpdate(Model):
"""OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
:param value: The list of OpenShift clusters.
:type value:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftCluster]
:param tags: The resource tags.
:type tags: dict[str, str]
:param provisioning_state: The cluster provisioning state (immutable).
Possible values include: 'AdminUpdating', 'Creating', 'Deleting',
'Failed', 'Succeeded', 'Updating'
:type provisioning_state: str or
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.enum
:param cluster_profile: The cluster profile.
:type cluster_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.ClusterProfile
:param console_profile: The console profile.
:type console_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.ConsoleProfile
:param service_principal_profile: The cluster service principal profile.
:type service_principal_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.ServicePrincipalProfile
:param network_profile: The cluster network profile.
:type network_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.NetworkProfile
:param master_profile: The cluster master profile.
:type master_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.MasterProfile
:param worker_profiles: The cluster worker profiles.
:type worker_profiles:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.WorkerProfile]
:param apiserver_profile: The cluster API server profile.
:type apiserver_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.APIServerProfile
:param ingress_profiles: The cluster ingress profiles.
:type ingress_profiles:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.IngressProfile]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[OpenShiftCluster]'},
'tags': {'key': 'tags', 'type': '{str}'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'cluster_profile': {'key': 'properties.clusterProfile', 'type': 'ClusterProfile'},
'console_profile': {'key': 'properties.consoleProfile', 'type': 'ConsoleProfile'},
'service_principal_profile': {'key': 'properties.servicePrincipalProfile', 'type': 'ServicePrincipalProfile'},
'network_profile': {'key': 'properties.networkProfile', 'type': 'NetworkProfile'},
'master_profile': {'key': 'properties.masterProfile', 'type': 'MasterProfile'},
'worker_profiles': {'key': 'properties.workerProfiles', 'type': '[WorkerProfile]'},
'apiserver_profile': {'key': 'properties.apiserverProfile', 'type': 'APIServerProfile'},
'ingress_profiles': {'key': 'properties.ingressProfiles', 'type': '[IngressProfile]'},
}
def __init__(self, **kwargs):
super(OpenShiftClusterList, self).__init__(**kwargs)
self.value = kwargs.get('value', None)
super(OpenShiftClusterUpdate, self).__init__(**kwargs)
self.tags = kwargs.get('tags', None)
self.provisioning_state = kwargs.get('provisioning_state', None)
self.cluster_profile = kwargs.get('cluster_profile', None)
self.console_profile = kwargs.get('console_profile', None)
self.service_principal_profile = kwargs.get('service_principal_profile', None)
self.network_profile = kwargs.get('network_profile', None)
self.master_profile = kwargs.get('master_profile', None)
self.worker_profiles = kwargs.get('worker_profiles', None)
self.apiserver_profile = kwargs.get('apiserver_profile', None)
self.ingress_profiles = kwargs.get('ingress_profiles', None)
class Operation(Model):
"""Operation represents an operation.
"""Operation represents an RP operation.
:param name: Operation name: {provider}/{resource}/{operation}.
:type name: str
@ -467,23 +557,6 @@ class Operation(Model):
self.display = kwargs.get('display', None)
class OperationList(Model):
"""OperationList represents an operation list.
:param value: List of operations supported by the resource provider.
:type value:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.Operation]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[Operation]'},
}
def __init__(self, **kwargs):
super(OperationList, self).__init__(**kwargs)
self.value = kwargs.get('value', None)
class ProxyResource(Resource):
"""The resource model definition for a ARM proxy resource. It will have
everything other than required location and tags.
@ -537,49 +610,6 @@ class ServicePrincipalProfile(Model):
self.client_secret = kwargs.get('client_secret', None)
class TrackedResource(Resource):
"""The resource model definition for a ARM tracked top level resource.
Variables are only populated by the server, and will be ignored when
sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
:vartype id: str
:ivar name: The name of the resource
:vartype name: str
:ivar type: The type of the resource. Ex-
Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
:vartype type: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param location: Required. The geo-location where the resource lives
:type location: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'location': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'location': {'key': 'location', 'type': 'str'},
}
def __init__(self, **kwargs):
super(TrackedResource, self).__init__(**kwargs)
self.tags = kwargs.get('tags', None)
self.location = kwargs.get('location', None)
class WorkerProfile(Model):
"""WorkerProfile represents a worker profile.

188
python/client/azure/mgmt/redhatopenshift/v2019_12_31_preview/models/_models_py3.py
Просмотреть файл

@ -184,7 +184,7 @@ class CloudErrorBody(Model):
class ClusterProfile(Model):
"""ClusterProfile.
"""ClusterProfile represents a cluster profile.
:param domain: The domain for the cluster (immutable).
:type domain: str
@ -209,7 +209,7 @@ class ClusterProfile(Model):
class ConsoleProfile(Model):
"""ConsoleProfile.
"""ConsoleProfile represents a console profile.
:param url: The URL to access the cluster console (immutable).
:type url: str
@ -322,12 +322,14 @@ class NetworkProfile(Model):
self.service_cidr = service_cidr
class OpenShiftCluster(Resource):
"""OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
class TrackedResource(Resource):
"""The resource model definition for a ARM tracked top level resource.
Variables are only populated by the server, and will be ignored when
sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
:vartype id: str
@ -338,7 +340,50 @@ class OpenShiftCluster(Resource):
:vartype type: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param location: The geo-location where the resource lives
:param location: Required. The geo-location where the resource lives
:type location: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'location': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'location': {'key': 'location', 'type': 'str'},
}
def __init__(self, *, location: str, tags=None, **kwargs) -> None:
super(TrackedResource, self).__init__(**kwargs)
self.tags = tags
self.location = location
class OpenShiftCluster(TrackedResource):
"""OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
Variables are only populated by the server, and will be ignored when
sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
:vartype id: str
:ivar name: The name of the resource
:vartype name: str
:ivar type: The type of the resource. Ex-
Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
:vartype type: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param location: Required. The geo-location where the resource lives
:type location: str
:param provisioning_state: The cluster provisioning state (immutable).
Possible values include: 'AdminUpdating', 'Creating', 'Deleting',
@ -375,6 +420,7 @@ class OpenShiftCluster(Resource):
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'location': {'required': True},
}
_attribute_map = {
@ -394,10 +440,8 @@ class OpenShiftCluster(Resource):
'ingress_profiles': {'key': 'properties.ingressProfiles', 'type': '[IngressProfile]'},
}
def __init__(self, *, tags=None, location: str=None, provisioning_state=None, cluster_profile=None, console_profile=None, service_principal_profile=None, network_profile=None, master_profile=None, worker_profiles=None, apiserver_profile=None, ingress_profiles=None, **kwargs) -> None:
super(OpenShiftCluster, self).__init__(**kwargs)
self.tags = tags
self.location = location
def __init__(self, *, location: str, tags=None, provisioning_state=None, cluster_profile=None, console_profile=None, service_principal_profile=None, network_profile=None, master_profile=None, worker_profiles=None, apiserver_profile=None, ingress_profiles=None, **kwargs) -> None:
super(OpenShiftCluster, self).__init__(tags=tags, location=location, **kwargs)
self.provisioning_state = provisioning_state
self.cluster_profile = cluster_profile
self.console_profile = console_profile
@ -429,25 +473,71 @@ class OpenShiftClusterCredentials(Model):
self.kubeadmin_password = kubeadmin_password
class OpenShiftClusterList(Model):
"""OpenShiftClusterList represents a list of OpenShift clusters.
class OpenShiftClusterUpdate(Model):
"""OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
:param value: The list of OpenShift clusters.
:type value:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftCluster]
:param tags: The resource tags.
:type tags: dict[str, str]
:param provisioning_state: The cluster provisioning state (immutable).
Possible values include: 'AdminUpdating', 'Creating', 'Deleting',
'Failed', 'Succeeded', 'Updating'
:type provisioning_state: str or
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.enum
:param cluster_profile: The cluster profile.
:type cluster_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.ClusterProfile
:param console_profile: The console profile.
:type console_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.ConsoleProfile
:param service_principal_profile: The cluster service principal profile.
:type service_principal_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.ServicePrincipalProfile
:param network_profile: The cluster network profile.
:type network_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.NetworkProfile
:param master_profile: The cluster master profile.
:type master_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.MasterProfile
:param worker_profiles: The cluster worker profiles.
:type worker_profiles:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.WorkerProfile]
:param apiserver_profile: The cluster API server profile.
:type apiserver_profile:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.APIServerProfile
:param ingress_profiles: The cluster ingress profiles.
:type ingress_profiles:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.IngressProfile]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[OpenShiftCluster]'},
'tags': {'key': 'tags', 'type': '{str}'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'cluster_profile': {'key': 'properties.clusterProfile', 'type': 'ClusterProfile'},
'console_profile': {'key': 'properties.consoleProfile', 'type': 'ConsoleProfile'},
'service_principal_profile': {'key': 'properties.servicePrincipalProfile', 'type': 'ServicePrincipalProfile'},
'network_profile': {'key': 'properties.networkProfile', 'type': 'NetworkProfile'},
'master_profile': {'key': 'properties.masterProfile', 'type': 'MasterProfile'},
'worker_profiles': {'key': 'properties.workerProfiles', 'type': '[WorkerProfile]'},
'apiserver_profile': {'key': 'properties.apiserverProfile', 'type': 'APIServerProfile'},
'ingress_profiles': {'key': 'properties.ingressProfiles', 'type': '[IngressProfile]'},
}
def __init__(self, *, value=None, **kwargs) -> None:
super(OpenShiftClusterList, self).__init__(**kwargs)
self.value = value
def __init__(self, *, tags=None, provisioning_state=None, cluster_profile=None, console_profile=None, service_principal_profile=None, network_profile=None, master_profile=None, worker_profiles=None, apiserver_profile=None, ingress_profiles=None, **kwargs) -> None:
super(OpenShiftClusterUpdate, self).__init__(**kwargs)
self.tags = tags
self.provisioning_state = provisioning_state
self.cluster_profile = cluster_profile
self.console_profile = console_profile
self.service_principal_profile = service_principal_profile
self.network_profile = network_profile
self.master_profile = master_profile
self.worker_profiles = worker_profiles
self.apiserver_profile = apiserver_profile
self.ingress_profiles = ingress_profiles
class Operation(Model):
"""Operation represents an operation.
"""Operation represents an RP operation.
:param name: Operation name: {provider}/{resource}/{operation}.
:type name: str
@ -467,23 +557,6 @@ class Operation(Model):
self.display = display
class OperationList(Model):
"""OperationList represents an operation list.
:param value: List of operations supported by the resource provider.
:type value:
list[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.Operation]
"""
_attribute_map = {
'value': {'key': 'value', 'type': '[Operation]'},
}
def __init__(self, *, value=None, **kwargs) -> None:
super(OperationList, self).__init__(**kwargs)
self.value = value
class ProxyResource(Resource):
"""The resource model definition for a ARM proxy resource. It will have
everything other than required location and tags.
@ -537,49 +610,6 @@ class ServicePrincipalProfile(Model):
self.client_secret = client_secret
class TrackedResource(Resource):
"""The resource model definition for a ARM tracked top level resource.
Variables are only populated by the server, and will be ignored when
sending a request.
All required parameters must be populated in order to send to Azure.
:ivar id: Fully qualified resource Id for the resource. Ex -
/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
:vartype id: str
:ivar name: The name of the resource
:vartype name: str
:ivar type: The type of the resource. Ex-
Microsoft.Compute/virtualMachines or Microsoft.Storage/storageAccounts.
:vartype type: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param location: Required. The geo-location where the resource lives
:type location: str
"""
_validation = {
'id': {'readonly': True},
'name': {'readonly': True},
'type': {'readonly': True},
'location': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'location': {'key': 'location', 'type': 'str'},
}
def __init__(self, *, location: str, tags=None, **kwargs) -> None:
super(TrackedResource, self).__init__(**kwargs)
self.tags = tags
self.location = location
class WorkerProfile(Model):
"""WorkerProfile represents a worker profile.

50
python/client/azure/mgmt/redhatopenshift/v2019_12_31_preview/models/_paged_models.py Normal file
Просмотреть файл

@ -0,0 +1,50 @@
# coding=utf-8
# --------------------------------------------------------------------------
# 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.
# --------------------------------------------------------------------------
from msrest.paging import Paged
class OperationPaged(Paged):
"""
A paging container for iterating over a list of :class:`Operation <azure.mgmt.redhatopenshift.v2019_12_31_preview.models.Operation>` object
"""
_attribute_map = {
'next_link': {'key': 'nextLink', 'type': 'str'},
'current_page': {'key': 'value', 'type': '[Operation]'}
}
def __init__(self, *args, **kwargs):
super(OperationPaged, self).__init__(*args, **kwargs)
class OpenShiftClusterPaged(Paged):
"""
A paging container for iterating over a list of :class:`OpenShiftCluster <azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftCluster>` object
"""
_attribute_map = {
'next_link': {'key': 'nextLink', 'type': 'str'},
'current_page': {'key': 'value', 'type': '[OpenShiftCluster]'}
}
def __init__(self, *args, **kwargs):
super(OpenShiftClusterPaged, self).__init__(*args, **kwargs)

158
python/client/azure/mgmt/redhatopenshift/v2019_12_31_preview/operations/_open_shift_clusters_operations.py
Просмотреть файл

@ -63,49 +63,59 @@ class OpenShiftClustersOperations(object):
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: OpenShiftClusterList or ClientRawResponse if raw=true
:return: An iterator like instance of OpenShiftCluster
:rtype:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftClusterList
or ~msrest.pipeline.ClientRawResponse
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftClusterPaged[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftCluster]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = self.list.metadata['url']
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str', min_length=1)
}
url = self._client.format_url(url, **path_format_arguments)
def prepare_request(next_link=None):
if not next_link:
# Construct URL
url = self.list.metadata['url']
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str', min_length=1)
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str', min_length=1)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str', min_length=1)
# Construct headers
header_parameters = {}
header_parameters['Accept'] = 'application/json'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
else:
url = next_link
query_parameters = {}
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
response = self._client.send(request, stream=False, **operation_config)
# Construct headers
header_parameters = {}
header_parameters['Accept'] = 'application/json'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
return request
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('OpenShiftClusterList', response)
def internal_paging(next_link=None):
request = prepare_request(next_link)
response = self._client.send(request, stream=False, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
header_dict = None
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
header_dict = {}
deserialized = models.OpenShiftClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)
return deserialized
list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.RedHatOpenShift/openShiftClusters'}
@ -126,50 +136,60 @@ class OpenShiftClustersOperations(object):
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: OpenShiftClusterList or ClientRawResponse if raw=true
:return: An iterator like instance of OpenShiftCluster
:rtype:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftClusterList
or ~msrest.pipeline.ClientRawResponse
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftClusterPaged[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftCluster]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = self.list_by_resource_group.metadata['url']
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$')
}
url = self._client.format_url(url, **path_format_arguments)
def prepare_request(next_link=None):
if not next_link:
# Construct URL
url = self.list_by_resource_group.metadata['url']
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str', min_length=1)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str', min_length=1)
# Construct headers
header_parameters = {}
header_parameters['Accept'] = 'application/json'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
else:
url = next_link
query_parameters = {}
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
response = self._client.send(request, stream=False, **operation_config)
# Construct headers
header_parameters = {}
header_parameters['Accept'] = 'application/json'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
return request
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('OpenShiftClusterList', response)
def internal_paging(next_link=None):
request = prepare_request(next_link)
response = self._client.send(request, stream=False, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
header_dict = None
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
header_dict = {}
deserialized = models.OpenShiftClusterPaged(internal_paging, self._deserialize.dependencies, header_dict)
return deserialized
list_by_resource_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RedHatOpenShift/openShiftClusters'}
@ -463,7 +483,7 @@ class OpenShiftClustersOperations(object):
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(parameters, 'OpenShiftCluster')
body_content = self._serialize.body(parameters, 'OpenShiftClusterUpdate')
# Construct and send request
request = self._client.patch(url, query_parameters, header_parameters, body_content)
@ -503,7 +523,7 @@ class OpenShiftClustersOperations(object):
:type resource_name: str
:param parameters: The OpenShift cluster resource.
:type parameters:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftCluster
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OpenShiftClusterUpdate
:param dict custom_headers: headers that will be added to the request
:param bool raw: The poller return type is ClientRawResponse, the
direct response alongside the deserialized response

70
python/client/azure/mgmt/redhatopenshift/v2019_12_31_preview/operations/_operations.py
Просмотреть файл

@ -53,7 +53,7 @@ class Operations(object):
self, custom_headers=None, raw=False, **operation_config):
"""Lists all of the available RP operations.
Lists all of the available RP operations. The operation returns the
Lists all of the available RP operations. The operation returns the RP
operations.
:param dict custom_headers: headers that will be added to the request
@ -61,45 +61,55 @@ class Operations(object):
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: OperationList or ClientRawResponse if raw=true
:return: An iterator like instance of Operation
:rtype:
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OperationList
or ~msrest.pipeline.ClientRawResponse
~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.OperationPaged[~azure.mgmt.redhatopenshift.v2019_12_31_preview.models.Operation]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = self.list.metadata['url']
def prepare_request(next_link=None):
if not next_link:
# Construct URL
url = self.list.metadata['url']
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str', min_length=1)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str', min_length=1)
# Construct headers
header_parameters = {}
header_parameters['Accept'] = 'application/json'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
else:
url = next_link
query_parameters = {}
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
response = self._client.send(request, stream=False, **operation_config)
# Construct headers
header_parameters = {}
header_parameters['Accept'] = 'application/json'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
# Construct and send request
request = self._client.get(url, query_parameters, header_parameters)
return request
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('OperationList', response)
def internal_paging(next_link=None):
request = prepare_request(next_link)
response = self._client.send(request, stream=False, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
header_dict = None
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
header_dict = {}
deserialized = models.OperationPaged(internal_paging, self._deserialize.dependencies, header_dict)
return deserialized
list.metadata = {'url': '/providers/Microsoft.RedHatOpenShift/operations'}

1
swagger/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/preview/2019-12-31-preview/examples/OpenShiftClusters_Update.json
Просмотреть файл

@ -5,7 +5,6 @@
"resourceGroupName": "resourceGroup",
"resourceName": "resourceName",
"parameters": {
"location": "location",
"tags": {
"key": "value"
},

120
swagger/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/preview/2019-12-31-preview/redhatopenshift.json
Просмотреть файл

@ -22,7 +22,7 @@
"Operations"
],
"summary": "Lists all of the available RP operations.",
"description": "Lists all of the available RP operations. The operation returns the operations.",
"description": "Lists all of the available RP operations. The operation returns the RP operations.",
"operationId": "Operations_List",
"parameters": [
{
@ -47,6 +47,9 @@
"Lists all of the available RP operations.": {
"$ref": "./examples/Operations_List.json"
}
},
"x-ms-pageable": {
"nextLinkName": "nextLink"
}
}
},
@ -84,6 +87,9 @@
"Lists OpenShift clusters in the specified subscription.": {
"$ref": "./examples/OpenShiftClusters_List.json"
}
},
"x-ms-pageable": {
"nextLinkName": "nextLink"
}
}
},
@ -124,6 +130,9 @@
"Lists OpenShift clusters in the specified subscription and resource group.": {
"$ref": "./examples/OpenShiftClusters_ListByResourceGroup.json"
}
},
"x-ms-pageable": {
"nextLinkName": "nextLink"
}
}
},
@ -310,7 +319,7 @@
"description": "The OpenShift cluster resource.",
"required": true,
"schema": {
"$ref": "#/definitions/OpenShiftCluster"
"$ref": "#/definitions/OpenShiftClusterUpdate"
}
}
],
@ -442,6 +451,7 @@
}
},
"ClusterProfile": {
"description": "ClusterProfile represents a cluster profile.",
"properties": {
"domain": {
"description": "The domain for the cluster (immutable).",
@ -458,6 +468,7 @@
}
},
"ConsoleProfile": {
"description": "ConsoleProfile represents a console profile.",
"properties": {
"url": {
"description": "The URL to access the cluster console (immutable).",
@ -533,32 +544,12 @@
"description": "OpenShiftCluster represents an Azure Red Hat OpenShift cluster.",
"allOf": [
{
"$ref": "../../../../../common-types/resource-management/v1/types.json#/definitions/Resource"
"$ref": "../../../../../common-types/resource-management/v1/types.json#/definitions/TrackedResource"
}
],
"properties": {
"tags": {
"description": "Resource tags.",
"type": "object",
"additionalProperties": {
"type": "string"
},
"x-ms-mutability": [
"read",
"create",
"update"
]
},
"location": {
"description": "The geo-location where the resource lives",
"type": "string",
"x-ms-mutability": [
"read",
"create"
]
},
"properties": {
"$ref": "#/definitions/Properties",
"$ref": "#/definitions/OpenShiftClusterProperties",
"description": "The cluster properties.",
"x-ms-client-flatten": true
}
@ -586,36 +577,15 @@
"items": {
"$ref": "#/definitions/OpenShiftCluster"
}
}
}
},
"Operation": {
"description": "Operation represents an operation.",
"properties": {
"name": {
"description": "Operation name: {provider}/{resource}/{operation}.",
"type": "string"
},
"display": {
"$ref": "#/definitions/Display",
"description": "The object that describes the operation."
"nextLink": {
"description": "The link used to get the next page of operations.",
"type": "string"
}
}
},
"OperationList": {
"description": "OperationList represents an operation list.",
"properties": {
"value": {
"description": "List of operations supported by the resource provider.",
"type": "array",
"items": {
"$ref": "#/definitions/Operation"
}
}
}
},
"Properties": {
"description": "Properties represents an OpenShift cluster's properties.",
"OpenShiftClusterProperties": {
"description": "OpenShiftClusterProperties represents an OpenShift cluster's properties.",
"properties": {
"provisioningState": {
"$ref": "#/definitions/ProvisioningState",
@ -661,6 +631,49 @@
}
}
},
"OpenShiftClusterUpdate": {
"description": "OpenShiftCluster represents an Azure Red Hat OpenShift cluster.",
"properties": {
"tags": {
"$ref": "#/definitions/Tags",
"description": "The resource tags."
},
"properties": {
"$ref": "#/definitions/OpenShiftClusterProperties",
"description": "The cluster properties.",
"x-ms-client-flatten": true
}
}
},
"Operation": {
"description": "Operation represents an RP operation.",
"properties": {
"name": {
"description": "Operation name: {provider}/{resource}/{operation}.",
"type": "string"
},
"display": {
"$ref": "#/definitions/Display",
"description": "The object that describes the operation."
}
}
},
"OperationList": {
"description": "OperationList represents an RP operation list.",
"properties": {
"value": {
"description": "List of operations supported by the resource provider.",
"type": "array",
"items": {
"$ref": "#/definitions/Operation"
}
},
"nextLink": {
"description": "The link used to get the next page of operations.",
"type": "string"
}
}
},
"ProvisioningState": {
"description": "ProvisioningState represents a provisioning state.",
"enum": [
@ -686,6 +699,13 @@
}
}
},
"Tags": {
"description": "Tags represents an OpenShift cluster's tags.",
"type": "object",
"additionalProperties": {
"type": "string"
}
},
"VMSize": {
"description": "VMSize represents a VM size.",
"enum": [