fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

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

@@ -6,6 +6,30 @@ module Fog
         basic_request :node_service_delete, 202, 'DELETE'
       end
 
+      class Mock
+        def node_service_delete(uri)
+
+          service_id = id_from_uri(uri)
+
+          service = self.data[:node_services][service_id].dup
+          self.data[:node_services].delete(service_id)
+
+          task_id = Fog::Mock.random_numbers(10).to_i
+          task = {
+            :id            => task_id,
+            :href          => "/cloudapi/ecloud/tasks/#{task_id}",
+            :type          => "application/vnd.tmrk.cloud.task",
+            :Operation     => "Delete Node Service",
+            :Status        => "Complete",
+            :ImpactedItem  => Fog::Ecloud.keep(service, :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/rows_delete.rb

@@ -1,11 +1,21 @@
 module Fog
   module Compute
     class Ecloud
-
       class Real
         basic_request :rows_delete, 204, 'DELETE'
       end
 
+      class Mock
+        def rows_delete(uri)
+          row_id = id_from_uri(uri)
+          self.data[:rows].delete(row_id)
+          self.data[:layouts].values.each do |layout|
+            layout[:Rows][:Row].delete_if { |r| r[:id] == row_id }
+          end
+
+          response(:body =>  nil, :status => 204)
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,62 @@
+module Fog
+  module Compute
+    class Ecloud
+      module Shared
+
+        def build_request_body_attach_disk(options)
+          xml = Builder::XmlMarkup.new
+          xml.AttachDisks(:name => options[:name]) do
+            xml.DetachedDisks do
+              xml.DetachedDisk(:href => options[:href], :name => options[:name], :type => "application/vnd.tmrk.cloud.detachedDisk")
+            end
+          end
+        end
+      end
+
+      class Real
+        def virtual_machine_attach_disk(href, options)
+          body = build_request_body_attach_disk(options)
+          request(
+            :expects => 202,
+            :method => 'POST',
+            :headers => {},
+            :body => body,
+            :uri => href,
+            :parse => true
+          )
+        end
+      end
+
+      class Mock
+        def virtual_machine_attach_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 = options[:href].match(/(\d+)/)[1].to_i
+          detached_disk    = self.data[:detached_disks][detached_disk_id]
+          new_index        = (server[:HardwareConfiguration][:Disks][:Disk].map { |h| h[:Index].to_i }.sort.last + 1).to_s
+          detached_disk[:Index] = new_index
+          server[:HardwareConfiguration][:Disks][:Disk] << Fog::Ecloud.keep(detached_disk, :Index, :Size, :Name)
+
+          self.data[:detached_disks].delete(detached_disk_id)
+
+          task_id = Fog::Mock.random_numbers(10).to_i
+          task = {
+            :id            => task_id,
+            :href          => "/cloudapi/ecloud/tasks/#{task_id}",
+            :type          => "application/vnd.tmrk.cloud.task",
+            :Operation     => "Attach Disk",
+            :Status        => "Complete",
+            :ImpactedItem  => Fog::Ecloud.keep(server, :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_create_from_template.rb

@@ -14,12 +14,6 @@ module Fog
             raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
           end
 
-          if template_uri.scan(/\/catalog\/\d+/)[0]
-            options[:template_type] = get_catalog_item(template_uri).body[:type]
-          elsif template_uri.scan(/\/templates\/\d+/)[0]
-            options[:template_type] = get_template(template_uri).body[:type]
-          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
@@ -27,7 +21,7 @@ module Fog
               ip = options[:ips][options[:network_uri].index(uri)]
             end
             {:href => uri, :name => network[:name], :ip => ip}
-          end 
+          end
           options[:template_uri] = template_uri
           options
         end
@@ -82,7 +76,7 @@ module Fog
                     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.Network(:href => uri[:href], :name => uri[:name], :type => "application/vnd.tmrk.cloud.network")
                         xml.IpAddress uri[:ip]
                       end
                     end
@@ -95,31 +89,157 @@ module Fog
                       end
                     end
                   end
-                end                
+                end
               end
               xml.SshKey(:href => options[:ssh_key_uri])
             end
             xml.PoweredOn options[:powered_on]
-            xml.Template(:href => options[:template_uri], :type => options[:template_type]) 
+            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',
-            :headers => {},
-            :body => build_request_body(options),
-            :uri => options[:uri],
-            :parse => true
+            :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].detect { |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,11 +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,71 @@
+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_assigned_ips.rb

@@ -0,0 +1,82 @@
+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].detect { |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