fog-ecloud 0.0.1

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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,45 @@
+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

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

@@ -0,0 +1,80 @@
+module Fog
+  module Compute
+    class Ecloud
+      module Shared
+        def build_request_body_edit_assigned_ips(networks)
+          xml = Builder::XmlMarkup.new
+          xml.AssignedIpAddresses do
+            xml.Networks do
+              networks.each do |network|
+                xml.Network(:href => network[:href], :type => network[:type]) do
+                  xml.IpAddresses do
+                    network[:ips].each do |ip|
+                      xml.IpAddress ip
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      class Real
+        def virtual_machine_edit_assigned_ips(href, options)
+          body = build_request_body_edit_assigned_ips(options)
+          request(
+            :expects => 202,
+            :method => 'PUT',
+            :headers => {},
+            :body => body,
+            :uri => href,
+            :parse => true
+          )
+        end
+      end
+
+      class Mock
+        def virtual_machine_edit_assigned_ips(href, options)
+          server_id       = href.match(/(\d+)/)[1].to_i
+          server          = self.data[:servers][server_id]
+          options.each do |network|
+            network_id     = id_from_uri(network[:href])
+            network        = self.data[:networks][network_id]
+            options.each.each do |net|
+              net[:ips].each do |ip|
+                ip = network[:IpAddresses][:IpAddress].find { |iph| iph[:name] == ip }
+                ip[:Host] = {
+                  :href => "/clouapi/ecloud/networkhosts/#{server_id}",
+                  :name => server[:name],
+                  :type => "application/vnd.tmrk.cloud.networkHost"
+                }
+                ip[:DetectedOn] = {
+                  :href => "/clouapi/ecloud/networkhosts/#{server_id}",
+                  :name => server[:name],
+                  :type => "application/vnd.tmrk.cloud.networkHost"
+                }
+              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_edit_hardware_configuration.rb

@@ -0,0 +1,75 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        def virtual_machine_edit_hardware_configuration(vm_uri, data)
+          validate_data([:cpus, :memory, :disks, :nics], data)
+          body = build_request_body_edit_hardware_configuration(data)
+          request(
+            :expects => 202,
+            :method => 'PUT',
+            :headers => {},
+            :body => body,
+            :uri => vm_uri,
+            :parse => true
+          )
+        end
+
+        def build_request_body_edit_hardware_configuration(data)
+          xml = Builder::XmlMarkup.new
+          xml.HardwareConfiguration do
+            xml.ProcessorCount data[:cpus]
+            xml.Memory do
+              xml.Unit "MB"
+              xml.Value data[:memory]
+            end
+            xml.Disks do
+              data[:disks].each do |disk|
+                xml.Disk do
+                  xml.Index disk[:Index]
+                  xml.Size do
+                    xml.Unit "GB"
+                    xml.Value disk[:Size][:Value]
+                  end
+                end
+              end
+            end
+            xml.Nics do
+              data[:nics].each do |nic|
+                xml.Nic do
+                  xml.UnitNumber nic[:UnitNumber]
+                  xml.MacAddress nic[:MacAddress]
+                  xml.Network(:href => nic[:Network][:href], :name => nic[:Network][:name], :type => "application/vnd.tmrk.cloud.network") do
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      class Mock
+        def virtual_machine_edit_hardware_configuration(vm_uri, data)
+          server_id = vm_uri.match(/(\d+)/)[1]
+
+          server  = self.data[:servers][server_id.to_i]
+          task_id = Fog::Mock.random_numbers(10)
+          task = {
+            :id            => task_id,
+            :href          => "/cloudapi/ecloud/tasks/#{task_id}",
+            :type          => "application/vnd.tmrk.cloud.task",
+            :Operation     => "Configure 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_import.rb

@@ -0,0 +1,179 @@
+module Fog
+  module Compute
+    class Ecloud
+      module Shared
+        def validate_import_server_options(template_uri, options)
+          required_opts = [:name, :cpus, :memory, :row, :group, :network_uri, :catalog_network_name]
+          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]]
+          options[:template_uri] = template_uri
+          options
+        end
+
+        def build_request_body_import(options)
+          xml = Builder::XmlMarkup.new
+          xml.ImportVirtualMachine(: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]
+            if options[:tags]
+              xml.Tags do
+                options[:tags].each do |tag|
+                  xml.Tag tag
+                end
+              end
+            end
+            xml.CatalogEntry(:href => options[:template_uri])
+            xml.NetworkMappings do
+              xml.NetworkMapping(:name => options[:catalog_network_name]) do
+                xml.Network(:href => options[:network_uri][0])
+              end
+            end
+            if options[:operating_system]
+              xml.OperatingSystem(:href => options[:operating_system][:href], :name => options[:operating_system][:name], :type => "application/vnd.tmrk.cloud.operatingSystem")
+            end
+          end
+        end
+      end
+
+      class Real
+        def virtual_machine_import(template_uri, options)
+          options = validate_import_server_options(template_uri, options)
+
+          request(
+            :expects => 201,
+            :method  => 'POST',
+            :body    => build_request_body_import(options),
+            :uri     => options[:uri],
+            :parse   => true
+          )
+        end
+      end
+
+      class Mock
+        def virtual_machine_import(template_uri, options)
+          options         = validate_import_server_options(template_uri, options)
+
+          compute_pool_id = options[:uri].match(/computePools\/(\d+)/)[1].to_i
+          compute_pool    = self.data[:compute_pools][compute_pool_id].dup
+          environment     = self.data[:environments][compute_pool[:environment_id]]
+          networks        = options[:network_uri].map{|nuri| self.data[:networks][id_from_uri(nuri)].dup}
+          server_id       = Fog::Mock.random_numbers(6).to_i
+          row_id          = Fog::Mock.random_numbers(6).to_i
+          group_id        = Fog::Mock.random_numbers(6).to_i
+          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{|network| links << Fog::Ecloud.keep(network, :name, :href, :type)}
+          server = {
+            :href        => "/cloudapi/ecloud/virtualmachines/#{server_id}",
+            :name        => options[:name],
+            :type        => "application/vnd.tmrk.cloud.virtualMachine",
+            :Description => options[:description],
+            :Status      => "Deployed",
+            :PoweredOn   => "false",
+            :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 => { # Default drive
+                :Disk => [{
+                  :Index => "0",
+                  :Name  => "Hard Disk 1",
+                  :Size  => {
+                    :Unit  => "GB",
+                    :Value => "25"
+                  },
+                }],
+              },
+              :Nics => {
+                :Nic => nics,
+              },
+            },
+            :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_upload_file.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class Ecloud
+      module Shared
+        def validate_upload_file_options(options)
+          required_opts = [:file, :path, :credentials]
+          unless required_opts.all? { |opt| options.key?(opt) }
+            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
+          end
+        end
+      end
+
+      class Real
+        def virtual_machine_upload_file(vm_uri, options)
+          validate_upload_file_options(options)
+          request(
+            :expects => 204,
+            :method => 'POST',
+            :headers => {'Content-Type' => 'application/octet-stream', 'X-Guest-User' => options[:credentials][:user], 'X-Guest-Password' => options[:credentials][:password], 'Content-Range' => "0-#{options[:file].bytesize - 1}/#{options[:file].bytesize}"},
+            :body => options[:file],
+            :uri => vm_uri + "?path=#{options[:path]}",
+            :parse => true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  module Ecloud
+    VERSION = "0.0.1"
+  end
+end

data/lib/fog/ecloud.rb

@@ -0,0 +1,8 @@
+require 'fog/ecloud/version'
+require 'fog/ecloud/compute'
+
+module Fog
+  module Ecloud
+    # Your code goes here...
+  end
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,31 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'turn'
+
+Turn.config do |c|
+  # use one of output formats:
+  # :outline  - turn's original case/test outline mode [default]
+  # :progress - indicates progress with progress bar
+  # :dotted   - test/unit's traditional dot-progress mode
+  # :pretty   - new pretty reporter
+  # :marshal  - dump output as YAML (normal run mode only)
+  # :cue      - interactive testing
+  # c.format  = :outline
+  # turn on invoke/execute tracing, enable full backtrace
+  c.trace   = 20
+  # use humanized test names (works only with :outline format)
+  c.natural = true
+end
+
+if ENV['COVERAGE']
+  require 'coveralls'
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end
+
+require File.join(File.dirname(__FILE__), '../lib/fog/ecloud.rb')
+
+Coveralls.wear! if ENV['COVERAGE']

data/tests/compute/helper.rb

@@ -0,0 +1,27 @@
+def compute_providers
+  {
+    :ecloud => {
+      :server_attributes => {
+        :name                 => "VM4",
+        :row                  => "Layout Row 1",
+        :group                => "Layout Group 1",
+        :catalog_network_name => "bridged",
+        :description          => "blarg",
+        :operating_system => {
+          :name =>  "Red Hat Enterprise Linux 5 (64-bit)",
+          :href => "/cloudapi/ecloud/operatingsystems/rhel5_64guest/computepools/963",
+        },
+        :organization_uri => 'organizations/9284920'
+      }.tap do |hash|
+        [:template_href, :network_uri,
+         :environment_name, :organization_uri].each do |k|
+          key = "ecloud_#{k}".to_sym
+          if Fog.credentials[key]
+            hash[k]= Fog.credentials[key]
+          end
+        end
+      end,
+      :mocked => true,
+    }
+  }
+end

data/tests/compute/models/admin_organization_tests.rb

@@ -0,0 +1,16 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | admin_organizations", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @admin_organization = @organization.admin
+
+  tests('#get').succeeds do
+    fetched_admin_organization = connection.get_admin_organization(@admin_organization.href)
+    returns(true) { !fetched_admin_organization.nil? }
+  end
+
+  tests('#ssh_keys').succeeds do
+    returns(true, "a list of SshKeys") { @admin_organization.ssh_keys.is_a?(Fog::Compute::Ecloud::SshKeys) }
+  end
+end

data/tests/compute/models/compute_pool_tests.rb

@@ -0,0 +1,17 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | compute_pools", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+
+  tests('#all').succeeds do
+    returns(false) { @environment.compute_pools.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    compute_pool = @environment.compute_pools.all.first
+    fetched_compute_pool = connection.compute_pools.get(compute_pool.href)
+    returns(true) { !fetched_compute_pool.nil? }
+  end
+end

data/tests/compute/models/detached_disk_tests.rb

@@ -0,0 +1,26 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | detached_disks", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization   = connection.organizations.first
+  @environment    = @organization.environments.first
+  @compute_pool   = @environment.compute_pools.first
+  @detached_disks = @compute_pool.detached_disks
+
+  tests('#all').succeeds do
+    if @detached_disks.is_a?(Fog::Compute::Ecloud::DetachedDisks) && @detached_disks.reload.empty?
+      returns(true, "compute pool has no detached disks") { @detached_disks.all.empty? }
+    else
+      returns(false, "has detached disks") { @detached_disks.all.empty? }
+    end
+  end
+
+  unless @detached_disks.empty?
+    tests('#get') do
+      disk = @detached_disks.first
+      fetched_disk = connection.detached_disks.get(disk.href)
+      returns(false, "disk is not nil") { fetched_disk.nil? }
+      returns(true, "is a DetachedDisk") { fetched_disk.is_a?(Fog::Compute::Ecloud::DetachedDisk) }
+    end
+  end
+end