vagrant-vcloud 0.1.0

data/lib/vagrant-vcloud/driver/base.rb

@@ -0,0 +1,459 @@
+#
+#  Copyright 2012 Stefano Tortarolo
+#  Copyright 2013 Fabio Rapposelli and Timo Sugliani
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+require "log4r"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+require "vagrant/util/retryable"
+require "vagrant/util/subprocess"
+
+
+module VagrantPlugins
+  module VCloud
+    module Driver
+      class UnauthorizedAccess < StandardError; end
+      class WrongAPIVersion < StandardError; end
+      class WrongItemIDError < StandardError; end
+      class InvalidStateError < StandardError; end
+      class InternalServerError < StandardError; end
+      class UnhandledError < StandardError; end
+
+      # Main class to access vCloud rest APIs
+      class Base
+        include Vagrant::Util::Retryable
+
+        def initialize
+          @logger = Log4r::Logger.new("vagrant::provider::vcloud::base")
+        end
+
+        ##
+        # Authenticate against the specified server
+        def login
+        end
+
+        ##
+        # Destroy the current session
+        def logout
+        end
+
+        ##
+        # Fetch existing organizations and their IDs
+        def get_organizations
+        end
+
+        ##
+        # friendly helper method to fetch an Organization Id by name
+        # - name (this isn't case sensitive)
+        def get_organization_id_by_name(name)
+        end
+
+
+        ##
+        # friendly helper method to fetch an Organization by name
+        # - name (this isn't case sensitive)
+        def get_organization_by_name(name)
+        end
+
+        ##
+        # Fetch details about an organization:
+        # - catalogs
+        # - vdcs
+        # - networks
+        def get_organization(orgId)
+        end
+
+        ##
+        # Fetch details about a given catalog
+        def get_catalog(catalogId)
+        end
+
+        ##
+        # Friendly helper method to fetch an catalog id by name
+        # - organization hash (from get_organization/get_organization_by_name)
+        # - catalog name
+        def get_catalog_id_by_name(organization, catalogName)
+        end
+
+        ##
+        # Friendly helper method to fetch an catalog by name
+        # - organization hash (from get_organization/get_organization_by_name)
+        # - catalog name
+        def get_catalog_by_name(organization, catalogName)
+        end
+
+        ##
+        # Fetch details about a given vdc:
+        # - description
+        # - vapps
+        # - networks
+        def get_vdc(vdcId)
+        end
+
+        ##
+        # Friendly helper method to fetch a Organization VDC Id by name
+        # - Organization object
+        # - Organization VDC Name
+        def get_vdc_id_by_name(organization, vdcName)
+        end
+
+        ##
+        # Friendly helper method to fetch a Organization VDC by name
+        # - Organization object
+        # - Organization VDC Name
+        def get_vdc_by_name(organization, vdcName)
+        end
+
+        ##
+        # Fetch details about a given catalog item:
+        # - description
+        # - vApp templates
+        def get_catalog_item(catalogItemId)
+        end
+
+        ##
+        # friendly helper method to fetch an catalogItem  by name
+        # - catalogId (use get_catalog_name(org, name))
+        # - catalagItemName 
+        def get_catalog_item_by_name(catalogId, catalogItemName)
+        end  
+
+        ##
+        # Fetch details about a given vapp:
+        # - name
+        # - description
+        # - status
+        # - IP
+        # - Children VMs:
+        #   -- IP addresses
+        #   -- status
+        #   -- ID
+        def get_vapp(vAppId)
+        end
+
+        ##
+        # Delete a given vapp
+        # NOTE: It doesn't verify that the vapp is shutdown
+        def delete_vapp(vAppId)
+        end
+
+        ##
+        # Suspend a given vapp
+        def suspend_vapp(vAppId)
+        end
+
+        ##
+        # reboot a given vapp
+        # This will basically initial a guest OS reboot, and will only work if
+        # VMware-tools are installed on the underlying VMs.
+        # vShield Edge devices are not affected
+        def reboot_vapp(vAppId)
+        end
+
+        ##
+        # reset a given vapp
+        # This will basically reset the VMs within the vApp
+        # vShield Edge devices are not affected.
+        def reset_vapp(vAppId)
+        end
+
+        ##
+        # Boot a given vapp
+        def poweron_vapp(vAppId)
+        end
+
+        ##
+        # Create a vapp starting from a template
+        #
+        # Params:
+        # - vdc: the associated VDC
+        # - vapp_name: name of the target vapp
+        # - vapp_description: description of the target vapp
+        # - vapp_templateid: ID of the vapp template
+        def create_vapp_from_template(vdc, vapp_name, vapp_description, vapp_templateid, poweron=false)
+        end
+
+        ##
+        # Compose a vapp using existing virtual machines
+        #
+        # Params:
+        # - vdc: the associated VDC
+        # - vapp_name: name of the target vapp
+        # - vapp_description: description of the target vapp
+        # - vm_list: hash with IDs of the VMs to be used in the composing process
+        # - network_config: hash of the network configuration for the vapp
+        def compose_vapp_from_vm(vdc, vapp_name, vapp_description, vm_list={}, network_config={})
+        end
+
+        # Fetch details about a given vapp template:
+        # - name
+        # - description
+        # - Children VMs:
+        #   -- ID
+        def get_vapp_template(vAppId)
+        end
+
+        ##
+        # Set vApp port forwarding rules
+        #
+        # - vappid: id of the vapp to be modified
+        # - network_name: name of the vapp network to be modified
+        # - config: hash with network configuration specifications, must contain an array inside :nat_rules with the nat rules to be applied.
+        def set_vapp_port_forwarding_rules(vappid, network_name, config={})
+        end
+
+        ##
+        # Get vApp port forwarding rules
+        #
+        # - vappid: id of the vApp
+        def get_vapp_port_forwarding_rules(vAppId)
+        end
+
+        ##
+        # get vApp edge public IP from the vApp ID
+        # Only works when:
+        # - vApp needs to be poweredOn
+        # - FenceMode is set to "natRouted"
+        # - NatType" is set to "portForwarding
+        # This will be required to know how to connect to VMs behind the Edge device.
+        def get_vapp_edge_public_ip(vAppId)
+        end
+
+        ##
+        # Upload an OVF package
+        # - vdcId
+        # - vappName
+        # - vappDescription
+        # - ovfFile
+        # - catalogId
+        # - uploadOptions {}
+        def upload_ovf(vdcId, vappName, vappDescription, ovfFile, catalogId, uploadOptions={})
+        end
+
+        ##
+        # Fetch information for a given task
+        def get_task(taskid)
+        end
+
+        ##
+        # Poll a given task until completion
+        def wait_task_completion(taskid)
+        end
+
+        ##
+        # Set vApp Network Config
+        def set_vapp_network_config(vappid, network_name, config={})
+        end
+
+        ##
+        # Set VM Network Config
+        def set_vm_network_config(vmid, network_name, config={})
+        end
+
+
+        ##
+        # Set VM Guest Customization Config
+        def set_vm_guest_customization(vmid, computer_name, config={})
+        end
+
+        ##
+        # Fetch details about a given VM
+        def get_vm(vmId)
+        end
+
+        private
+          ##
+          # Sends a synchronous request to the vCloud API and returns the response as parsed XML + headers.
+          def send_request(params, payload=nil, content_type=nil)
+            headers = {:accept => "application/*+xml;version=#{@api_version}"}
+            if @auth_key
+              headers.merge!({:x_vcloud_authorization => @auth_key})
+            end
+
+            if content_type
+              headers.merge!({:content_type => content_type})
+            end
+
+            # FIXME: get rid of RestClient and switch everything to HTTPClient, easier to use and we get rid of another dependency.
+
+            request = RestClient::Request.new(:method => params['method'],
+                                             :user => "#{@username}@#{@org_name}",
+                                             :password => @password,
+                                             :headers => headers,
+                                             :url => "#{@api_url}#{params['command']}",
+                                             :payload => payload)
+
+
+            begin
+              response = request.execute
+              if ![200, 201, 202, 204].include?(response.code)
+                puts "Warning: unattended code #{response.code}"
+              end
+
+              # TODO: handle asynch properly, see TasksList
+              [Nokogiri.parse(response), response.headers]
+            rescue RestClient::ResourceNotFound => e
+              raise Errors::ObjectNotFound
+            rescue RestClient::Unauthorized => e
+              raise Errors::UnauthorizedAccess
+            rescue RestClient::BadRequest => e
+              body = Nokogiri.parse(e.http_body)
+              message = body.css("Error").first["message"]
+
+              case message
+              when /The request has invalid accept header/
+                raise WrongAPIVersion, "Invalid accept header. Please verify that the server supports v.#{@api_version} or specify a different API Version."
+              when /validation error on field 'id': String value has invalid format or length/
+                raise WrongItemIDError, "Invalid ID specified. Please verify that the item exists and correctly typed."
+              when /The requested operation could not be executed on vApp "(.*)". Stop the vApp and try again/
+                raise Errors::InvalidStateError, :message => "Invalid request because vApp is running. Stop vApp '#{$1}' and try again."
+              when /The requested operation could not be executed since vApp "(.*)" is not running/
+                raise Errors::InvalidStateError, :message => "Invalid request because vApp is stopped. Start vApp '#{$1}' and try again."
+              when /The administrator password cannot be empty when it is enabled and automatic password generation is not selected/
+                raise Errors::InvalidConfigError
+              when /The reference "(.*)" cannot be parsed correctly/   # FIXME: doesn't work
+                raise Errors::InvalidNetSpecification
+              else
+                raise UnhandledError, "BadRequest - unhandled error: #{message}.\nPlease report this issue."
+              end
+            rescue RestClient::Forbidden => e
+              body = Nokogiri.parse(e.http_body)
+              message = body.css("Error").first["message"]
+              raise Errors::UnauthorizedAccess
+            rescue RestClient::InternalServerError => e
+              body = Nokogiri.parse(e.http_body)
+              message = body.css("Error").first["message"]
+              raise InternalServerError, "Internal Server Error: #{message}."
+            rescue RestClient::Found => e
+              raise Errors::HostRedirect
+            end
+          end
+
+          ##
+          # Upload a large file in configurable chunks, output an optional progressbar
+          def upload_file(uploadURL, uploadFile, vAppTemplate, config={})
+
+            # Set chunksize to 10M if not specified otherwise
+            chunkSize = (config[:chunksize] || 10485760)
+
+            # Set progress bar to default format if not specified otherwise
+            progressBarFormat = (config[:progressbar_format] || "%t Progress: %p%% %e")
+
+            # Set progress bar length to 120 if not specified otherwise
+            progressBarLength = (config[:progressbar_length] || 80)
+
+            # Open our file for upload
+            uploadFileHandle = File.new(uploadFile, "rb" )
+            fileName = File.basename(uploadFileHandle)
+
+            progressBarTitle = "Uploading: " + fileName.to_s
+
+            # Create a progressbar object if progress bar is enabled
+            if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
+              progressbar = ProgressBar.create(
+                :title => progressBarTitle,
+                :starting_at => 0,
+                :total => uploadFileHandle.size.to_i,
+                ##:length => progressBarLength,
+                :format => progressBarFormat
+              )
+            else
+              puts progressBarTitle
+            end
+            # Create a new HTTP client
+            clnt = HTTPClient.new
+
+            # Disable SSL cert verification
+            clnt.ssl_config.verify_mode=(OpenSSL::SSL::VERIFY_NONE)
+
+            # Suppress SSL depth message
+            clnt.ssl_config.verify_callback=proc{ |ok, ctx|; true };
+
+            # Perform ranged upload until the file reaches its end
+            until uploadFileHandle.eof?
+
+              # Create ranges for this chunk upload
+              rangeStart = uploadFileHandle.pos
+              rangeStop = uploadFileHandle.pos.to_i + chunkSize
+
+              # Read current chunk
+              fileContent = uploadFileHandle.read(chunkSize)
+
+              # If statement to handle last chunk transfer if is > than filesize
+              if rangeStop.to_i > uploadFileHandle.size.to_i
+                contentRange = "bytes #{rangeStart.to_s}-#{uploadFileHandle.size.to_s}/#{uploadFileHandle.size.to_s}"
+                rangeLen = uploadFileHandle.size.to_i - rangeStart.to_i
+              else
+                contentRange = "bytes #{rangeStart.to_s}-#{rangeStop.to_s}/#{uploadFileHandle.size.to_s}"
+                rangeLen = rangeStop.to_i - rangeStart.to_i
+              end
+
+              # Build headers
+              extheader = {
+                'x-vcloud-authorization' => @auth_key,
+                'Content-Range' => contentRange,
+                'Content-Length' => rangeLen.to_s
+              }
+
+              begin
+                uploadRequest = "#{@host_url}#{uploadURL}"
+                connection = clnt.request('PUT', uploadRequest, nil, fileContent, extheader)
+
+                if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
+                  params = {
+                    'method' => :get,
+                    'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+                  }
+                  response, headers = send_request(params)
+
+                  response.css("Files File [name='#{fileName}']").each do |file|
+                    progressbar.progress=file[:bytesTransferred].to_i
+                  end
+                end
+              rescue # FIXME: HUGE FIXME!!!! DO SOMETHING WITH THIS, IT'S JUST STUPID AS IT IS NOW!!!
+                retryTime = (config[:retry_time] || 5)
+                puts "Range #{contentRange} failed to upload, retrying the chunk in #{retryTime.to_s} seconds, to stop the action press CTRL+C."
+                sleep retryTime.to_i
+                retry
+              end
+            end
+            uploadFileHandle.close
+          end
+
+
+          ##
+          # Convert vApp status codes into human readable description
+          def convert_vapp_status(status_code)
+            case status_code.to_i
+              when 0
+                'suspended'
+              when 3
+                'paused'
+              when 4
+                'running'
+              when 8
+                'stopped'
+              when 10
+                'mixed'
+              else
+                "Unknown #{status_code}"
+            end
+          end
+
+      end # class
+    end
+  end
+end