fog 1.25.0 → 1.26.0

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

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

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

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

@@ -1,28 +0,0 @@
-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/storm_on_demand.rb

@@ -1,9 +0,0 @@
-require 'fog/storm_on_demand/account'
-require 'fog/storm_on_demand/billing'
-require 'fog/storm_on_demand/compute'
-require 'fog/storm_on_demand/dns'
-require 'fog/storm_on_demand/monitoring'
-require 'fog/storm_on_demand/network'
-require 'fog/storm_on_demand/storage'
-require 'fog/storm_on_demand/support'
-require 'fog/storm_on_demand/vpn'

data/lib/fog/storm_on_demand/README.md

@@ -1,49 +0,0 @@
-# StormOnDemand services examples
-
-This storm_on_demand directory provides code for all storm on demand cloud APIs. All of the APIs are seperated into Compute, Network, Storage, DNS, Monitoring, Account, Billing, Support and Billing services.
-
-
-## Use a service
-Before using APIs of a service, you need to create a service object first. Take Compute for instance:
-
-		c = Fog::Compute.new :provider => :stormondemand,
-							 :storm_on_demand_username => 'username',
-							 :storm_on_demand_password => 'password'
-Now, you can call API methods for Compute service. For instance:
-
-		c.servers.all
-this will list all servers for the current account.
-
-## Call an API method
-According to Fog, a high level interface is provided through collections, such as images and servers. Each collection has a corresponding model, such as image and server.
-
-APIs like create, list or details reside in the collections. For instance:
-
-		server = c.servers.create :config_id => conf.id,
-								  :template => tpl.name,
-								  :domain => 'example.com',
-								  :password => 'rootpassword'
-Other APIs for specific cloud object will reside in a model. For instance:
-
-		server.reboot :force => 1
-
-All APIs' parameters are the same with the [Storm On Demand API Doc](https://www.stormondemand.com/api/docs/v1/).
-
-#### (p.s. In order to conform to Fog's CRUD operations, some API methods are changed. For instance, 'list' methods are now 'all', 'details' methods are now 'get')
-
-
-## Use a Token
-If you want to use a token instead of password for API calls, instead of creating a new service like Compute, you should create a new Account first and get the token. Then create a new Compute/Network/Storage with the token.
-
-		account = Fog::Account.new :provider => :stormondemand,
-								   :storm_on_demand_username => 'username',
-							       :storm_on_demand_password => 'password'
-		# create a new token
-		token = account.tokens.create
-		# use the token instead of a password
-		net = Fog::Network.new :provider => :stormondemand,
-							   :storm_on_demand_username = 'username',
-							   :storm_on_demand_password = token.token
-		
-		# if you want to expire the token
-		token.expire

data/lib/fog/storm_on_demand/account.rb

@@ -1,51 +0,0 @@
-require 'fog/storm_on_demand/core'
-require 'fog/storm_on_demand/shared'
-
-module Fog
-  module Account
-    class StormOnDemand < Fog::Service
-      requires :storm_on_demand_username, :storm_on_demand_password
-      recognizes :storm_on_demand_auth_url
-
-      model_path 'fog/storm_on_demand/models/account'
-      model      :token
-      collection :tokens
-
-      request_path 'fog/storm_on_demand/requests/account'
-      request :create_token
-      request :expire_token
-
-      class Mock
-        def self.data
-          @data ||= Hash.new
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def self.reset_data(keys=data.keys)
-          for key in [*keys]
-            data.delete(key)
-          end
-        end
-
-        def initialize(options={})
-          @storm_on_demand_username = options[:storm_on_demand_username]
-        end
-
-        def data
-          self.class.data[@storm_on_demand_username]
-        end
-
-        def reset_data
-          self.class.data.delete(@storm_on_demand_username)
-        end
-      end
-
-      class Real
-        include Fog::StormOnDemand::RealShared
-      end
-    end
-  end
-end