jkawamoto/roadie

package virtual_machine_scale_sets

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
    "github.com/go-openapi/runtime"

    strfmt "github.com/go-openapi/strfmt"
)

// New creates a new virtual machine scale sets API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client {
    return &Client{transport: transport, formats: formats}
}

/*
Client for virtual machine scale sets API
*/
type Client struct {
    transport runtime.ClientTransport
    formats   strfmt.Registry
}

/*
VirtualMachineScaleSetsCreateOrUpdate Create or update a VM scale set.
*/
func (a *Client) VirtualMachineScaleSetsCreateOrUpdate(params *VirtualMachineScaleSetsCreateOrUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsCreateOrUpdateOK, *VirtualMachineScaleSetsCreateOrUpdateCreated, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsCreateOrUpdateParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_CreateOrUpdate",
        Method:             "PUT",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{name}",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsCreateOrUpdateReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsCreateOrUpdateOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsCreateOrUpdateCreated:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsDeallocate Deallocates specific virtual machines in a VM scale set. Shuts down the virtual machines and releases the compute resources. You are not billed for the compute resources that this virtual machine scale set deallocates.
*/
func (a *Client) VirtualMachineScaleSetsDeallocate(params *VirtualMachineScaleSetsDeallocateParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsDeallocateOK, *VirtualMachineScaleSetsDeallocateAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsDeallocateParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_Deallocate",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/deallocate",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsDeallocateReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsDeallocateOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsDeallocateAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsDelete Deletes a VM scale set.
*/
func (a *Client) VirtualMachineScaleSetsDelete(params *VirtualMachineScaleSetsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsDeleteOK, *VirtualMachineScaleSetsDeleteAccepted, *VirtualMachineScaleSetsDeleteNoContent, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsDeleteParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_Delete",
        Method:             "DELETE",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsDeleteReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsDeleteOK:
        return value, nil, nil, nil
    case *VirtualMachineScaleSetsDeleteAccepted:
        return nil, value, nil, nil
    case *VirtualMachineScaleSetsDeleteNoContent:
        return nil, nil, value, nil
    }
    return nil, nil, nil, nil

}

/*
VirtualMachineScaleSetsDeleteInstances Deletes virtual machines in a VM scale set.
*/
func (a *Client) VirtualMachineScaleSetsDeleteInstances(params *VirtualMachineScaleSetsDeleteInstancesParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsDeleteInstancesOK, *VirtualMachineScaleSetsDeleteInstancesAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsDeleteInstancesParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_DeleteInstances",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/delete",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsDeleteInstancesReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsDeleteInstancesOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsDeleteInstancesAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsGet Display information about a virtual machine scale set.
*/
func (a *Client) VirtualMachineScaleSetsGet(params *VirtualMachineScaleSetsGetParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsGetOK, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsGetParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_Get",
        Method:             "GET",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsGetReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, err
    }
    return result.(*VirtualMachineScaleSetsGetOK), nil

}

/*
VirtualMachineScaleSetsGetInstanceView Gets the status of a VM scale set instance.
*/
func (a *Client) VirtualMachineScaleSetsGetInstanceView(params *VirtualMachineScaleSetsGetInstanceViewParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsGetInstanceViewOK, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsGetInstanceViewParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_GetInstanceView",
        Method:             "GET",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/instanceView",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsGetInstanceViewReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, err
    }
    return result.(*VirtualMachineScaleSetsGetInstanceViewOK), nil

}

/*
VirtualMachineScaleSetsList Gets a list of all VM scale sets under a resource group.
*/
func (a *Client) VirtualMachineScaleSetsList(params *VirtualMachineScaleSetsListParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsListOK, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsListParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_List",
        Method:             "GET",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsListReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, err
    }
    return result.(*VirtualMachineScaleSetsListOK), nil

}

/*
VirtualMachineScaleSetsListAll Gets a list of all VM Scale Sets in the subscription, regardless of the associated resource group. Use nextLink property in the response to get the next page of VM Scale Sets. Do this till nextLink is not null to fetch all the VM Scale Sets.
*/
func (a *Client) VirtualMachineScaleSetsListAll(params *VirtualMachineScaleSetsListAllParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsListAllOK, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsListAllParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_ListAll",
        Method:             "GET",
        PathPattern:        "/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachineScaleSets",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsListAllReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, err
    }
    return result.(*VirtualMachineScaleSetsListAllOK), nil

}

/*
VirtualMachineScaleSetsListSkus Gets a list of SKUs available for your VM scale set, including the minimum and maximum VM instances allowed for each SKU.
*/
func (a *Client) VirtualMachineScaleSetsListSkus(params *VirtualMachineScaleSetsListSkusParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsListSkusOK, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsListSkusParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_ListSkus",
        Method:             "GET",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/skus",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsListSkusReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, err
    }
    return result.(*VirtualMachineScaleSetsListSkusOK), nil

}

/*
VirtualMachineScaleSetsPowerOff Power off (stop) one or more virtual machines in a VM scale set. Note that resources are still attached and you are getting charged for the resources. Instead, use deallocate to release resources and avoid charges.
*/
func (a *Client) VirtualMachineScaleSetsPowerOff(params *VirtualMachineScaleSetsPowerOffParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsPowerOffOK, *VirtualMachineScaleSetsPowerOffAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsPowerOffParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_PowerOff",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/poweroff",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsPowerOffReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsPowerOffOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsPowerOffAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsReimage Reimages (upgrade the operating system) one or more virtual machines in a VM scale set.
*/
func (a *Client) VirtualMachineScaleSetsReimage(params *VirtualMachineScaleSetsReimageParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsReimageOK, *VirtualMachineScaleSetsReimageAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsReimageParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_Reimage",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimage",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsReimageReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsReimageOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsReimageAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsReimageAll Reimages all the disks ( including data disks ) in the virtual machines in a virtual machine scale set. This operation is only supported for managed disks.
*/
func (a *Client) VirtualMachineScaleSetsReimageAll(params *VirtualMachineScaleSetsReimageAllParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsReimageAllOK, *VirtualMachineScaleSetsReimageAllAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsReimageAllParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_ReimageAll",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimageall",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsReimageAllReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsReimageAllOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsReimageAllAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsRestart Restarts one or more virtual machines in a VM scale set.
*/
func (a *Client) VirtualMachineScaleSetsRestart(params *VirtualMachineScaleSetsRestartParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsRestartOK, *VirtualMachineScaleSetsRestartAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsRestartParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_Restart",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/restart",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsRestartReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsRestartOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsRestartAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsStart Starts one or more virtual machines in a VM scale set.
*/
func (a *Client) VirtualMachineScaleSetsStart(params *VirtualMachineScaleSetsStartParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsStartOK, *VirtualMachineScaleSetsStartAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsStartParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_Start",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/start",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsStartReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsStartOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsStartAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

/*
VirtualMachineScaleSetsUpdateInstances Upgrades one or more virtual machines to the latest SKU set in the VM scale set model.
*/
func (a *Client) VirtualMachineScaleSetsUpdateInstances(params *VirtualMachineScaleSetsUpdateInstancesParams, authInfo runtime.ClientAuthInfoWriter) (*VirtualMachineScaleSetsUpdateInstancesOK, *VirtualMachineScaleSetsUpdateInstancesAccepted, error) {
    // TODO: Validate the params before sending
    if params == nil {
        params = NewVirtualMachineScaleSetsUpdateInstancesParams()
    }

    result, err := a.transport.Submit(&runtime.ClientOperation{
        ID:                 "VirtualMachineScaleSets_UpdateInstances",
        Method:             "POST",
        PathPattern:        "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/manualupgrade",
        ProducesMediaTypes: []string{"application/json"},
        ConsumesMediaTypes: []string{"application/json"},
        Schemes:            []string{"https"},
        Params:             params,
        Reader:             &VirtualMachineScaleSetsUpdateInstancesReader{formats: a.formats},
        AuthInfo:           authInfo,
        Context:            params.Context,
        Client:             params.HTTPClient,
    })
    if err != nil {
        return nil, nil, err
    }
    switch value := result.(type) {
    case *VirtualMachineScaleSetsUpdateInstancesOK:
        return value, nil, nil
    case *VirtualMachineScaleSetsUpdateInstancesAccepted:
        return nil, value, nil
    }
    return nil, nil, nil

}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
    a.transport = transport
}