fog 1.25.0 → 1.26.0

data/lib/fog/ecloud/requests/compute/virtual_machine_copy_identical.rb

@@ -1,43 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def validate_create_server_options_identical(template_uri, options)
-          required_opts = [:name, :row, :group, :source]
-          unless required_opts.all? { |opt| options.key?(opt) }
-            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
-          end
-
-          options
-        end
-
-        def build_request_body_identical(options)
-          xml = Builder::XmlMarkup.new
-          xml.CopyIdenticalVirtualMachine(:name => options[:name]) do
-            xml.Source(:href => options[:source], :type => "application/vnd.tmrk.cloud.virtualMachine")
-            xml.Layout do
-              xml.NewRow options[:row]
-              xml.NewGroup options[:group]
-            end
-            xml.Description options[:description]
-          end
-        end
-      end
-
-      class Real
-        def virtual_machine_copy_identical(template_uri, options)
-          options = validate_create_server_options_identical(template_uri, options)
-          body = build_request_body_identical(options)
-          request(
-            :expects => 201,
-            :method => 'POST',
-            :headers => {},
-            :body => body,
-            :uri => template_uri,
-            :parse => true
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/requests/compute/virtual_machine_create_from_template.rb

@@ -1,244 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def validate_create_server_options(template_uri, options)
-          required_opts = [:name, :cpus, :memory, :row, :group, :customization, :network_uri]
-          if options[:customization] == :windows
-            required_opts.push(:windows_password)
-          else
-            required_opts.push(:ssh_key_uri)
-          end
-          unless required_opts.all? { |opt| options.key?(opt) }
-            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
-          end
-
-          options[:network_uri] = options[:network_uri].is_a?(String) ? [options[:network_uri]] : options[:network_uri]
-          options[:network_uri].map! do |uri|
-            network = get_network(uri).body
-            if options[:ips]
-              ip = options[:ips][options[:network_uri].index(uri)]
-            end
-            {:href => uri, :name => network[:name], :ip => ip}
-          end
-          options[:template_uri] = template_uri
-          options
-        end
-
-        def build_request_body(options)
-          xml = Builder::XmlMarkup.new
-          xml.CreateVirtualMachine(:name => options[:name]) do
-            xml.ProcessorCount options[:cpus]
-            xml.Memory do
-              xml.Unit "MB"
-              xml.Value options[:memory]
-            end
-            xml.Layout do
-              xml.NewRow options[:row]
-              xml.NewGroup options[:group]
-            end
-            xml.Description options[:description]
-            xml.Tags do
-              options[:tags].each do |tag|
-                xml.Tag tag
-              end
-            end
-            if options[:customization] == :windows
-              xml.WindowsCustomization do
-                xml.NetworkSettings do
-                  xml.NetworkAdapterSettings do
-                    options[:network_uri].each do |uri|
-                      xml.NetworkAdapter do
-                        xml.Network(:href => uri[:href], :name => uri[:name], :type => "application/vnd.tmrk.cloud.network")
-                        xml.IpAddress uri[:ip]
-                      end
-                    end
-                  end
-                  if options[:dns_settings]
-                    xml.DnsSettings do
-                      xml.PrimaryDns options[:dns_settings][:primary_dns]
-                      if options[:dns_settings][:secondary_dns]
-                        xml.SecondaryDns options[:dns_settings][:secondary_dns]
-                      end
-                    end
-                  end
-                end
-                xml.Password options[:windows_password]
-                if options[:windows_license_key]
-                  xml.LicenseKey options[:windows_license_key]
-                end
-              end
-            else
-              xml.LinuxCustomization do
-                xml.NetworkSettings do
-                  xml.NetworkAdapterSettings do
-                    options[:network_uri] = options[:network_uri].is_a?(String) ? [options[:network_uri]] : options[:network_uri]
-                    options[:network_uri].each do |uri|
-                      xml.NetworkAdapter do
-                        xml.Network(:href => uri[:href], :name => uri[:name], :type => "application/vnd.tmrk.cloud.network")
-                        xml.IpAddress uri[:ip]
-                      end
-                    end
-                  end
-                  if options[:dns_settings]
-                    xml.DnsSettings do
-                      xml.PrimaryDns options[:dns_settings][:primary_dns]
-                      if options[:dns_settings][:secondary_dns]
-                        xml.SecondaryDns options[:dns_settings][:secondary_dns]
-                      end
-                    end
-                  end
-                end
-                xml.SshKey(:href => options[:ssh_key_uri])
-              end
-            end
-            xml.PoweredOn options[:powered_on]
-            xml.Template(:href => options[:template_uri], :type => options[:template_type])
-          end
-        end
-      end
-
-      class Real
-        def virtual_machine_create_from_template(template_uri, options)
-          options = validate_create_server_options(template_uri, options)
-
-          request(
-            :expects => 201,
-            :method  => 'POST',
-            :body    => build_request_body(options),
-            :uri     => options[:uri],
-            :parse   => true
-          )
-        end
-      end
-
-      class Mock
-        def virtual_machine_create_from_template(template_uri, options)
-          options                      = validate_create_server_options(template_uri, options)
-          server_id                    = Fog::Mock.random_numbers(7).to_i
-          row_id                       = Fog::Mock.random_numbers(6).to_i
-          group_id                     = Fog::Mock.random_numbers(6).to_i
-          template_id, compute_pool_id = template_uri.match(/\/templates\/(\d+)\/computepools\/(\d+)$/).captures
-          compute_pool                 = self.data[:compute_pools][compute_pool_id.to_i].dup
-          environment                  = self.data[:environments][compute_pool[:environment_id]]
-          layout                       = self.data[:layouts][environment[:id]]
-          networks                     = options[:network_uri]
-          nics                         = networks.each_with_index.map do |network, i|
-            {
-              :UnitNumber => i.to_s,
-              :Name       => "Network adapter #{i}",
-              :MacAddress => Fog::Ecloud.mac_address,
-              :Network    => Fog::Ecloud.keep(network, :name, :href, :type),
-            }
-          end
-
-          links = [Fog::Ecloud.keep(compute_pool, :name, :href, :type), Fog::Ecloud.keep(environment, :name, :href, :type)]
-          networks.each do |network|
-            links << Fog::Ecloud.keep(network, :name, :href, :type)
-            network_id = id_from_uri(network[:href])
-            ip = self.data[:networks][network_id][:IpAddresses][:IpAddress].find { |ip| ip[:id] = network[:ip] }
-            ip[:DetectedOn] = {:href => "/cloudapi/ecloud/networkhosts/#{server_id}", :name => options[:name], :type => "application/vnd.tmrk.cloud.networkHost"}
-            ip[:Host]       = {:href => "/cloudapi/ecloud/networkhosts/#{server_id}", :name => options[:name], :type => "application/vnd.tmrk.cloud.networkHost"}
-          end
-
-          server = {
-            :href                  => "/cloudapi/ecloud/virtualmachines/#{server_id}",
-            :name                  => options[:name],
-            :type                  => "application/vnd.tmrk.cloud.virtualMachine",
-            :Description           => options[:description],
-            :Status                => "Deployed",
-            :HardwareConfiguration => {
-              :href => "/cloudapi/ecloud/virtualmachines/#{server_id}/hardwareconfiguration",
-              :type => "application/vnd.tmrk.cloud.virtualMachineHardware",
-              :Links => {
-                :Link => {
-                  :href => "/cloudapi/ecloud/virtualmachines/#{server_id}",
-                  :name => options[:name],
-                  :type => "application/vnd.tmrk.cloud.virtualMachine",
-                  :rel  => "up",
-                }
-              },
-              :ProcessorCount => options[:cpus],
-              :Memory => {
-                :Unit  => "MB",
-                :Value => options[:memory],
-              },
-              :Disks => {
-                :Disk => [{
-                  :Index => "0",
-                  :Name  => "Hard Disk 1",
-                  :Size  => {
-                    :Unit  => "GB",
-                    :Value => "25",
-                  },
-                }],
-              },
-              :Nics => {
-                :Nic => nics,
-              },
-            },
-            :IpAddresses => {
-              :AssignedIpAddresses => {
-                :Networks => {
-                  :Network => self.data[:networks].dup.values,
-                }
-              }
-            },
-            :Links => { :Link => links },
-          }
-
-          row = {
-            :id => row_id,
-            :name => options[:row],
-            :href => "/cloudapi/ecloud/layoutrows/#{row_id}",
-            :type => "application/vnd.tmrk.cloud.layoutRow",
-            :Links => {
-              :Link => [
-                Fog::Ecloud.keep(environment, :name, :href, :type)
-              ],
-            },
-            :Index => 0,
-            :Groups => {
-              :Group => [
-              ],
-            },
-            :environment_id => environment[:id],
-          }
-
-          group = {
-            :id => group_id,
-            :name => options[:group],
-            :href => "/cloudapi/ecloud/layoutgroups/#{group_id}",
-            :type => "application/vnd.tmrk.cloud.layoutGroup",
-            :Links => {
-              :Link => [
-                Fog::Ecloud.keep(row, :name, :href, :type),
-              ],
-            },
-            :Index => 0,
-            :VirtualMachines => {
-              :VirtualMachine => [
-                server,
-              ],
-            },
-            :row_id => row_id,
-          }
-          row[:Groups][:Group].push(group)
-          layout[:Rows][:Row].push(row)
-
-          server.merge!(:OperatingSystem => options[:operating_system].merge(:type => "application/vnd.tmrk.cloud.operatingSystem")) if options[:operating_system]
-
-          server_response = response(:body =>  server)
-
-          server.merge!(:compute_pool_id => compute_pool[:id])
-
-          self.data[:servers][server_id] = server
-          self.data[:rows][row_id]       = row
-          self.data[:groups][group_id]   = group
-
-          server_response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/requests/compute/virtual_machine_delete.rb

@@ -1,46 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Real
-        basic_request :virtual_machine_delete, 202, 'DELETE'
-      end
-
-      class Mock
-        def virtual_machine_delete(uri)
-          server_id = id_from_uri(uri)
-
-          server = self.data[:servers][server_id]
-          self.data[:servers].delete(server_id)
-          self.data[:groups].values.each do |group|
-            group[:VirtualMachines][:VirtualMachine].delete_if { |s| s[:name] == server[:name] }
-          end
-          self.data[:networks].values.each do |network|
-            network[:IpAddresses][:IpAddress].each do |ip|
-              unless ip[:Host].nil?
-                ip[:Host] = nil if ip[:Host][:name] == server[:name]
-              end
-              unless ip[:DetectedOn].nil?
-                ip[:DetectedOn] = nil if ip[:DetectedOn][:name] == server[:name]
-              end
-            end
-          end
-          task_id = Fog::Mock.random_numbers(10)
-          task = {
-            :id            => task_id,
-            :href          => "/cloudapi/ecloud/tasks/#{task_id}",
-            :type          => "application/vnd.tmrk.cloud.task",
-            :Operation     => "Delete Server",
-            :Status        => "Complete",
-            :ImpactedItem  => Fog::Ecloud.keep(server, :name, :href, :type),
-            :StartTime     => Time.now.iso8601,
-            :CompletedTime => Time.now.iso8601,
-            :InitiatedBy   => {},
-          }
-          self.data[:tasks][task_id] = task
-
-          response(:body =>  task)
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/requests/compute/virtual_machine_detach_disk.rb

@@ -1,70 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def build_request_body_detach_disk(options)
-          xml = Builder::XmlMarkup.new
-          xml.DetachDisk(:name => options[:name]) do
-            xml.Description options[:description]
-            xml.Disk do
-              xml.Index options[:disk][:Index]
-            end
-          end
-        end
-      end
-
-      class Real
-        def virtual_machine_detach_disk(href, options)
-          body = build_request_body_detach_disk(options)
-          request(
-            :expects => 201,
-            :method => 'POST',
-            :headers => {},
-            :body => body,
-            :uri => href,
-            :parse => true
-          )
-        end
-      end
-
-      class Mock
-        def virtual_machine_detach_disk(href, options)
-          server_id        = href.match(/(\d+)/)[1].to_i
-          server           = self.data[:servers][server_id]
-          compute_pool_id  = server[:compute_pool_id]
-          compute_pool     = self.data[:compute_pools][compute_pool_id]
-          detached_disk_id = Fog::Mock.random_numbers(6).to_i
-          detached_disk    = {
-            :id              => detached_disk_id,
-            :href            => "/cloudapi/ecloud/detacheddisks/#{detached_disk_id}",
-            :name            => options[:name],
-            :type            => "application/vnd.tmrk.cloud.detachedDisk",
-            :Links => {
-              :Link => [
-                Fog::Ecloud.keep(compute_pool, :href, :name, :type),
-              ],
-            },
-            :Description => options[:description],
-            :LastKnownVirtualMachineConfiguration => Fog::Ecloud.keep(server, :name, :ProcessorCount, :Memory, :OperatingSystem),
-            :Type => "Data",
-            :Size => {
-              :Unit  => "GB",
-              :Value => options[:disk][:Size][:Value],
-            },
-            :Status => "Available",
-          }
-
-          server[:HardwareConfiguration][:Disks][:Disk].delete_if { |disk| disk[:Index] == options[:disk][:Index] }
-
-          detached_disk_response = response(:body => detached_disk)
-
-          detached_disk.merge!(:compute_pool_id => compute_pool_id)
-
-          self.data[:detached_disks][detached_disk_id] = detached_disk
-
-          detached_disk_response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/requests/compute/virtual_machine_edit.rb

@@ -1,45 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def validate_edit_server_options(options)
-          required_opts = [:name]
-          unless required_opts.all? { |opt| options.key?(opt) }
-            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
-          end
-        end
-
-        def build_request_body_edit(options)
-          xml = Builder::XmlMarkup.new
-          xml.VirtualMachine(:name => options[:name]) do
-            if options[:description]
-              xml.Description options[:description]
-            end
-            if options[:tags]
-              xml.Tags do
-                options[:tags].each do |tag|
-                  xml.Tag tag
-                end
-              end
-            end
-          end
-        end
-      end
-
-      class Real
-        def virtual_machine_edit(vm_uri, options)
-          validate_edit_server_options(options)
-          body = build_request_body_edit(options)
-          request(
-            :expects => [202,204],
-            :method => 'PUT',
-            :headers => {},
-            :body => body,
-            :uri => vm_uri,
-            :parse => true
-          )
-        end
-      end
-    end
-  end
-end