~abp998/gwacl/subscription

// Copyright 2013 Canonical Ltd.  This software is licensed under the

// GNU Lesser General Public License version 3 (see the file COPYING).

package gwacl

import (

    "fmt"

    "sort"

    "strings"

)

type ListInstancesRequest struct {

    ServiceName string

}

// ListInstances returns a slice of all instances for all deployments for the

// given hosted service name.

func (api *ManagementAPI) ListInstances(request *ListInstancesRequest) ([]RoleInstance, error) {

    instances := []RoleInstance{}

    properties, err := api.GetHostedServiceProperties(request.ServiceName, true)

    if err != nil {

        return nil, err

    }

    for _, deployment := range properties.Deployments {

        instances = append(instances, deployment.RoleInstanceList...)

    }

    return instances, nil

}

// ListAllDeploymentsRequest is a parameter object for ListAllDeployments.

type ListAllDeploymentsRequest struct {

    // ServiceName restricts the listing to the given service.

    ServiceName string

}

// ListAllDeployments returns a slice containing all deployments that match

// the request.

func (api *ManagementAPI) ListAllDeployments(request *ListAllDeploymentsRequest) ([]Deployment, error) {

    properties, err := api.GetHostedServiceProperties(request.ServiceName, true)

    if err != nil {

        return nil, err

    }

    return properties.Deployments, nil

}

// ListDeploymentsRequest is a parameter object for ListDeployments.

type ListDeploymentsRequest struct {

    // ServiceName restricts the listing to the given service.

    ServiceName string

    // DeploymentNames is a set (its value type is ignored) that restricts the

    // listing to those deployments which it contains.

    DeploymentNames []string

}

// ListDeployments returns a slice containing specific deployments, insofar

// as they match the request.

func (api *ManagementAPI) ListDeployments(request *ListDeploymentsRequest) ([]Deployment, error) {

    properties, err := api.GetHostedServiceProperties(request.ServiceName, true)

    if err != nil {

        return nil, err

    }

    // Filter the deployment list according to the given names.

    filter := make(map[string]bool)

    for _, name := range request.DeploymentNames {

        filter[name] = true

    }

    deployments := []Deployment{}

    for _, deployment := range properties.Deployments {

        if _, ok := filter[deployment.Name]; ok {

            deployments = append(deployments, deployment)

        }

    }

    return deployments, nil

}

type ListSpecificHostedServicesRequest struct {

    ServiceNames []string

}

// ListSpecificHostedServices returns a slice containing specific

// HostedServiceDescriptor objects, insofar as they match the request.

func (api *ManagementAPI) ListSpecificHostedServices(request *ListSpecificHostedServicesRequest) ([]HostedServiceDescriptor, error) {

    allServices, err := api.ListHostedServices()

    if err != nil {

        return nil, err

    }

    // Filter the service list according to the given names.

    filter := make(map[string]bool)

    for _, name := range request.ServiceNames {

        filter[name] = true

    }

    services := []HostedServiceDescriptor{}

    for _, service := range allServices {

        if _, ok := filter[service.ServiceName]; ok {

            services = append(services, service)

        }

    }

    return services, nil

}

type ListPrefixedHostedServicesRequest struct {

    ServiceNamePrefix string

}

// ListPrefixedHostedServices returns a slice containing specific

// HostedServiceDescriptor objects, insofar as they match the request.

func (api *ManagementAPI) ListPrefixedHostedServices(request *ListPrefixedHostedServicesRequest) ([]HostedServiceDescriptor, error) {

    services, err := api.ListHostedServices()

    if err != nil {

        return nil, err

    }

    resServices := []HostedServiceDescriptor{}

    for _, service := range services {

        if strings.HasPrefix(service.ServiceName, request.ServiceNamePrefix) {

            resServices = append(resServices, service)

        }

    }

    services = resServices

    return services, nil

}

type DestroyDeploymentRequest struct {

    ServiceName    string

    DeploymentName string

}

// DestroyDeployment brings down all resources within a deployment - running

// instances, disks, etc. - and deletes the deployment itself.

func (api *ManagementAPI) DestroyDeployment(request *DestroyDeploymentRequest) error {

    deployment, err := api.GetDeployment(&GetDeploymentRequest{

        ServiceName:    request.ServiceName,

        DeploymentName: request.DeploymentName,

    })

    if err != nil {

        if IsNotFoundError(err) {

            return nil

        }

        return err

    }

    // 1. Get the list of the VM disks.

    diskNameMap := make(map[string]bool)

    for _, role := range deployment.RoleList {

        for _, osVHD := range role.OSVirtualHardDisk {

            diskNameMap[osVHD.DiskName] = true

        }

    }

    // 2. Delete deployment.  This will delete all the role instances inside

    // this deployment as a side effect.

    err = api.DeleteDeployment(request.ServiceName, request.DeploymentName)

    if err != nil && !IsNotFoundError(err) {

        return err

    }

    // Sort the disk names to aid testing.

    diskNames := []string{}

    for diskName := range diskNameMap {

        diskNames = append(diskNames, diskName)

    }

    sort.Strings(diskNames)

    // 3. Delete the disks.

    for _, diskName := range diskNames {

        err = api.DeleteDisk(&DeleteDiskRequest{

            DiskName:   diskName,

            DeleteBlob: true})

        if err != nil && !IsNotFoundError(err) {

            return err

        }

    }

    // Done.

    return nil

}

type DestroyHostedServiceRequest struct {

    ServiceName string

}

// DestroyHostedService destroys all of the hosted service's contained

// deployments then deletes the hosted service itself.

func (api *ManagementAPI) DestroyHostedService(request *DestroyHostedServiceRequest) error {

    // 1. Get properties.

    properties, err := api.GetHostedServiceProperties(request.ServiceName, true)

    if err != nil {

        if IsNotFoundError(err) {

            return nil

        }

        return err

    }

    // 2. Delete deployments.

    for _, deployment := range properties.Deployments {

        err := api.DestroyDeployment(&DestroyDeploymentRequest{

            ServiceName:    request.ServiceName,

            DeploymentName: deployment.Name,

        })

        if err != nil {

            return err

        }

    }

    // 3. Delete service.

    err = api.DeleteHostedService(request.ServiceName)

    if err != nil && !IsNotFoundError(err) {

        return err

    }

    // Done.

    return nil

}

func (api *ManagementAPI) AddVirtualNetworkSite(site *VirtualNetworkSite) error {

    // Obtain the current network config, which we will then modify.

    networkConfig, err := api.GetNetworkConfiguration()

    if err != nil {

        return err

    }

    if networkConfig == nil {

        // There's no config yet.

        networkConfig = &NetworkConfiguration{XMLNS: XMLNS_NC}

    }

    if networkConfig.VirtualNetworkSites == nil {

        networkConfig.VirtualNetworkSites = &[]VirtualNetworkSite{}

    }

    // Check to see if this network already exists.

    for _, existingSite := range *networkConfig.VirtualNetworkSites {

        if existingSite.Name == site.Name {

            // Network already defined.

            return fmt.Errorf("could not add virtual network: %q already exists", site.Name)

        }

    }

    // Add the network to the configuration.

    virtualNetworkSites := append(*networkConfig.VirtualNetworkSites, *site)

    networkConfig.VirtualNetworkSites = &virtualNetworkSites

    // Put it back up to Azure. There's a race here...

    return api.SetNetworkConfiguration(networkConfig)

}

func (api *ManagementAPI) RemoveVirtualNetworkSite(siteName string) error {

    // Obtain the current network config, which we will then modify.

    networkConfig, err := api.GetNetworkConfiguration()

    if err != nil {

        return err

    }

    if networkConfig == nil || networkConfig.VirtualNetworkSites == nil {

        // There's no config, nothing to do.

        return nil

    }

    // Remove all references to the specified virtual network site name.

    virtualNetworkSites := []VirtualNetworkSite{}

    for _, existingSite := range *networkConfig.VirtualNetworkSites {

        if existingSite.Name != siteName {

            virtualNetworkSites = append(virtualNetworkSites, existingSite)

        }

    }

    if len(virtualNetworkSites) < len(*networkConfig.VirtualNetworkSites) {

        // Put it back up to Azure. There's a race here...

        networkConfig.VirtualNetworkSites = &virtualNetworkSites

        return api.SetNetworkConfiguration(networkConfig)

    }

    return nil

}

type ListRoleEndpointsRequest struct {

    ServiceName    string

    DeploymentName string

    RoleName       string

}

// ListRoleEndpoints lists the open endpoints for the named service/deployment/role name.

func (api *ManagementAPI) ListRoleEndpoints(request *ListRoleEndpointsRequest) ([]InputEndpoint, error) {

    var err error

    vmRole, err := api.GetRole(&GetRoleRequest{

        ServiceName:    request.ServiceName,

        DeploymentName: request.DeploymentName,

        RoleName:       request.RoleName})

    if err != nil {

        return nil, err

    }

    for i, configSet := range vmRole.ConfigurationSets {

        if configSet.ConfigurationSetType == CONFIG_SET_NETWORK {

            endpointsP := vmRole.ConfigurationSets[i].InputEndpoints

            if endpointsP != nil {

                return *endpointsP, nil

            }

        }

    }

    return []InputEndpoint{}, nil

}

type AddRoleEndpointsRequest struct {

    ServiceName    string

    DeploymentName string

    RoleName       string

    InputEndpoints []InputEndpoint

}

// AddRoleEndpoints appends the supplied endpoints to the existing endpoints

// for the named service/deployment/role name.  Note that the Azure API

// leaves this open to a race condition between fetching and updating the role.

func (api *ManagementAPI) AddRoleEndpoints(request *AddRoleEndpointsRequest) error {

    var err error

    vmRole, err := api.GetRole(&GetRoleRequest{

        ServiceName:    request.ServiceName,

        DeploymentName: request.DeploymentName,

        RoleName:       request.RoleName})

    if err != nil {

        return err

    }

    for i, configSet := range vmRole.ConfigurationSets {

        // TODO: Is NetworkConfiguration always present?

        if configSet.ConfigurationSetType == CONFIG_SET_NETWORK {

            endpointsP := vmRole.ConfigurationSets[i].InputEndpoints

            if endpointsP == nil {

                // No endpoints set at all, initialise it to be empty.

                vmRole.ConfigurationSets[i].InputEndpoints = &[]InputEndpoint{}

            }

            // Append to existing endpoints.

            // TODO: Check clashing endpoint. LocalPort/Name/Port unique?

            endpoints := append(

                *vmRole.ConfigurationSets[i].InputEndpoints,

                request.InputEndpoints...)

            vmRole.ConfigurationSets[i].InputEndpoints = &endpoints

            break // Only one NetworkConfiguration so exit loop now.

        }

    }

    // Enjoy this race condition.

    err = api.UpdateRole(&UpdateRoleRequest{

        ServiceName:      request.ServiceName,

        DeploymentName:   request.DeploymentName,

        RoleName:         request.RoleName,

        PersistentVMRole: vmRole})

    if err != nil {

        return err

    }

    return nil

}

// CompareInputEndpoints attempts to compare two InputEndpoint objects in a

// way that's congruent with how Windows's Azure considers them. The name is

// always ignored, as is LoadBalancerProbe. When LoadBalancedEndpointSetName

// is set (not the empty string), all the fields - LocalPort, Port, Protocol,

// VIP and LoadBalancedEndpointSetName - are used for the comparison. When

// LoadBalancedEndpointSetName is the empty string, all except LocalPort -

// effectively Port, Protocol and VIP - are used for comparison.

func CompareInputEndpoints(a, b *InputEndpoint) bool {

    if a.LoadBalancedEndpointSetName == "" {

        return a.Port == b.Port && a.Protocol == b.Protocol && a.VIP == b.VIP

    } else {

        return (a.LoadBalancedEndpointSetName == b.LoadBalancedEndpointSetName &&

            a.LocalPort == b.LocalPort && a.Port == b.Port &&

            a.Protocol == b.Protocol && a.VIP == b.VIP)

    }

}

type RemoveRoleEndpointsRequest struct {

    ServiceName    string

    DeploymentName string

    RoleName       string

    InputEndpoints []InputEndpoint

}

// RemoveRoleEndpoints attempts to remove the given endpoints from the

// specified role. It uses `CompareInputEndpoints` to determine when there's a

// match between the given endpoint and one already configured.

func (api *ManagementAPI) RemoveRoleEndpoints(request *RemoveRoleEndpointsRequest) error {

    filterRequest := filterRoleEndpointsRequest{

        ServiceName:    request.ServiceName,

        DeploymentName: request.DeploymentName,

        RoleName:       request.RoleName,

        Filter: func(a *InputEndpoint) bool {

            for _, b := range request.InputEndpoints {

                if CompareInputEndpoints(a, &b) {

                    return false

                }

            }

            return true

        },

    }

    return api.filterRoleEndpoints(&filterRequest)

}

// Returns true to keep the endpoint defined in the role's configuration,

// false to remove it. It is also welcome to mutate endpoints; they are passed

// by reference.

type inputEndpointFilter func(*InputEndpoint) bool

type filterRoleEndpointsRequest struct {

    ServiceName    string

    DeploymentName string

    RoleName       string

    Filter         inputEndpointFilter

}

// filterRoleEndpoints is a general role endpoint filtering function. It is

// private because it is only a support function for RemoveRoleEndpoints, and

// is not tested directly.

func (api *ManagementAPI) filterRoleEndpoints(request *filterRoleEndpointsRequest) error {

    role, err := api.GetRole(&GetRoleRequest{

        ServiceName:    request.ServiceName,

        DeploymentName: request.DeploymentName,

        RoleName:       request.RoleName,

    })

    if err != nil {

        return err

    }

    for index, configSet := range role.ConfigurationSets {

        if configSet.ConfigurationSetType == CONFIG_SET_NETWORK {

            if configSet.InputEndpoints != nil {

                endpoints := []InputEndpoint{}

                for _, existingEndpoint := range *configSet.InputEndpoints {

                    if request.Filter(&existingEndpoint) {

                        endpoints = append(endpoints, existingEndpoint)

                    }

                }

                if len(endpoints) == 0 {

                    configSet.InputEndpoints = nil

                } else {

                    configSet.InputEndpoints = &endpoints

                }

            }

        }

        // Update the role; implicit copying is a nuisance.

        role.ConfigurationSets[index] = configSet

    }

    return api.UpdateRole(&UpdateRoleRequest{

        ServiceName:      request.ServiceName,

        DeploymentName:   request.DeploymentName,

        RoleName:         request.RoleName,

        PersistentVMRole: role,

    })

}