~wallyworld/gwacl/fix-request-eof

// Copyright 2013 Canonical Ltd.  This software is licensed under the
// GNU Lesser General Public License version 3 (see the file COPYING).

package gwacl

import (
    "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(diskName)
        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
}