Merge lp:~rvb/gwacl/add-network-config into lp:gwacl

[Raphaël Badin]

Add support for configuring the network when creating a VM.

This branch's main goal is to allow the user to configure the network using a ConfigurationSet object. It can be used when creating the VM and (hopefully) later on when reconfiguring the VM to open/close ports.

The main trick is that the object we used to call LinuxProvisioningConfiguration is in fact a "generic" ConfigurationSet object which can contain different types of configuration. This is rather bad design on Azure's part but it's easier for us to reflect exactly the structure of Azure's objects in our class hierarchy. This is why I renamed LinuxProvisioningConfiguration into ConfigurationSet and added a utility method to create the other type of ConfigurationSet object: the network configuration object (i.e. a ConfigurationSet object with a type of "NetworkConfiguration").

I changed the DisableSSHPasswordAuthentication boolean into a string because the 'omitempty' parameter would remove the field altogether from the serialized XML when it's false. And we *have to* use 'omitempty' because, when the ConfigurationSet object will be of type NetworkConfiguration, we need that field to be omitted.

I had to tweak the XML used in tests in xmlobjects_test.go because the examples (I /think/, not my doing) where taken straight out of the documentation and are not actually valid (for instance the value for the ports where not integers).

Drive-by fixes:
    - display the host/username/password info in example/management/run.go
    - add the GeoReplicated stuff as a parameter

[Jeroen T. Vermeulen (jtv)]

Is it really worth adding GeoReplicationEnabled as a parameter to NewCreateStorageServiceInputWithLocation? Go puts you on this slippery slope from "I want optional and named parameters for my function" to "I'll use a Parameter Object" to "I need a constructor for my Parameter Object" to "I want another parameter added to the constructor" to "my constructor needs a Parameter Object."

So unless we need to set the GeoReplicationEnabled all the time, or there is something fundamentally dangerous that requires an explicit choice, I'd just make NewCreateStorageServiceInputWithLocation initialize GeoReplicationEnabled to either "false" or "true," whichever makes more sense. Or if you do make it a parameter, then IMO at least the constructor should take a boolean so that the caller can ignore the weirdness in the field's type!

[Raphaël Badin (rvb)]

> Is it really worth adding GeoReplicationEnabled as a parameter to
> NewCreateStorageServiceInputWithLocation? Go puts you on this slippery slope
> from "I want optional and named parameters for my function" to "I'll use a
> Parameter Object" to "I need a constructor for my Parameter Object" to "I want
> another parameter added to the constructor" to "my constructor needs a
> Parameter Object."
>
> So unless we need to set the GeoReplicationEnabled all the time, or there is
> something fundamentally dangerous that requires an explicit choice, I'd just
> make NewCreateStorageServiceInputWithLocation initialize GeoReplicationEnabled
> to either "false" or "true," whichever makes more sense. Or if you do make it
> a parameter, then IMO at least the constructor should take a boolean so that
> the caller can ignore the weirdness in the field's type!

You've right, I forgot to say *why* I thought it was important: the geo replication has a very high cost (dixit Scott) and thus I thought that it would be better to force the user to explicitly set it.

[Jeroen T. Vermeulen (jtv)]

Also, why only retrieve deployment information in the optional "pause" bit? Isn't this something you might as well do anyway, as part of the test?

Arguably it's not useful if you're not pausing, but then again the same goes for creating the virtual machine in the first place. :) If shutdown fails, for example, you might still want to have a closer look at the instance, perhaps using the information you got from GetDeployment.

Finally, would it be worth adding a few words of how-and-why-this-works documentation to ConfigurationSet?

review: Approve

[lp:~rvb/gwacl/add-network-config]

152. By Raphaël Badin on 2013-07-02

Review fixes.

153. By Raphaël Badin on 2013-07-02

Remove test data.

[Raphaël Badin (rvb)]

> Also, why only retrieve deployment information in the optional "pause" bit?
> Isn't this something you might as well do anyway, as part of the test?
>
> Arguably it's not useful if you're not pausing, but then again the same goes
> for creating the virtual machine in the first place. :) If shutdown fails,
> for example, you might still want to have a closer look at the instance,
> perhaps using the information you got from GetDeployment.

Very true, fixed.

> Finally, would it be worth adding a few words of how-and-why-this-works
> documentation to ConfigurationSet?

Done.

Thanks for the review!

[Julian Edwards (julian-edwards)]

On 02/07/13 20:44, Raphaël Badin wrote:
> I changed the DisableSSHPasswordAuthentication boolean into a string because the 'omitempty' parameter would remove the field altogether from the serialized XML when it's false. And we *have to* use 'omitempty' because, when the ConfigurationSet object will be of type NetworkConfiguration, we need that field to be omitted.

FWIW, this really is shouting that LinuxProvisioningConfiguration is not
the same as a generic ConfigurationSet at all ... which is why I did it
that way to start with.

=== modified file 'example/management/run.go'
--- example/management/run.go	2013-07-02 00:33:52 +0000
+++ example/management/run.go	2013-07-02 13:56:26 +0000
@@ -139,14 +139,16 @@
     // test with your instance, so we'll use a fixed one.  It's not really a
     // security hazard in such a short-lived private instance.
     password := "Ubuntu123"
+    username := "ubuntu"
     vhdName := makeRandomIdentifier("gwacldisk", 16)
-    configurationSet := gwacl.NewLinuxProvisioningConfiguration(hostname, "ubuntu", password, "TEST_USER_DATA", false)
+    linuxConfigurationSet := gwacl.NewLinuxProvisioningConfiguration(hostname, username, password, "TEST_USER_DATA", "false")
+    inputendpoint := gwacl.InputEndpoint{LocalPort: 22, Name: "sshport", Port: 22, Protocol: "TCP"}
+    networkConfigurationSet := gwacl.NewNetworkConfiguration([]gwacl.InputEndpoint{inputendpoint})
 
     storageAccount := makeRandomIdentifier("gwacl", 24)
     storageLabel := makeRandomIdentifier("gwacl", 64)
     fmt.Printf("Requesting storage account with name '%s' and label '%s'...\n", storageAccount, storageLabel)
-    cssi := gwacl.NewCreateStorageServiceInputWithLocation(storageAccount, storageLabel, location)
-    cssi.GeoReplicationEnabled = "false"
+    cssi := gwacl.NewCreateStorageServiceInputWithLocation(storageAccount, storageLabel, location, "false")
     err = api.AddStorageAccount(cssi)
     checkError(err)
     fmt.Println("Done requesting storage account\n")
@@ -162,7 +164,7 @@
     diskLabel := makeRandomIdentifier("gwacl", 64)
     vhd := gwacl.NewOSVirtualHardDisk("", diskLabel, diskName, mediaLink, sourceImageName, "Linux")
     roleName := makeRandomIdentifier("gwaclrole", 16)
-    role := gwacl.NewRole("ExtraSmall", roleName, []gwacl.LinuxProvisioningConfiguration{*configurationSet}, []gwacl.OSVirtualHardDisk{*vhd})
+    role := gwacl.NewRole("ExtraSmall", roleName, []gwacl.ConfigurationSet{*linuxConfigurationSet, *networkConfigurationSet}, []gwacl.OSVirtualHardDisk{*vhd})
     machineName := makeRandomIdentifier("gwaclmachine", 20)
     deployment := gwacl.NewDeploymentForCreateVMDeployment(machineName, "Staging", machineName, []gwacl.Role{*role}, "")
     err = api.AddDeployment(deployment, hostServiceName)
@@ -201,6 +203,19 @@
     fmt.Printf("Got %d instance(s)\n", len(instances))
     fmt.Println("Done listing VM\n")
 
+    fmt.Println("Getting deployment info...")
+    request := &gwacl.GetDeploymentRequest{ServiceName: hostServiceName, DeploymentName: machineName}
+    deploy, err := api.GetDeployment(request)
+    checkError(err)
+    fqdn, err := deploy.GetFQDN()
+    checkError(err)
+    fmt.Println("Got deployment info\n")
+
+    fmt.Println("host:", fqdn)
+    fmt.Println("username:", username)
+    fmt.Println("password:", password)
+    fmt.Println("")
+
     if pause {
         var wait string
         fmt.Println("Pausing so you can play with the newly-created VM")

=== modified file 'helpers_apiobjects_test.go'
--- helpers_apiobjects_test.go	2013-06-28 00:14:46 +0000
+++ helpers_apiobjects_test.go	2013-07-02 13:56:26 +0000
@@ -42,20 +42,13 @@
         Protocol:                    params.protocol}
 }
 
-func makeLinuxProvisioningConfiguration() *LinuxProvisioningConfiguration {
+func makeLinuxProvisioningConfiguration() *ConfigurationSet {
     hostname := MakeRandomString(10)
     username := MakeRandomString(10)
     password := MakeRandomString(10)
     userdata := MakeRandomString(10)
-    disableSSH := MakeRandomBool()
-
-    return &LinuxProvisioningConfiguration{
-        ConfigurationSetType: "LinuxProvisioningConfiguration",
-        Hostname:             hostname,
-        Username:             username,
-        Password:             password,
-        UserData:             userdata,
-        DisableSSHPasswordAuthentication: disableSSH}
+    disableSSH := BoolToString(MakeRandomBool())
+    return NewLinuxProvisioningConfiguration(hostname, username, password, userdata, disableSSH)
 }
 
 func makeOSVirtualHardDisk() *OSVirtualHardDisk {
@@ -78,7 +71,7 @@
     RoleName := MakeRandomString(10)
     RoleType := "PersistentVMRole"
     config := makeLinuxProvisioningConfiguration()
-    configset := []LinuxProvisioningConfiguration{*config}
+    configset := []ConfigurationSet{*config}
 
     return &Role{
         RoleSize:          RoleSize,

=== modified file 'management_base_test.go'
--- management_base_test.go	2013-07-01 01:14:04 +0000
+++ management_base_test.go	2013-07-02 13:56:26 +0000
@@ -495,9 +495,9 @@
     api := makeAPI(c)
     recordedRequests := setUpDispatcher("operationID")
     serviceName := "serviceName"
-    configurationSet := NewLinuxProvisioningConfiguration("testHostname12345", "test", "test123#@!", "user-data", false)
+    configurationSet := NewLinuxProvisioningConfiguration("testHostname12345", "test", "test123#@!", "user-data", "false")
     vhd := NewOSVirtualHardDisk("hostCaching", "diskLabel", "diskName", "http://mediaLink", "sourceImageName", "os")
-    role := NewRole("ExtraSmall", "test-role-123", []LinuxProvisioningConfiguration{*configurationSet}, []OSVirtualHardDisk{*vhd})
+    role := NewRole("ExtraSmall", "test-role-123", []ConfigurationSet{*configurationSet}, []OSVirtualHardDisk{*vhd})
     deployment := NewDeploymentForCreateVMDeployment("test-machine-name", "Staging", "testLabel", []Role{*role}, "testNetwork")
     err := api.AddDeployment(deployment, serviceName)
 
@@ -629,7 +629,7 @@
     rigFixedResponseDispatcher(&fixedResponse)
     recordedRequests := make([]*X509Request, 0)
     rigRecordingDispatcher(&recordedRequests)
-    cssi := NewCreateStorageServiceInputWithLocation("name", "label", "East US")
+    cssi := NewCreateStorageServiceInputWithLocation("name", "label", "East US", "false")
 
     err := api.AddStorageAccount(cssi)
     c.Assert(err, IsNil)

=== modified file 'xmlobjects.go'
--- xmlobjects.go	2013-07-02 06:08:22 +0000
+++ xmlobjects.go	2013-07-02 13:56:26 +0000
@@ -36,31 +36,48 @@
 }
 
 //
-// LinuxProvisioningConfiguration bits
+// ConfigurationSet bits
 //
 
-// TODO: this should contain InputEndpoints objects.
-type LinuxProvisioningConfiguration struct {
-    ConfigurationSetType             string `xml:"ConfigurationSetType"` // "LinuxProvisioningConfiguration"
-    Hostname                         string `xml:"HostName"`
-    Username                         string `xml:"UserName"`
-    Password                         string `xml:"UserPassword"`
-    UserData                         string `xml:"UserData"`
-    DisableSSHPasswordAuthentication bool   `xml:"DisableSshPasswordAuthentication"`
-}
-
-func (c *LinuxProvisioningConfiguration) Serialize() (string, error) {
+// A ConfigurationSet object can be different things depending on its 'type'.
+// The types we currently support are:
+// - LinuxProvisioningConfigurationSet: configuration of a Linux VM
+// - NetworkConfiguration: configuration of the network of a VM
+type ConfigurationSet struct {
+    ConfigurationSetType string `xml:"ConfigurationSetType"` // "ConfigurationSet"
+
+    // LinuxProvisioningConfiguration fields.
+    Hostname                         string `xml:"HostName,omitempty"`
+    Username                         string `xml:"UserName,omitempty"`
+    Password                         string `xml:"UserPassword,omitempty"`
+    UserData                         string `xml:"UserData,omitempty"`
+    DisableSSHPasswordAuthentication string `xml:"DisableSshPasswordAuthentication,omitempty"`
+
+    // NetworkConfiguration fields.
+    // We use a pointer in the 'InputEndpoints' field to work around bug:
+    // https://code.google.com/p/go/issues/detail?id=4168
+    // We need the whole 'InputEndpoints' element to be omitted when no InputEndpoint objects are
+    // present (this happens when the ConfigurationSet object has a
+    // LinuxProvisioningConfiguration type for instance).
+    InputEndpoints *[]InputEndpoint `xml:"InputEndpoints>InputEndpoint,omitempty"`
+}
+
+func (c *ConfigurationSet) inputEndpoints() []InputEndpoint {
+    return *c.InputEndpoints
+}
+
+func (c *ConfigurationSet) Serialize() (string, error) {
     return toxml(c)
 }
 
-// NewLinuxProvisioningConfiguration creates and returns a
-// LinuxProvisioningConfiguration which is used when deploying a Linux VM
-// instance. Note that UserData is passed to Azure *as-is* which also stores
-// it as passed, so consider base64 encoding it.
+// NewLinuxProvisioningConfiguration creates and returns a ConfigurationSet of type
+// "LinuxProvisioningConfiguration" which is used when deploying a Linux VM instance.
+// Note that UserData is passed to Azure *as-is* which also stores it as passed, so consider
+// base64 encoding it.
 func NewLinuxProvisioningConfiguration(
     Hostname, Username, Password, UserData string,
-    DisableSSHPasswordAuthentication bool) *LinuxProvisioningConfiguration {
-    return &LinuxProvisioningConfiguration{
+    DisableSSHPasswordAuthentication string) *ConfigurationSet {
+    return &ConfigurationSet{
         ConfigurationSetType: "LinuxProvisioningConfiguration",
         Hostname:             Hostname,
         Username:             Username,
@@ -70,12 +87,21 @@
     }
 }
 
+// NewNetworkConfiguration creates a ConfigurationSet of type "NetworkConfiguration".
+func NewNetworkConfiguration(
+    inputEndpoints []InputEndpoint) *ConfigurationSet {
+    return &ConfigurationSet{
+        ConfigurationSetType: "NetworkConfiguration",
+        InputEndpoints:       &inputEndpoints,
+    }
+}
+
 //
 // InputEndpoint bits
 //
 
 type InputEndpoint struct {
-    LoadBalancedEndpointSetName string `xml:"LoadBalancedEndpointSetName"`
+    LoadBalancedEndpointSetName string `xml:"LoadBalancedEndpointSetName,omitempty"`
     LocalPort                   int    `xml:"LocalPort"`
     Name                        string `xml:"Name"`
     Port                        int    `xml:"Port"`
@@ -245,24 +271,12 @@
     }
 }
 
-//
-// NetworkConfiguration bits
-//
-
-type NetworkConfiguration struct {
-    InputEndpoints []InputEndpoint `xml:"InputEndpoints>InputEndpoint"`
-}
-
-func (c *NetworkConfiguration) Serialize() (string, error) {
-    return toxml(c)
-}
-
 type Role struct {
-    RoleName          string                           `xml:"RoleName"`
-    RoleType          string                           `xml:"RoleType"` // Always "PersistentVMRole"
-    ConfigurationSets []LinuxProvisioningConfiguration `xml:"ConfigurationSets>ConfigurationSet"`
-    OSVirtualHardDisk []OSVirtualHardDisk              `xml:"OSVirtualHardDisk"`
-    RoleSize          string                           `xml:"RoleSize"`
+    RoleName          string              `xml:"RoleName"`
+    RoleType          string              `xml:"RoleType"` // Always "PersistentVMRole"
+    ConfigurationSets []ConfigurationSet  `xml:"ConfigurationSets>ConfigurationSet"`
+    OSVirtualHardDisk []OSVirtualHardDisk `xml:"OSVirtualHardDisk"`
+    RoleSize          string              `xml:"RoleSize"`
 }
 
 //
@@ -274,7 +288,7 @@
 }
 
 func NewRole(RoleSize string, RoleName string,
-    ConfigurationSets []LinuxProvisioningConfiguration, vhds []OSVirtualHardDisk) *Role {
+    ConfigurationSets []ConfigurationSet, vhds []OSVirtualHardDisk) *Role {
     return &Role{
         RoleSize:          RoleSize,
         RoleName:          RoleName,
@@ -560,12 +574,13 @@
 
 // NewCreateStorageServiceInputWithLocation creates a location-based
 // CreateStorageServiceInput, with all required fields filled out.
-func NewCreateStorageServiceInputWithLocation(name, label, location string) *CreateStorageServiceInput {
+func NewCreateStorageServiceInputWithLocation(name, label, location string, geoReplicationEnabled string) *CreateStorageServiceInput {
     return &CreateStorageServiceInput{
-        XMLNS:       XMLNS,
-        ServiceName: name,
-        Label:       base64.StdEncoding.EncodeToString([]byte(label)),
-        Location:    location,
+        XMLNS:                 XMLNS,
+        ServiceName:           name,
+        Label:                 base64.StdEncoding.EncodeToString([]byte(label)),
+        Location:              location,
+        GeoReplicationEnabled: geoReplicationEnabled,
     }
 }
 

=== modified file 'xmlobjects_test.go'
--- xmlobjects_test.go	2013-07-02 06:08:22 +0000
+++ xmlobjects_test.go	2013-07-02 13:56:26 +0000
@@ -20,20 +20,20 @@
 // Tests for Marshallers
 //
 
-func (suite *xmlSuite) TestLinuxProvisioningConfiguration(c *C) {
+func (suite *xmlSuite) TestConfigurationSet(c *C) {
     config := makeLinuxProvisioningConfiguration()
 
     xml, err := config.Serialize()
     c.Assert(err, IsNil)
     template := dedent.Dedent(`
-        <LinuxProvisioningConfiguration>
+        <ConfigurationSet>
           <ConfigurationSetType>LinuxProvisioningConfiguration</ConfigurationSetType>
           <HostName>%s</HostName>
           <UserName>%s</UserName>
           <UserPassword>%s</UserPassword>
           <UserData>%s</UserData>
           <DisableSshPasswordAuthentication>%v</DisableSshPasswordAuthentication>
-        </LinuxProvisioningConfiguration>`)
+        </ConfigurationSet>`)
     expected := fmt.Sprintf(template, config.Hostname, config.Username,
         config.Password, config.UserData,
         config.DisableSSHPasswordAuthentication)
@@ -76,16 +76,16 @@
     c.Check(xml, Equals, expected)
 }
 
-func (suite *xmlSuite) TestNetworkConfiguration(c *C) {
+func (suite *xmlSuite) TestConfigurationSetNetworkConfiguration(c *C) {
     endpoint1 := makeEndpoint(endpointParams{})
     endpoint2 := makeEndpoint(endpointParams{})
     endpoints := []InputEndpoint{*endpoint1, *endpoint2}
-    config := &NetworkConfiguration{
-        InputEndpoints: endpoints}
+    config := NewNetworkConfiguration(endpoints)
     xml, err := config.Serialize()
     c.Assert(err, IsNil)
     template := dedent.Dedent(`
-        <NetworkConfiguration>
+        <ConfigurationSet>
+          <ConfigurationSetType>NetworkConfiguration</ConfigurationSetType>
           <InputEndpoints>
             <InputEndpoint>
               <LoadBalancedEndpointSetName>%s</LoadBalancedEndpointSetName>
@@ -102,7 +102,7 @@
               <Protocol>%s</Protocol>
             </InputEndpoint>
           </InputEndpoints>
-        </NetworkConfiguration>`)
+        </ConfigurationSet>`)
     expected := fmt.Sprintf(template, endpoint1.LoadBalancedEndpointSetName,
         endpoint1.LocalPort, endpoint1.Name, endpoint1.Port,
         endpoint1.Protocol, endpoint2.LoadBalancedEndpointSetName,
@@ -351,14 +351,8 @@
       <OsVersion>operating-system-version</OsVersion>
       <ConfigurationSets>
 	<ConfigurationSet>
-	  <ConfigurationSetType>NetworkConfiguration</ConfigurationSetType>
-	  <InputEndpoints>
-	    <InputEndpoint>
-	      <Port>port-number-of-input-endpoint-in-network</Port>
-	      <Protocol>protocol-of-input-endpoint-in-network</Protocol>
-	      <Vip>virtual-ip-address-of-input-endpoint-in-network</Vip>
-	    </InputEndpoint>
-	  </InputEndpoints>
+	  <ConfigurationSetType>LinuxProvisioningConfiguration</ConfigurationSetType>
+          <DisableSshPasswordAuthentication>false</DisableSshPasswordAuthentication>
 	</ConfigurationSet>
       </ConfigurationSets>
     </Role>
@@ -369,21 +363,14 @@
       <ConfigurationSets>
 	<ConfigurationSet>
 	  <ConfigurationSetType>NetworkConfiguration</ConfigurationSetType>
-	  <InputEndpoints>
-	    <InputEndpoint>
-	      <LoadBalancedEndpointSetName>name-of-load-balanced-endpoint-set</LoadBalancedEndpointSetName>
-	      <LocalPort>internal-facing-port-of-input-endpoint</LocalPort>
-	      <Name>name-of-input-endpoint</Name>
-	      <Port>external-facing-port-of-input-endpoint</Port>
-	      <LoadBalancerProbe>
-		<Path>path-of-probe</Path>
-		<Port>port-assigned-to-probe</Port>
-		<Protocol>protocol-of-probe-port</Protocol>
-	      </LoadBalancerProbe>
-	      <Protocol>protocol-of-input-endpoint</Protocol>
-	      <Vip>virtual-ip-address-of-input-endpoint</Vip>
-	    </InputEndpoint>
-	  </InputEndpoints>
+            <InputEndpoints>
+	      <InputEndpoint>
+	        <Port>2222</Port>
+	        <LocalPort>111</LocalPort>
+  	        <Protocol>TCP</Protocol>
+  	        <Name>test-name</Name>
+  	      </InputEndpoint>
+	    </InputEndpoints>
 	  <SubnetNames>
 	    <SubnetName>name-of-subnet</SubnetName>
 	  </SubnetNames>
@@ -498,20 +485,27 @@
         RoleList: []Role{
             {
                 RoleName: "name-of-role",
-                ConfigurationSets: []LinuxProvisioningConfiguration{
+                ConfigurationSets: []ConfigurationSet{
                     {
-                        ConfigurationSetType:             "NetworkConfiguration",
-                        DisableSSHPasswordAuthentication: false,
+                        ConfigurationSetType:             "LinuxProvisioningConfiguration",
+                        DisableSSHPasswordAuthentication: "false",
                     },
                 },
             },
             {
                 RoleName: "name-of-role",
                 RoleType: "PersistentVMRole",
-                ConfigurationSets: []LinuxProvisioningConfiguration{
+                ConfigurationSets: []ConfigurationSet{
                     {
-                        ConfigurationSetType:             "NetworkConfiguration",
-                        DisableSSHPasswordAuthentication: false,
+                        ConfigurationSetType: "NetworkConfiguration",
+                        InputEndpoints: &[]InputEndpoint{
+                            {
+                                Name:      "test-name",
+                                Port:      2222,
+                                LocalPort: 111,
+                                Protocol:  "TCP",
+                            },
+                        },
                     },
                 },
                 OSVirtualHardDisk: []OSVirtualHardDisk{
@@ -597,7 +591,7 @@
     deploymentSlot := "staging"
     label := "deploymentLabel"
     vhd := NewOSVirtualHardDisk("hostCaching", "diskLabel", "diskName", "mediaLink", "sourceImageName", "os")
-    roles := []Role{*NewRole("size", "name", []LinuxProvisioningConfiguration{}, []OSVirtualHardDisk{*vhd})}
+    roles := []Role{*NewRole("size", "name", []ConfigurationSet{}, []OSVirtualHardDisk{*vhd})}
     virtualNetworkName := "network"
 
     deployment := NewDeploymentForCreateVMDeployment(name, deploymentSlot, label, roles, virtualNetworkName)
@@ -853,7 +847,7 @@
     rolesize := MakeRandomString(10)
     rolename := MakeRandomString(10)
     config := makeLinuxProvisioningConfiguration()
-    configset := []LinuxProvisioningConfiguration{*config}
+    configset := []ConfigurationSet{*config}
     vhd := NewOSVirtualHardDisk("hostCaching", "diskLabel", "diskName", "mediaLink", "sourceImageName", "os")
 
     role := NewRole(rolesize, rolename, configset, []OSVirtualHardDisk{*vhd})
@@ -867,8 +861,8 @@
     hostname := MakeRandomString(10)
     username := MakeRandomString(10)
     password := MakeRandomString(10)
+    disablessh := BoolToString(MakeRandomBool())
     userdata := MakeRandomString(10)
-    disablessh := MakeRandomBool()
 
     config := NewLinuxProvisioningConfiguration(
         hostname, username, password, userdata, disablessh)
@@ -880,6 +874,27 @@
     c.Check(config.ConfigurationSetType, Equals, "LinuxProvisioningConfiguration")
 }
 
+func (suite *xmlSuite) TestNewNetworkConfiguration(c *C) {
+    name := "name1"
+    port := 242
+    localPort := 922
+    protocol := "TCP"
+    bName := "bname1"
+    inputendpoint := InputEndpoint{
+        LoadBalancedEndpointSetName: bName, LocalPort: localPort, Name: name, Port: port, Protocol: protocol}
+
+    config := NewNetworkConfiguration([]InputEndpoint{inputendpoint})
+    inputEndpoints := *config.InputEndpoints
+    c.Check(len(inputEndpoints), Equals, 1)
+    inputEndpoint := inputEndpoints[0]
+    c.Check(inputEndpoint.Name, Equals, name)
+    c.Check(inputEndpoint.Port, Equals, port)
+    c.Check(inputEndpoint.Protocol, Equals, protocol)
+    c.Check(inputEndpoint.LoadBalancedEndpointSetName, Equals, bName)
+    c.Check(inputEndpoint.LocalPort, Equals, localPort)
+    c.Check(config.ConfigurationSetType, Equals, "NetworkConfiguration")
+}
+
 func (suite *xmlSuite) TestNewOSVirtualHardDisk(c *C) {
     var hostcaching HostCachingType = "ReadWrite"
     disklabel := MakeRandomString(10)
@@ -1110,11 +1125,12 @@
 }
 
 func (suite *xmlSuite) TestNewCreateStorageServiceInputWithLocation(c *C) {
-    cssi := NewCreateStorageServiceInputWithLocation("name", "label", "location")
+    cssi := NewCreateStorageServiceInputWithLocation("name", "label", "location", "false")
     c.Check(cssi.XMLNS, Equals, XMLNS)
     c.Check(cssi.ServiceName, Equals, "name")
     c.Check(cssi.Label, Equals, base64.StdEncoding.EncodeToString([]byte("label")))
     c.Check(cssi.Location, Equals, "location")
+    c.Check(cssi.GeoReplicationEnabled, Equals, "false")
 }
 
 func (suite *xmlSuite) TestBlockListSerialize(c *C) {