Merge lp:~allenap/gwacl/destroy-everything into lp:gwacl

[Gavin Panella]

Script to destroy most things belonging to a subscription.

I wrote this because I had loads of artifacts in my Azure account that would take me a day to remove, which is more time than it has taken to implement this script and run it.

Along the way I had to implement ListDisks() and ListStorageAccounts(). It also uncovered an error in the XML that's generated in TestStorageServicesUnmarshal(), which is an argument for using the example XML basically as-is from the Azure docs. This actually seems to be what we're doing these days, but it's interesting to note anyway.

[Jeroen T. Vermeulen (jtv)]

This looks helpful — although please say very clearly at the top of the destroyer program what it does! Otherwise people might expect it to prompt for the thing they want to delete, or something.

The literal XML in tests leads to funny situations, like "true|false" as a Boolean field, but it works for me.

One thing I'm not a fan of is the happy-path-only tests with names like TestFunction. When you push yourself there's usually a corner case you can find that could gainfully be tested. It's a useful habit not just for improving test coverage, but for honing testability skills as well — it trains you to recognize unnecessarily complex code, code that's hard to test exhaustively, unnecessary special cases, and forgotten corner cases.

[Jeroen T. Vermeulen (jtv)]

review: Approve

Unmerged revisions

211. By Gavin Panella on 2013-07-29

Remove virtual networks too.

210. By Gavin Panella on 2013-07-29

Example script to destroy (almost) everything.

209. By Gavin Panella on 2013-07-29

Whitespace.

208. By Gavin Panella on 2013-07-29

New method ListDisks().

207. By Gavin Panella on 2013-07-29

New struct for Disks.

206. By Gavin Panella on 2013-07-29

New method, ListStorageAccounts.

205. By Gavin Panella on 2013-07-29

Invalid StorageServices template for test.

=== added directory 'example/destroyer'
=== added file 'example/destroyer/run.go'
--- example/destroyer/run.go	1970-01-01 00:00:00 +0000
+++ example/destroyer/run.go	2013-07-29 15:50:39 +0000
@@ -0,0 +1,113 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+/*
+This is an example on how the Azure Go library can be used to interact with
+the Windows Azure Service.
+Note that this is a provided only as an example and that real code should
+probably do something more sensible with errors than ignoring them or panicking.
+*/
+package main
+
+import (
+    "flag"
+    "fmt"
+    "launchpad.net/gwacl"
+    "os"
+)
+
+var certFile string
+var subscriptionID string
+
+func getParams() error {
+    flag.StringVar(&certFile, "cert", "", "Name of your management certificate file (in PEM format).")
+    flag.StringVar(&subscriptionID, "subscriptionid", "", "Your Azure subscription ID.")
+    flag.Parse()
+    if certFile == "" {
+        return fmt.Errorf("No .pem certificate specified.  Use the -cert option.")
+    }
+    if subscriptionID == "" {
+        return fmt.Errorf("No subscription ID specified.  Use the -subscriptionid option.")
+    }
+    return nil
+}
+
+func checkError(err error) {
+    if err != nil {
+        panic(err)
+    }
+}
+
+func main() {
+    err := getParams()
+    if err != nil {
+        fmt.Println(err)
+        os.Exit(1)
+    }
+
+    api, err := gwacl.NewManagementAPI(subscriptionID, certFile)
+    checkError(err)
+
+    DestroyEverything(api)
+}
+
+func DestroyEverything(api *gwacl.ManagementAPI) {
+    hostedServices, err := api.ListHostedServices()
+    checkError(err)
+
+    for _, hostedService := range hostedServices {
+        err := api.DestroyHostedService(
+            &gwacl.DestroyHostedServiceRequest{hostedService.ServiceName})
+        checkError(err)
+    }
+
+    disks, err := api.ListDisks()
+    checkError(err)
+
+    // Delete all disks and their storage.
+    for _, disk := range disks {
+        err := api.DeleteDisk(&gwacl.DeleteDiskRequest{
+            DiskName:   disk.Name,
+            DeleteBlob: true,
+        })
+        checkError(err)
+    }
+
+    storageAccounts, err := api.ListStorageAccounts()
+    checkError(err)
+
+    for _, storageAccount := range storageAccounts {
+        storageKeys, err := api.GetStorageAccountKeys(storageAccount.ServiceName)
+        checkError(err)
+
+        storageContext := &gwacl.StorageContext{
+            Account: storageAccount.ServiceName,
+            Key:     storageKeys.Primary,
+        }
+
+        storageContainers, err := storageContext.ListAllContainers()
+        checkError(err)
+
+        // Delete all blobs in all containers, and the containers themselves.
+        for _, storageContainer := range storageContainers.Containers {
+            err := storageContext.DeleteAllBlobs(
+                &gwacl.DeleteAllBlobsRequest{storageContainer.Name})
+            checkError(err)
+            err = storageContext.DeleteContainer(storageContainer.Name)
+            checkError(err)
+        }
+
+        // Delete the storage account.
+        err = api.DeleteStorageAccount(storageAccount.ServiceName)
+        checkError(err)
+    }
+
+    // Remove virtual networks.
+    networkConfig, err := api.GetNetworkConfiguration()
+    checkError(err)
+    if networkConfig != nil && networkConfig.VirtualNetworkSites != nil {
+        networkConfig.VirtualNetworkSites = &[]gwacl.VirtualNetworkSite{}
+        err := api.SetNetworkConfiguration(networkConfig)
+        checkError(err)
+    }
+}

=== modified file 'management_base.go'
--- management_base.go	2013-07-25 22:02:41 +0000
+++ management_base.go	2013-07-29 15:50:39 +0000
@@ -274,6 +274,23 @@
     return &deployment, nil
 }
 
+// ListStorageAccount lists all storage accounts. This is called a storage
+// service in the Azure API, but nomenclature seems to have changed.
+// See http://msdn.microsoft.com/en-us/library/windowsazure/ee460787.aspx
+func (api *ManagementAPI) ListStorageAccounts() ([]StorageService, error) {
+    uri := "services/storageservices"
+    response, err := api.session.get(uri, "2012-03-01")
+    if err != nil {
+        return nil, err
+    }
+    services := &StorageServices{}
+    err = services.Deserialize(response.Body)
+    if err != nil {
+        return nil, err
+    }
+    return services.StorageServices, nil
+}
+
 // AddStorageAccount starts the creation of a storage account.  This is
 // called a storage service in the Azure API, but nomenclature seems to
 // have changed.
@@ -324,6 +341,20 @@
     return &keys, nil
 }
 
+// ListDisk lists all disks.
+func (api *ManagementAPI) ListDisks() ([]Disk, error) {
+    res, err := api.session.get("services/disks", "2012-03-01")
+    if err != nil {
+        return nil, err
+    }
+    disks := &Disks{}
+    err = disks.Deserialize(res.Body)
+    if err != nil {
+        return nil, err
+    }
+    return disks.Disks, nil
+}
+
 type DeleteDiskRequest struct {
     DiskName   string // Name of the disk to delete.
     DeleteBlob bool   // Whether to delete the associated blob storage.

=== modified file 'management_base_test.go'
--- management_base_test.go	2013-07-25 22:02:41 +0000
+++ management_base_test.go	2013-07-29 15:50:39 +0000
@@ -802,6 +802,80 @@
     c.Check(deployment.Name, Equals, deploymentName)
 }
 
+func (suite *managementBaseAPISuite) TestListStorageAccounts(c *C) {
+    body := dedent.Dedent(`
+        <?xml version="1.0" encoding="utf-8"?>
+        <StorageServices xmlns="http://schemas.microsoft.com/windowsazure">
+          <StorageService>
+            <Url>storage-service-address</Url>
+            <ServiceName>storage-service-name</ServiceName>
+            <StorageServiceProperties>
+              <Description>description</Description>
+              <AffinityGroup>affinity-group</AffinityGroup>
+              <Label>base64-encoded-label</Label>
+              <Status>status</Status>
+              <Endpoints>
+                <Endpoint>storage-service-blob-endpoint</Endpoint>
+                <Endpoint>storage-service-queue-endpoint</Endpoint>
+                <Endpoint>storage-service-table-endpoint</Endpoint>
+              </Endpoints>
+              <GeoReplicationEnabled>true|false</GeoReplicationEnabled>
+              <GeoPrimaryRegion>primary-region</GeoPrimaryRegion>
+              <StatusOfPrimary>Available|Unavailable</StatusOfPrimary>
+              <LastGeoFailoverTime>DateTime</LastGeoFailoverTime>
+              <GeoSecondaryRegion>secondary-region</GeoSecondaryRegion>
+              <StatusOfSecondary>Available|Unavailable</StatusOfSecondary>
+              <CreationTime>time-of-creation</CreationTime>
+            </StorageServiceProperties>
+            <ExtendedProperties>
+              <ExtendedProperty>
+                <Name>property-name</Name>
+                <Value>property-value</Value>
+              </ExtendedProperty>
+            </ExtendedProperties>
+          </StorageService>
+        </StorageServices>
+        `)
+    rigFixedResponseDispatcher(&x509Response{
+        StatusCode: http.StatusOK,
+        Body:       []byte(body),
+    })
+    api := makeAPI(c)
+    recordedRequests := make([]*X509Request, 0)
+    rigRecordingDispatcher(&recordedRequests)
+
+    accounts, err := api.ListStorageAccounts()
+
+    c.Assert(err, IsNil)
+    c.Assert(recordedRequests, HasLen, 1)
+    expectedURL := api.session.composeURL("services/storageservices")
+    c.Assert(recordedRequests[0].URL, Equals, expectedURL)
+    c.Check(accounts, HasLen, 1)
+    c.Check(accounts[0], DeepEquals, StorageService{
+        URL:           "storage-service-address",
+        ServiceName:   "storage-service-name",
+        Description:   "description",
+        AffinityGroup: "affinity-group",
+        Label:         "base64-encoded-label",
+        Status:        "status",
+        Endpoints: []string{
+            "storage-service-blob-endpoint",
+            "storage-service-queue-endpoint",
+            "storage-service-table-endpoint",
+        },
+        GeoReplicationEnabled: "true|false",
+        GeoPrimaryRegion:      "primary-region",
+        StatusOfPrimary:       "Available|Unavailable",
+        LastGeoFailoverTime:   "DateTime",
+        GeoSecondaryRegion:    "secondary-region",
+        StatusOfSecondary:     "Available|Unavailable",
+        CreationTime:          "time-of-creation",
+        ExtendedProperties: []ExtendedProperty{
+            {"property-name", "property-value"},
+        },
+    })
+}
+
 func (suite *managementBaseAPISuite) TestAddStorageAccount(c *C) {
     api := makeAPI(c)
     header := http.Header{}
@@ -872,6 +946,36 @@
     c.Check(keys.URL, Equals, url)
 }
 
+func (suite *managementBaseAPISuite) TestListDisks(c *C) {
+    // This is a minimal response body; Disks XML docs are tested elsewhere.
+    responseBody := `
+        <Disks xmlns="http://schemas.microsoft.com/windowsazure">
+          <Disk>
+            <Name>disk-name-1</Name>
+          </Disk>
+          <Disk>
+            <Name>disk-name-2</Name>
+          </Disk>
+        </Disks>`
+    rigFixedResponseDispatcher(&x509Response{
+        StatusCode: http.StatusOK,
+        Body:       []byte(responseBody),
+    })
+    recordedRequests := make([]*X509Request, 0)
+    rigRecordingDispatcher(&recordedRequests)
+
+    disks, err := makeAPI(c).ListDisks()
+
+    c.Assert(err, IsNil)
+    c.Assert(recordedRequests, HasLen, 1)
+    c.Check(recordedRequests[0].Method, Equals, "GET")
+    c.Check(recordedRequests[0].URL, Equals, AZURE_URL+"subscriptionId/services/disks")
+    c.Check(disks, HasLen, 2)
+    c.Check(disks, DeepEquals, []Disk{
+        {Name: "disk-name-1"}, {Name: "disk-name-2"},
+    })
+}
+
 func assertDeleteDiskRequest(c *C, api *ManagementAPI, diskName string, httpRequest *X509Request) {
     expectedURL := fmt.Sprintf("%s%s/services/disks/%s", AZURE_URL,
         api.session.subscriptionId, diskName)

=== modified file 'xmlobjects.go'
--- xmlobjects.go	2013-07-25 22:02:41 +0000
+++ xmlobjects.go	2013-07-29 15:50:39 +0000
@@ -251,6 +251,40 @@
 }
 
 //
+// Disk, as returned by List Disks
+//
+
+type AttachedTo struct {
+    HostedServiceName string `xml:"HostedServiceName"`
+    DeploymentName    string `xml:"DeploymentName"`
+    RoleName          string `xml:"RoleName"`
+}
+
+type Disk struct {
+    AffinityGroup   string      `xml:"AffinityGroup,omitempty"`
+    AttachedTo      *AttachedTo `xml:"AttachedTo,omitempty"`
+    OS              string      `xml:"OS,omitempty"`
+    Location        string      `xml:"Location,omitempty`
+    LogicalSizeInGB string      `xml:"LogicalSizeInGB,omitempty"`
+    MediaLink       string      `xml:"MediaLink,omitempty"`
+    Name            string      `xml:"Name"`
+    SourceImageName string      `xml:"SourceImageName,omitempty"`
+}
+
+type Disks struct {
+    XMLNS string `xml:"xmlns,attr"`
+    Disks []Disk `xml:"Disk"`
+}
+
+func (disks *Disks) Serialize() (string, error) {
+    return toxml(disks)
+}
+
+func (disks *Disks) Deserialize(data []byte) error {
+    return xml.Unmarshal(data, disks)
+}
+
+//
 // DataVirtualHardDisk
 //
 
@@ -764,7 +798,8 @@
     LastGeoFailoverTime   string             `xml:"StorageServiceProperties>LastGeoFailoverTime"`
     GeoSecondaryRegion    string             `xml:"StorageServiceProperties>GeoSecondaryRegion"`
     StatusOfSecondary     string             `xml:"StorageServiceProperties>StatusOfSecondary"`
-    ExtendedProperties    []ExtendedProperty `xml:"StorageServiceProperties>ExtendedProperties>ExtendedProperty"`
+    CreationTime          string             `xml:"StorageServiceProperties>CreationTime"`
+    ExtendedProperties    []ExtendedProperty `xml:"ExtendedProperties>ExtendedProperty"`
 
     // TODO: Add accessors for non-string data encoded as strings.
 }

=== modified file 'xmlobjects_test.go'
--- xmlobjects_test.go	2013-07-25 22:02:41 +0000
+++ xmlobjects_test.go	2013-07-29 15:50:39 +0000
@@ -67,6 +67,94 @@
     c.Check(strings.TrimSpace(xml), Equals, strings.TrimSpace(expected))
 }
 
+func (suite *xmlSuite) TestDisksSerialize(c *C) {
+    disks := &Disks{
+        XMLNS: XMLNS,
+        Disks: []Disk{
+            {
+                AffinityGroup: "affinity-group",
+                AttachedTo: &AttachedTo{
+                    HostedServiceName: "hosted-service-name",
+                    DeploymentName:    "deployment-name",
+                    RoleName:          "role-name",
+                },
+                OS:              "os",
+                Location:        "location",
+                LogicalSizeInGB: "logical-size-in-gb",
+                MediaLink:       "media-link",
+                Name:            "name",
+                SourceImageName: "source-image-name",
+            },
+        },
+    }
+    observed, err := disks.Serialize()
+    c.Assert(err, IsNil)
+    expected := strings.TrimSpace(dedent.Dedent(`
+        <Disks xmlns="http://schemas.microsoft.com/windowsazure">
+          <Disk>
+            <AffinityGroup>affinity-group</AffinityGroup>
+            <AttachedTo>
+              <HostedServiceName>hosted-service-name</HostedServiceName>
+              <DeploymentName>deployment-name</DeploymentName>
+              <RoleName>role-name</RoleName>
+            </AttachedTo>
+            <OS>os</OS>
+            <Location>location</Location>
+            <LogicalSizeInGB>logical-size-in-gb</LogicalSizeInGB>
+            <MediaLink>media-link</MediaLink>
+            <Name>name</Name>
+            <SourceImageName>source-image-name</SourceImageName>
+          </Disk>
+        </Disks>`))
+    c.Check(observed, Equals, expected)
+
+}
+
+func (suite *xmlSuite) TestDisksDeserialize(c *C) {
+    // From http://msdn.microsoft.com/en-us/library/windowsazure/jj157176.aspx
+    input := `
+        <Disks xmlns="http://schemas.microsoft.com/windowsazure">
+          <Disk>
+            <AffinityGroup>affinity-group-name</AffinityGroup>
+            <AttachedTo>
+              <HostedServiceName>hostedService-name</HostedServiceName>
+              <DeploymentName>deployment-name</DeploymentName>
+              <RoleName>role-name</RoleName>
+            </AttachedTo>
+            <OS>Linux|Windows</OS>
+            <Location>geo-location-of-the-stored-disk</Location>
+            <LogicalSizeInGB>size-of-the-disk</LogicalSizeInGB>
+            <MediaLink>uri-of-the-containing-blob</MediaLink>
+            <Name>disk-name</Name>
+            <SourceImageName>source-image-name</SourceImageName>
+          </Disk>
+          ...
+        </Disks>`
+    expected := &Disks{
+        XMLNS: XMLNS,
+        Disks: []Disk{
+            {
+                AffinityGroup: "affinity-group-name",
+                AttachedTo: &AttachedTo{
+                    HostedServiceName: "hostedService-name",
+                    DeploymentName:    "deployment-name",
+                    RoleName:          "role-name",
+                },
+                OS:              "Linux|Windows",
+                Location:        "geo-location-of-the-stored-disk",
+                LogicalSizeInGB: "size-of-the-disk",
+                MediaLink:       "uri-of-the-containing-blob",
+                Name:            "disk-name",
+                SourceImageName: "source-image-name",
+            },
+        },
+    }
+    observed := &Disks{}
+    err := observed.Deserialize([]byte(input))
+    c.Assert(err, IsNil)
+    c.Check(observed, DeepEquals, expected)
+}
+
 func (suite *xmlSuite) TestOSVirtualHardDisk(c *C) {
     disk := makeOSVirtualHardDisk()
 
@@ -1113,17 +1201,17 @@
               <LastGeoFailoverTime>%s</LastGeoFailoverTime>
               <GeoSecondaryRegion>%s</GeoSecondaryRegion>
               <StatusOfSecondary>%s</StatusOfSecondary>
-              <ExtendedProperties>
-                <ExtendedProperty>
-                  <Name>%s</Name>
-                  <Value>%s</Value>
-                </ExtendedProperty>
-                <ExtendedProperty>
-                  <Name>%s</Name>
-                  <Value>%s</Value>
-                </ExtendedProperty>
-              </ExtendedProperties>
             </StorageServiceProperties>
+            <ExtendedProperties>
+              <ExtendedProperty>
+                <Name>%s</Name>
+                <Value>%s</Value>
+              </ExtendedProperty>
+              <ExtendedProperty>
+                <Name>%s</Name>
+                <Value>%s</Value>
+              </ExtendedProperty>
+            </ExtendedProperties>
           </StorageService>
         </StorageServices>`
     url := MakeRandomString(10)