azure 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16b612bbee697e6b52ae74452eb8c74474582c95
-  data.tar.gz: c54be6fa7ef63f2867b680ad272ae5745e62b51b
+  metadata.gz: 2218a9a37d85a587e477daa5f91d8c06d0eb3f59
+  data.tar.gz: 39efa8b58227090e87058d9aa4765251d423f4ce
 SHA512:
-  metadata.gz: ac0c2777f58a96237eb85db41f6990932b352d1873aa8c7bd256b9422ed4ab760ce590618006f517b2d56baf4cb9376b6288929a9093f01a7ebe464d0edaa9d2
-  data.tar.gz: 7fe4e38feb67a395d7a7e986d3415cb434f13857298ccb27b09356485d46a447165bf6c006c00e5b600e41c2a96ada8877b07aea16c0d14fdc4a1832045f7ec2
+  metadata.gz: a47b93b9e6e87ea04bc0458569e16d3b75046f8a3ce178c4d0914078f94d4b78d4ffd3ac124c8870033f09cf2d6932fec147ed739d43f1fb71e8cb72620a32ca
+  data.tar.gz: f15f40f69a33d35902b0f585c1de2a405a7468b7c21befe2b0902d0d61da233923c8bb417b4d0212e8ddab87937a9607c32d13220e2316e9d492df2d2a314c40

data/ChangeLog.txt

@@ -1,5 +1,11 @@
+2014.03.15 - version 0.6.2
+* Restart Virtual Machine
+* Add disk to Virtual Machine
+* Add/Update Virtual Machine endpoints
+* Delete Virtual Machine endpoint
+
 2014.02.18 - version 0.6.1
-* Fixed http redirection error.
+* Fixed http redirection error
 * Add a new role to existing deployment
 * Add support for including VMs in availability sets
 

data/README.md

@@ -369,6 +369,38 @@ virtual_machine_service.shutdown_virtual_machine('vm_name', 'cloud_service_name'
 #API to start Virtual Machine
 virtual_machine_service.start_virtual_machine('vm_name', 'cloud_service_name')
 
+#API to restart Virtual Machine
+virtual_machine_service.restart_virtual_machine('vm_name', 'cloud_service_name')
+
+#API for add disk to Virtual Machine
+lun = 1  #Valid LUN values are 0 through 15.
+options = {
+  :disk_label => 'disk-label',
+  :disk_size => 100, #In GB
+  :import => false
+}
+virtual_machine_service.add_data_disk('vm_name', 'cloud_service_name', lun, options)
+
+#API to add/update Virtual Machine endpoints
+endpoint1 = {
+    :name => 'ep-1',
+    :public_port => 996,
+    :local_port => 998,
+    :protocol => 'TCP',
+  }
+endpoint2 = {
+    :name => 'ep-2',
+    :public_port => 997,
+    :local_port => 997,
+    :protocol => 'TCP',
+    :load_balancer_name => ‘lb-ep2’,
+    :load_balancer => {:protocol => 'http', :path => 'hello'}
+  }
+virtual_machine_service.update_endpoints('vm_name', 'cloud_service_name', endpoint1, endpoint2)
+
+#API to delete Virtual Machine endpoint
+virtual_machine_service.delete_endpoint('vm_name', 'cloud_service_name', 'endpoint_name')
+
 #API to delete Virtual Machine
 virtual_machine_service.delete_virtual_machine('vm_name', 'cloud_service_name')
 

data/lib/azure/version.rb

@@ -17,7 +17,7 @@ module Azure
   class Version
     MAJOR = 0 unless defined? MAJOR
     MINOR = 6 unless defined? MINOR
-    UPDATE = 1 unless defined? UPDATE
+    UPDATE = 2 unless defined? UPDATE
     PRE = nil unless defined? PRE
 
     class << self

data/lib/azure/virtual_machine_image_management/serialization.rb

@@ -39,7 +39,10 @@ module Azure
         disks.each do |disk_node|
           disk = VirtualMachineDisk.new
           disk.name = xml_content(disk_node, 'Name')
+          disk.os_type = xml_content(disk_node, 'OS')
           disk.attached = !xml_content(disk_node,'AttachedTo').empty?
+          disk.image = xml_content(disk_node, 'SourceImageName')
+          disk.size = xml_content(disk_node, 'LogicalDiskSizeInGB')
           os_disks << disk
         end
         os_disks

data/lib/azure/virtual_machine_image_management/virtual_machine_disk.rb

@@ -20,7 +20,7 @@ module Azure
         yield self if block_given?
       end
 
-      attr_accessor :name, :attached
+      attr_accessor :name, :attached, :os_type, :image, :size
 
     end
   end

data/lib/azure/virtual_machine_image_management/virtual_machine_image_management_service.rb

@@ -50,6 +50,11 @@ module Azure
         Serialization.disks_from_xml(response)
       end
 
+      def get_virtual_machine_disk(disk_name)
+        disk = list_virtual_machine_disks.select {|x| x.name == disk_name}
+        disk.first
+      end
+
       # Public: Deletes the specified data or operating system disk from the image repository.
       #
       # Returns None

data/lib/azure/virtual_machine_management/serialization.rb

@@ -43,6 +43,18 @@ module Azure
         builder.doc.to_xml
       end
 
+      def self.restart_virtual_machine_to_xml
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.RestartRoleOperation(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure',
+            'xmlns:i' => 'http://www.w3.org/2001/XMLSchema-instance'
+          ) do
+            xml.OperationType 'RestartRoleOperation'
+          end
+        end
+        builder.doc.to_xml
+      end
+
       def self.deployment_to_xml(params, options)
         options[:deployment_name] ||= options[:cloud_service_name]
         builder = Nokogiri::XML::Builder.new do |xml|
@@ -101,6 +113,7 @@ module Azure
       end
 
       def self.provisioning_configuration_to_xml(xml, params, options)
+        fingerprint = params[:certificate][:fingerprint]
         if options[:os_type] == 'Linux'
           xml.ConfigurationSet('i:type' => 'LinuxProvisioningConfigurationSet') do
             xml.ConfigurationSetType 'LinuxProvisioningConfiguration'
@@ -110,11 +123,11 @@ module Azure
               xml.UserPassword params[:password]
               xml.DisableSshPasswordAuthentication 'false'
             end
-            if params[:certificate][:fingerprint]
+            if fingerprint
               xml.SSH do
                 xml.PublicKeys do
                   xml.PublicKey do
-                    xml.Fingerprint params[:certificate][:fingerprint]
+                    xml.Fingerprint fingerprint
                     xml.Path "/home/#{params[:vm_user]}/.ssh/authorized_keys"
                   end
                 end
@@ -139,7 +152,7 @@ module Azure
                   if options[:winrm_transport].include?('https')
                     xml.Listener do
                       xml.Protocol 'Https'
-                      xml.CertificateThumbprint params[:certificate][:fingerprint] if params[:certificate][:fingerprint]
+                      xml.CertificateThumbprint fingerprint if fingerprint
                     end
                   end
                 end
@@ -152,73 +165,82 @@ module Azure
 
       def self.default_endpoints_to_xml(xml, options)
         os_type = options[:os_type]
+        endpoints = []
         if os_type == 'Linux'
-          xml.InputEndpoint do
-            xml.LocalPort '22'
-            xml.Name 'SSH'
-            xml.Port options[:ssh_port] || '22'
-            xml.Protocol 'TCP'
+          endpoints <<  {
+            name: 'SSH',
+            public_port: options[:ssh_port] || '22',
+            protocol: 'TCP',
+            local_port: '22'
+          }
+        elsif os_type == 'Windows' && options[:winrm_transport]
+          if options[:winrm_transport].include?('http')
+            endpoints <<  {
+              name: 'WinRm-Http',
+              public_port: '5985',
+              protocol: 'TCP',
+              local_port: '5985'
+            }
           end
-        elsif os_type == 'Windows'
-          if options[:winrm_transport] && options[:winrm_transport].include?('http')
-            xml.InputEndpoint do
-              xml.LocalPort '5985'
-              xml.Name 'WinRm-Http'
-              xml.Port '5985'
-              xml.Protocol 'TCP'
-            end
-          end
-          if options[:winrm_transport] && options[:winrm_transport].include?('https')
-            xml.InputEndpoint do
-              xml.LocalPort '5986'
-              xml.Name 'WinRm-Https'
-              xml.Port '5986'
-              xml.Protocol 'TCP'
-            end
+          if options[:winrm_transport].include?('https')
+            endpoints <<  {
+              name: 'PowerShell',
+              public_port: '5986',
+              protocol: 'TCP',
+              local_port: '5986'
+            }
           end
         end
+        endpoints_to_xml(xml, endpoints)
       end
 
       def self.tcp_endpoints_to_xml(xml, tcp_endpoints)
-        if tcp_endpoints
-          tcp_endpoints.split(',').each do |endpoint|
-            ports = endpoint.split(':')
-            xml.InputEndpoint do
-              xml.LocalPort ports[0]
-              if ports.length > 1
-                xml.Name 'TCP-PORT-' + ports[1]
-                xml.Port ports[1]
-              else
-                xml.Name 'TCP-PORT-' + ports[0]
-                xml.Port ports[0]
-              end
-              xml.Protocol 'TCP'
-            end
+        endpoints = []
+        tcp_endpoints.split(',').each do |endpoint|
+          ports = endpoint.split(':')
+          tcp_ep = {}
+          if ports.length > 1
+            tcp_ep[:name]  = 'TCP-PORT-' + ports[1]
+            tcp_ep[:public_port] = ports[1]
+          else
+            tcp_ep[:name] = 'TCP-PORT-' + ports[0]
+            tcp_ep[:public_port] = ports[0]
           end
+          tcp_ep[:local_port] = ports[0]
+          tcp_ep[:protocol] = 'TCP'
+          endpoints << tcp_ep
         end
+        endpoints_to_xml(xml, endpoints)
       end
 
       def self.virtual_machines_from_xml(deployXML, cloud_service_name)
-        unless (deployXML.nil? or deployXML.at_css('Deployment Name').nil?)
-          rolesXML = deployXML.css('Deployment RoleInstanceList RoleInstance')
+        unless deployXML.nil? or deployXML.at_css('Deployment Name').nil?
+          instances = deployXML.css('Deployment RoleInstanceList RoleInstance')
+          roles = deployXML.css('Deployment RoleList Role')
+          ip = deployXML.css('Deployment VirtualIPs VirtualIP')
           vms = []
-          rolesXML.each do |instance|
+          instances.each do |instance|
             vm = VirtualMachine.new
+            role_name = xml_content(instance, 'RoleName')
             vm.status = xml_content(instance, 'InstanceStatus')
-            vm.vm_name = xml_content(instance, 'RoleName').downcase
+            vm.vm_name = role_name.downcase
+            vm.ipaddress = xml_content(ip, 'Address')
             vm.role_size = xml_content(instance, 'InstanceSize')
             vm.hostname = xml_content(instance, 'HostName')
             vm.cloud_service_name = cloud_service_name.downcase
             vm.deployment_name = xml_content(deployXML, 'Deployment Name')
             vm.deployment_status = xml_content(deployXML, 'Deployment Status')
-            tcp_endpoints_from_xml(instance, vm)
-            vm.ipaddress = xml_content(instance, 'IpAddress') unless vm.ipaddress
-            vm.virtual_network_name = xml_content(deployXML.css('Deployment'), 'VirtualNetworkName')
-            deployXML.css('Deployment RoleList Role').each do |role|
-              if xml_content(role, 'RoleName') ==  xml_content(instance, 'RoleName')
+            vm.virtual_network_name =  xml_content(
+              deployXML.css('Deployment'),
+              'VirtualNetworkName'
+            )
+            roles.each do |role|
+              if xml_content(role, 'RoleName') ==  role_name
                 vm.availability_set_name = xml_content(role, 'AvailabilitySetName')
+                endpoints_from_xml(role, vm)
                 vm.os_type = xml_content(role, 'OSVirtualHardDisk OS')
                 vm.disk_name = xml_content(role, 'OSVirtualHardDisk DiskName')
+                vm.media_link = xml_content(role, 'OSVirtualHardDisk MediaLink')
                 break
               end
             end
@@ -228,30 +250,124 @@ module Azure
         end
       end
 
-      def self.tcp_endpoints_from_xml(rolesXML, vm)
+      def self.endpoints_from_xml(rolesXML, vm)
         vm.tcp_endpoints = []
         vm.udp_endpoints = []
-        endpoints = rolesXML.css('InstanceEndpoint')
+        endpoints = rolesXML.css('ConfigurationSets ConfigurationSet InputEndpoints InputEndpoint')
         endpoints.each do |endpoint|
-          if vm.ipaddress.nil?
-            if xml_content(endpoint, 'Name').downcase == 'ssh'
-              vm.ipaddress = xml_content(endpoint, 'Vip')
-            elsif !(xml_content(endpoint, 'Name').downcase =~ /winrm/).nil?
-              vm.ipaddress = xml_content(endpoint, 'Vip')
-            end
+          lb_name = xml_content(endpoint, 'LoadBalancedEndpointSetName')
+          ep = {}
+          ep[:name] = xml_content(endpoint, 'Name')
+          ep[:vip] = xml_content(endpoint, 'Vip')
+          ep[:public_port] = xml_content(endpoint, 'Port')
+          ep[:local_port] = xml_content(endpoint, 'LocalPort')
+          ep[:protocol] = xml_content(endpoint, 'Protocol')
+          server_return = xml_content(endpoint, 'EnableDirectServerReturn')
+          ep[:direct_server_return] = server_return if !server_return.empty?
+          unless lb_name.empty?
+            ep[:protocol] = endpoint.css('Protocol').last.text
+            ep[:load_balancer_name] =  lb_name
+            lb_port = xml_content(endpoint, 'LoadBalancerProbe Port')
+            lb_protocol = xml_content(endpoint, 'LoadBalancerProbe Protocol')
+            lb_path = xml_content(endpoint, 'LoadBalancerProbe Path')
+            lb_interval = xml_content(
+              endpoint,
+              'LoadBalancerProbe IntervalInSeconds'
+            )
+            lb_timeout = xml_content(
+              endpoint,
+              'LoadBalancerProbe TimeoutInSeconds'
+            )
+            ep[:load_balancer] = {
+              port: lb_port,
+              path: lb_path,
+              protocol: lb_protocol,
+              interval: lb_interval,
+              timeout: lb_timeout
+            }
           end
-          hash = Hash.new
-          hash['Name'] = xml_content(endpoint, 'Name')
-          hash['Vip'] = xml_content(endpoint, 'Vip')
-          hash['PublicPort'] = xml_content(endpoint, 'PublicPort')
-          hash['LocalPort'] = xml_content(endpoint, 'LocalPort')
-          if xml_content(endpoint, 'Protocol') == 'tcp'
-            vm.tcp_endpoints << hash
+          if ep[:protocol].downcase == 'tcp'
+            vm.tcp_endpoints << ep
           else
-            vm.udp_endpoints << hash
+            vm.udp_endpoints << ep
           end
         end
       end
+
+      def self.update_role_to_xml(endpoints, vm)
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.PersistentVMRole(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure',
+            'xmlns:i' => 'http://www.w3.org/2001/XMLSchema-instance'
+          ) do
+            xml.ConfigurationSets do
+              xml.ConfigurationSet do
+                xml.ConfigurationSetType 'NetworkConfiguration'
+                xml.InputEndpoints do
+                  endpoints_to_xml(xml, endpoints)
+                end
+              end
+            end
+            xml.OSVirtualHardDisk do
+            end
+          end
+        end
+        builder.doc.to_xml
+      end
+
+      def self.endpoints_to_xml(xml, endpoints)
+        endpoints.each do |endpoint|
+          endpoint[:load_balancer] ||= {}
+          protocol = endpoint[:protocol]
+          port = endpoint[:public_port]
+          interval = endpoint[:load_balancer][:interval]
+          timeout =  endpoint[:load_balancer][:timeout]
+          path = endpoint[:load_balancer][:path]
+          balancer_name = endpoint[:load_balancer_name]
+          xml.InputEndpoint do
+            xml.LoadBalancedEndpointSetName balancer_name if balancer_name
+            xml.LocalPort endpoint[:local_port]
+            xml.Name endpoint[:name]
+            xml.Port endpoint[:public_port]
+            if balancer_name
+              xml.LoadBalancerProbe do
+                xml.Path path if path
+                xml.Port endpoint[:load_balancer][:port] || port
+                xml.Protocol endpoint[:load_balancer][:protocol] || 'TCP'
+                xml.IntervalInSeconds interval if interval
+                xml.TimeoutInSeconds timeout if timeout
+              end
+            end
+            xml.Protocol protocol
+            xml.EnableDirectServerReturn endpoint[:direct_server_return] unless endpoint[:direct_server_return].nil?
+          end
+        end
+      end
+
+      def self.add_data_disk_to_xml(lun, media_link, options)
+        if options[:import] && options[:disk_name].nil?
+          Loggerx.error_with_exit "The data disk name is not valid."
+        end
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.DataVirtualHardDisk(
+            'xmlns' => 'http://schemas.microsoft.com/windowsazure',
+            'xmlns:i' => 'http://www.w3.org/2001/XMLSchema-instance'
+          ) do
+            xml.HostCaching options[:host_caching] || 'ReadOnly'
+            xml.DiskLabel options[:disk_label]
+            xml.DiskName options[:disk_name] if options[:import]
+            xml.Lun lun
+            xml.LogicalDiskSizeInGB options[:disk_size] || 1
+            unless options[:import]
+              disk_name  = media_link[/([^\/]+)$/]
+              media_link = media_link.gsub(/#{disk_name}/, (Time.now.strftime('disk_%Y_%m_%d_%H_%M')) + '.vhd')
+              xml.MediaLink media_link
+            end
+          end
+        end
+        builder.doc.to_xml
+      end
+
     end
   end
 end

data/lib/azure/virtual_machine_management/virtual_machine.rb

@@ -36,6 +36,7 @@ module Azure
       attr_accessor :disk_name
       attr_accessor :virtual_network_name
       attr_accessor :availability_set_name
+      attr_accessor :media_link
     end
   end
 end

data/lib/azure/virtual_machine_management/virtual_machine_management_service.rb

@@ -18,7 +18,6 @@ include Azure::VirtualMachineImageManagement
 module Azure
   module VirtualMachineManagement
     class VirtualMachineManagementService < BaseManagementService
-
       def initialize
         super()
       end
@@ -26,16 +25,19 @@ module Azure
       # Public: Get a lists of virtual machines available under the current subscription.
       #
       # Returns an list of Azure::VirtualMachineManagement::VirtualMachine instances.
-      def list_virtual_machines
+      def list_virtual_machines(*cloud_service_names)
         roles = []
-        cloud_service = Azure::CloudServiceManagementService.new
-        cloud_services = cloud_service.list_cloud_services
-        cloud_services.each do |cloud_service|
-          request_path = "/services/hostedservices/#{cloud_service.name}/deploymentslots/production"
+        cloud_service_names.flatten!
+        if cloud_service_names.empty?
+          cloud_service = Azure::CloudServiceManagementService.new
+          cloud_service_names = cloud_service.list_cloud_services.map(&:name)
+        end
+        cloud_service_names.each do |cloud_service_name|
+          request_path = "/services/hostedservices/#{cloud_service_name}/deploymentslots/production"
           request = ManagementHttpRequest.new(:get, request_path)
           request.warn = true
           response = request.call
-          roles << Serialization.virtual_machines_from_xml(response,cloud_service.name)
+          roles << Serialization.virtual_machines_from_xml(response, cloud_service_name)
         end
         roles.flatten.compact
       end
@@ -49,7 +51,7 @@ module Azure
       #
       # Returns an  Azure::VirtualMachineManagement::VirtualMachine instance.
       def get_virtual_machine(name, cloud_service_name)
-        server = list_virtual_machines.select {|x| x.vm_name == name && x.cloud_service_name == cloud_service_name}
+        server = list_virtual_machines(cloud_service_name).select { |x| x.vm_name == name && x.cloud_service_name == cloud_service_name }
         server.first
       end
 
@@ -83,7 +85,7 @@ module Azure
       # * +:ssh_private_key_file+     - String. Path of private key file.
       # * +:ssh_certificate_file+     - String. Path of certificate file.
       # * +:ssh_port+                 - Integer. Specifies the SSH port number.
-      # * +:vm_size+                  - String. Specifies the size of the virtual machine instance.  
+      # * +:vm_size+                  - String. Specifies the size of the virtual machine instance.
       # * +:winrm_transport+          - Array. Specifies WINRM transport protocol.
       # * +:availability_set_name+    - String. Specifies the availability set name.
       #
@@ -103,15 +105,15 @@ module Azure
         options[:os_type] = get_os_type(params[:image])
         validate_deployment_params(params, options)
         options[:deployment_name] ||= options[:cloud_service_name]
-        
+
         unless add_role
-          Loggerx.info "Creating deploymnent..."
+          Loggerx.info 'Creating deploymnent...'
           options[:cloud_service_name] ||= generate_cloud_service_name(params[:vm_name])
           options[:storage_account_name] ||= generate_storage_account_name(params[:vm_name])
           optionals = {}
           if options[:virtual_network_name]
             virtual_network_service = Azure::VirtualNetworkManagementService.new
-            virtual_networks = virtual_network_service.list_virtual_networks.select{|x| x.name == options[:virtual_network_name]}
+            virtual_networks = virtual_network_service.list_virtual_networks.select { |x| x.name == options[:virtual_network_name] }
             if virtual_networks.empty?
               Loggerx.error_with_exit "Virtual network #{options[:virtual_network_name]} doesn't exists"
             else
@@ -124,19 +126,19 @@ module Azure
           end
           cloud_service = Azure::CloudServiceManagementService.new
           cloud_service.create_cloud_service(options[:cloud_service_name], optionals)
-          cloud_service.upload_certificate(options[:cloud_service_name],params[:certificate]) unless params[:certificate].empty?
+          cloud_service.upload_certificate(options[:cloud_service_name], params[:certificate]) unless params[:certificate].empty?
           Azure::StorageManagementService.new.create_storage_account(options[:storage_account_name], optionals)
-          body = Serialization.deployment_to_xml(params,options)
+          body = Serialization.deployment_to_xml(params, options)
           path = "/services/hostedservices/#{options[:cloud_service_name]}/deployments"
         else
 
-          Loggerx.info "Deployment exists, adding role..."
+          Loggerx.info 'Deployment exists, adding role...'
           body = Serialization.role_to_xml(params, options).to_xml
           path = "/services/hostedservices/#{options[:cloud_service_name]}/deployments/#{options[:deployment_name]}/roles"
         end
         Loggerx.error 'Cloud service name is required for adding role.' unless options[:cloud_service_name]
         Loggerx.error 'Storage account name is required for adding role.' unless options[:storage_account_name]
-        Loggerx.info "Deployment in progress..."
+        Loggerx.info 'Deployment in progress...'
         request = ManagementHttpRequest.new(:post, path, body)
         request.call
         get_virtual_machine(params[:vm_name], options[:cloud_service_name])
@@ -156,19 +158,34 @@ module Azure
       #
       # Returns NONE
       def delete_virtual_machine(vm_name, cloud_service_name)
-        vm = get_virtual_machine(vm_name,cloud_service_name)
+        vm = get_virtual_machine(vm_name, cloud_service_name)
         if vm
           cloud_service = Azure::CloudServiceManagementService.new
           cloud_service.delete_cloud_service_deployment(cloud_service_name)
           cloud_service.delete_cloud_service(cloud_service_name)
           Loggerx.info "Waiting for disk to be released.\n"
-          sleep 60
+          disk_name = vm.disk_name
           disk_management_service = VirtualMachineDiskManagementService.new
-          disk_management_service.delete_virtual_machine_disk(vm.disk_name)
+          # Wait for 180s for disk to be released.
+          disk = nil
+          18.times do
+            print '# '
+            disk = disk_management_service.get_virtual_machine_disk(disk_name)
+            unless disk.attached
+              print "Disk released.\n"
+              break
+            end
+            sleep 10
+          end
+          if disk.attached
+            Loggerx.error "\nCannot delete disk #{disk_name}."
+          else
+            disk_management_service.delete_virtual_machine_disk(disk_name)
+          end
         else
           Loggerx.error "Cannot find virtual machine #{vm_name} under cloud service #{cloud_service_name}"
         end
-      rescue 
+      rescue
       end
 
       # Public: Shuts down the specified virtual machine.
@@ -184,8 +201,8 @@ module Azure
       def shutdown_virtual_machine(vm_name, cloud_service_name)
         vm = get_virtual_machine(vm_name, cloud_service_name)
         if vm
-          if ['StoppedVM','StoppedDeallocated'].include?(vm.status)
-            Loggerx.error "Cannot perform the shutdown operation on a stopped virtual machine."
+          if ['StoppedVM', 'StoppedDeallocated'].include?(vm.status)
+            Loggerx.error 'Cannot perform the shutdown operation on a stopped virtual machine.'
           elsif vm.deployment_status == 'Running'
             path = "/services/hostedservices/#{vm.cloud_service_name}/deployments/#{vm.deployment_name}/roleinstances/#{vm.vm_name}/Operations"
             body = Serialization.shutdown_virtual_machine_to_xml
@@ -193,7 +210,7 @@ module Azure
             request = ManagementHttpRequest.new(:post, path, body)
             request.call
           else
-            Loggerx.error "Cannot perform the shutdown operation on a stopped deployment."
+            Loggerx.error 'Cannot perform the shutdown operation on a stopped deployment.'
           end
         else
           Loggerx.error "Cannot find virtual machine \"#{vm_name}\" under cloud service \"#{cloud_service_name}\". "
@@ -214,7 +231,7 @@ module Azure
         vm = get_virtual_machine(vm_name, cloud_service_name)
         if vm
           if vm.status == 'ReadyRole'
-            Loggerx.error "Cannot perform the start operation on started virtual machine."
+            Loggerx.error 'Cannot perform the start operation on started virtual machine.'
           else
             path = "/services/hostedservices/#{vm.cloud_service_name}/deployments/#{vm.deployment_name}/roleinstances/#{vm.vm_name}/Operations"
             body = Serialization.start_virtual_machine_to_xml
@@ -227,6 +244,156 @@ module Azure
         end
       end
 
+      # Public: Restarts the specified virtual machine.
+      #
+      # ==== Attributes
+      #
+      # * +name+                - String. Virtual machine name.
+      # * +cloud_service_name+  - String. Cloud service name.
+      #
+      # See http://msdn.microsoft.com/en-us/library/windowsazure/jj157197.aspx
+      #
+      # Returns NONE
+      def restart_virtual_machine(vm_name, cloud_service_name)
+        vm = get_virtual_machine(vm_name, cloud_service_name)
+        if vm
+          path = "/services/hostedservices/#{vm.cloud_service_name}/deployments/#{vm.deployment_name}/roleinstances/#{vm.vm_name}/Operations"
+          body = Serialization.restart_virtual_machine_to_xml
+          Loggerx.info "Restarting virtual machine \"#{vm.vm_name}\" ..."
+          request = ManagementHttpRequest.new(:post, path, body)
+          request.call
+        else
+          Loggerx.error "Cannot find virtual machine \"#{vm_name}\" under cloud service \"#{cloud_service_name}\"."
+        end
+      end
+      
+      # Public: Add/Update endpoints of virtual machine.
+      #
+      # ==== Attributes
+      #
+      # * +name+                - String. Virtual machine name.
+      # * +cloud_service_name+  - String. Cloud service name.
+      # * +input_endpoints+     - Hash. A hash of the name/value pairs for the endpoint.
+      #
+      # ==== Endpoint
+      #
+      # Accepted key/value pairs are:
+      # * +:local_port+   - String. Specifies the internal port on which the
+      #   Virtual Machine is listening.
+      # * +:public_port+  - String. Specifies the external port to use for
+      #   the endpoint.
+      # * +:name+         - String. Specifies the name of the external endpoint.
+      # * +load_balancer_name+  - String. Specifies a name for a set of
+      #   load-balanced endpoints.
+      # * +:protocol+              - String. Specifies the transport protocol
+      #   for the endpoint. Possible values are: TCP, UDP
+      # * +:direct_server_return+  - String. Specifies whether the endpoint
+      #   uses Direct Server Return. (optional)
+      # * +:load_balancer          - Hash. Contains properties that define the
+      #   endpoint settings that the load balancer uses to monitor the
+      #   availability of the Virtual Machine (optional)
+      #
+      # === Load balancer
+      #
+      # Accepted key/value pairs are:
+      # * +:port+   - String. Specifies the internal port on which the
+      #   Virtual Machine is listening.
+      # * +:protocol+  - String. Specifies the protocol to use to inspect the
+      #   availability status of the virtual machine.
+      # * +:interval+  - String. Specifies the interval for the load balancer
+      #   probe in seconds. (optional)
+      # * +:timeout+   - String. Specifies the timeout for the load balancer
+      #   probe in seconds. (optional)
+      # * +:path+      - String. Specifies the relative path to inspect to
+      #   determine the availability status of the Virtual Machine. (optional)
+      #
+      # See http://msdn.microsoft.com/en-us/library/windowsazure/jj157187.aspx
+      #
+      # Returns NONE
+      def update_endpoints(vm_name, cloud_service_name, *input_endpoints)
+        input_endpoints.flatten!
+        vm = get_virtual_machine(vm_name, cloud_service_name)
+        if vm
+          path = "/services/hostedservices/#{vm.cloud_service_name}/deployments/#{vm.deployment_name}/roles/#{vm_name}"
+          endpoints = vm.tcp_endpoints + vm.udp_endpoints
+          input_endpoints.each do |iep|
+            endpoints.delete_if { |ep| iep[:name].downcase == ep[:name].downcase && iep[:protocol].downcase  == ep[:protocol] }
+          end
+          endpoints += input_endpoints
+          body = Serialization.update_role_to_xml(endpoints, vm)
+          request = ManagementHttpRequest.new(:put, path, body)
+          Loggerx.info "Updating endpoints of virtual machine #{vm.vm_name} ..."
+          request.call
+        else
+          Loggerx.error "Cannot find virtual machine \"#{vm_name}\" under cloud service \"#{cloud_service_name}\"."
+        end
+      end
+
+      # Public: Delete endpoint of virtual machine.
+      #
+      # ==== Attributes
+      #
+      # * +name+                - String. Virtual machine name.
+      # * +cloud_service_name+  - String. Cloud service name.
+      # * +endpoint_name+       - String. Name of endpoint.
+      # 
+      # See http://msdn.microsoft.com/en-us/library/windowsazure/jj157187.aspx
+      #
+      # Returns NONE
+      def delete_endpoint(vm_name, cloud_service_name, endpoint_name)
+        vm = get_virtual_machine(vm_name, cloud_service_name)
+        if vm
+          path = "/services/hostedservices/#{vm.cloud_service_name}/deployments/#{vm.deployment_name}/roles/#{vm_name}"
+          endpoints = vm.tcp_endpoints + vm.udp_endpoints
+          endpoints.delete_if { |ep| endpoint_name.downcase == ep[:name].downcase }
+          body = Serialization.update_role_to_xml(endpoints, vm)
+          request = ManagementHttpRequest.new(:put, path, body)
+          Loggerx.info "Deleting virtual machine endpoint #{endpoint_name} ..."
+          request.call
+        else
+          Loggerx.error "Cannot find virtual machine \"#{vm_name}\" under cloud service \"#{cloud_service_name}\"."
+        end
+      end
+
+      # Public: adds a data disk to a virtual machine.
+      #
+      # ==== Attributes
+      #
+      # * +cloud_service_name+  - String. Cloud service name.
+      # * +vm_name+           - String. Virtual machine name.
+      # * +lun+                 - String. Specifies the Logical Unit Number
+      #   (LUN) for the disk. Valid LUN values are 0 through 15.
+      # * +options+             - Hash. Optional parameters.
+      #
+      # ==== Options
+      #
+      # Accepted key/value pairs in options parameter are:
+      # * +:import+        - Boolean. if true, then allows to use an existing
+      #  disk by disk name. if false, then create and attach new data disk.
+      # * +:disk_name+     - String. Specifies the name of the disk.
+      #   Reqruied if using existing disk.
+      # * +:host_caching+  - String. Specifies the caching behavior of data disk
+      #   The default is ReadOnly. Possible values are: None, ReadOnly, ReadWrite
+      # * +:disk_label+    - String. Specifies the description of the data disk.
+      # * +:disk_size+     - String. Specifies the size of disk in GB
+      #
+      # See http://msdn.microsoft.com/en-us/library/windowsazure/jj157199.aspx
+      #
+      # Returns None
+      def add_data_disk(vm_name, cloud_service_name, lun, options = {})
+        options[:import] ||= false
+        vm = get_virtual_machine(vm_name, cloud_service_name)
+        if vm
+          path = "/services/hostedservices/#{cloud_service_name}/deployments/#{vm.deployment_name}/roles/#{vm_name}/DataDisks"
+          body = Serialization.add_data_disk_to_xml(lun, vm.media_link, options)
+          Loggerx.info "Adding data disk to virtual machine #{vm_name} ..."
+          request = ManagementHttpRequest.new(:post, path, body)
+          request.call
+        else
+          Loggerx.error "Cannot find virtual machine \"#{vm_name}\" under cloud service \"#{cloud_service_name}\"."
+        end
+      end
+
       private
 
       # Private: Gets the operating system type of an image.
@@ -234,45 +401,45 @@ module Azure
       # Returns Linux or Windows
       def get_os_type(image_name)
         image_service = Azure::VirtualMachineImageManagementService.new
-        image = image_service.list_virtual_machine_images.select{|x| x.name == image_name}.first
-        Loggerx.error_with_exit "The virtual machine image source is not valid." unless image
+        image = image_service.list_virtual_machine_images.select { |x| x.name == image_name }.first
+        Loggerx.error_with_exit 'The virtual machine image source is not valid.' unless image
         image.os_type
       end
 
       def generate_cloud_service_name(vm_name)
-        random_string(vm_name+'-service-')
+        random_string(vm_name + '-service-')
       end
 
       def generate_storage_account_name(vm_name)
-        random_string(vm_name+'storage').gsub(/[^0-9a-z ]/i, '').downcase[0..23] 
+        random_string(vm_name + 'storage').gsub(/[^0-9a-z ]/i, '').downcase[0..23]
       end
 
       def validate_deployment_params(params, options)
         errors = []
-        params_keys = ["vm_name", "image", "location", "vm_user"]
-        if options[:os_type] == "Windows"
-          params_keys += ["password"]
+        params_keys = ['vm_name', 'image', 'location', 'vm_user']
+        if options[:os_type] == 'Windows'
+          params_keys += ['password']
         end
         options_keys = []
-        options_keys = ['private_key_file','certificate_file'] if certificate_required?(params, options)
+        options_keys = ['private_key_file', 'certificate_file'] if certificate_required?(params, options)
 
         params_keys.each do |key|
           errors << key if params[key.to_sym].nil?
         end
-        
+
         options_keys.each do |key|
           errors << key if options[key.to_sym].nil?
         end
         validate_role_size(options[:vm_size])
-        validate_location(params[:location]) unless errors.include?("location")
+        validate_location(params[:location]) unless errors.include?('location')
         if errors.empty?
-          params[:certificate]={}
+          params[:certificate] = {}
           if certificate_required?(params, options)
             begin
               params[:certificate][:key] = OpenSSL::PKey.read File.read(options[:private_key_file])
               params[:certificate][:cert] = OpenSSL::X509::Certificate.new File.read(options[:certificate_file])
               params[:certificate][:fingerprint] = export_fingerprint(params[:certificate][:cert])
-            rescue Exception =>e
+            rescue Exception => e
               Loggerx.error_with_exit e.message
             end
           end
@@ -304,14 +471,13 @@ module Azure
 
       def validate_location(location_name)
         locations = Azure::BaseManagementService.new.list_locations
-        location = locations.select{|loc| loc.name.downcase == location_name.downcase}.first
+        location = locations.select { |loc| loc.name.downcase == location_name.downcase }.first
         if location.nil?
-          Loggerx.error_with_exit "Value '#{location_name}' specified for parameter 'location' is invalid. Allowed values are #{locations.collect(&:name).join(',')}"
-        elsif !location.available_services.include?("PersistentVMRole")
+          Loggerx.error_with_exit "Value '#{location_name}' specified for parameter 'location' is invalid. Allowed values are #{locations.map(&:name).join(',')}"
+        elsif !location.available_services.include?('PersistentVMRole')
           Loggerx.error_with_exit "Persistentvmrole not enabled for \"#{location.name}\". Try different location"
         end
       end
-
     end
   end
 end