fog 1.25.0 → 1.26.0

data/lib/fog/ecloud/models/compute/organizations.rb

@@ -1,38 +0,0 @@
-require 'fog/ecloud/models/compute/organization'
-
-module Fog
-  module Compute
-    class Ecloud
-      class Organizations < Fog::Ecloud::Collection
-        model Fog::Compute::Ecloud::Organization
-
-        undef_method :create
-
-        identity :href
-
-        def all
-          data = service.get_organizations(organization_uri).body
-          load(data[:Organization])
-        end
-
-        def get(uri)
-          if data = service.get_organization(uri)
-            new(data.body)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-        def organization_uri
-          @organization_uri ||= service.default_organization_uri
-        end
-
-        private
-
-        def organization_uri=(new_organization_uri)
-          @organization_uri = new_organization_uri
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/password_complexity_rule.rb

@@ -1,49 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class PasswordComplexityRule < Fog::Ecloud::Model
-        identity :href
-
-        attribute :rule_type, :aliases => :RuleType
-        attribute :custom_rules, :aliases => :CustomRules
-        attribute :description, :aliases => :Description
-
-        def minimum_characters
-          custom_rules[:MinimumCharacters]
-        end
-
-        def minimum_upper_case_characters
-          custom_rules[:MinimumUpperCaseCharacters]
-        end
-
-        def minimum_lower_case_characters
-          custom_rules[:MinimumLowerCaseCharacters]
-        end
-
-        def minimum_numeric_characters
-          custom_rules[:MinimumNumericCharacters]
-        end
-
-        def minimum_special_characters
-          custom_rules[:MinimumSpecialCharacters]
-        end
-
-        def maximum_consecutive_characters_from_prior_password
-          custom_rules[:MaximumConsecutiveCharactersFromPriorPassword]
-        end
-
-        def minimum_lifetime_restriction
-          custom_rules[:MinimumLifetimeRestriction]
-        end
-
-        def minimum_generations_before_reuse
-          custom_rules[:MinimumGenerationsBeforeReuse]
-        end
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/password_complexity_rules.rb

@@ -1,26 +0,0 @@
-require 'fog/ecloud/models/compute/password_complexity_rule'
-
-module Fog
-  module Compute
-    class Ecloud
-      class PasswordComplexityRules < Fog::Ecloud::Collection
-        identity :href
-
-        model Fog::Compute::Ecloud::PasswordComplexityRule
-
-        def all
-          data = service.get_password_complexity_rules(href).body
-          load(data)
-        end
-
-        def get(uri)
-          if data = service.get_password_complexity_rule(uri)
-            new(data.body)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/physical_device.rb

@@ -1,21 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class PhysicalDevice < Fog::Ecloud::Model
-        identity :href
-
-        attribute :name, :aliases => :Name
-        attribute :type, :aliases => :Type
-        attribute :tags, :aliases => :Tags
-        attribute :layout, :aliases => :Layout
-        attribute :network_host, :aliases => :NetworkHost
-        attribute :classification, :aliases => :Classification
-        attribute :model, :aliases => :Model
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/physical_devices.rb

@@ -1,26 +0,0 @@
-require 'fog/ecloud/models/compute/physical_device'
-
-module Fog
-  module Compute
-    class Ecloud
-      class PhysicalDevices < Fog::Ecloud::Collection
-        identity :href
-
-        model Fog::Compute::Ecloud::PhysicalDevice
-
-        def all
-          data = service.get_physical_devices(href).body[:PhysicalDevice] || []
-          load(data)
-        end
-
-        def get(uri)
-          if data = service.get_physical_device(uri)
-            new(data.body)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/public_ip.rb

@@ -1,26 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class PublicIp < Fog::Ecloud::Model
-        identity :href
-
-        attribute :name, :aliases => :Name
-        attribute :type, :aliases => :Type
-        attribute :other_links, :aliases => :Links
-        attribute :ip_type, :aliases => :IpType
-
-        def internet_services
-          @internet_services = Fog::Compute::Ecloud::InternetServices.new(:service => service, :href => href)
-        end
-
-        def environment_id
-          other_links[:Link].find { |l| l[:type] == "application/vnd.tmrk.cloud.environment" }[:href].scan(/\d+/)[0]
-        end
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/public_ips.rb

@@ -1,31 +0,0 @@
-require 'fog/ecloud/models/compute/public_ip'
-
-module Fog
-  module Compute
-    class Ecloud
-      class PublicIps < Fog::Ecloud::Collection
-        identity :href
-
-        model Fog::Compute::Ecloud::PublicIp
-
-        def all
-          data = service.get_public_ips(href).body
-          data = data[:PublicIp] ? data[:PublicIp] : data
-          load(data)
-        end
-
-        def get(uri)
-          data = service.get_public_ip(uri).body
-          new(data)
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-        def activate
-          data = service.public_ip_activate(href + "/action/activatePublicIp").body
-          ip = Fog::Compute::Ecloud::PublicIps.new(:service => service, :href => data[:href])[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/rnat.rb

@@ -1,27 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Rnat < Fog::Ecloud::Model
-        identity :href
-
-        attribute :name, :aliases => :Name
-        attribute :type, :aliases => :Type
-        attribute :other_links, :aliases => :Links
-        attribute :default, :aliases => :Default, :type => :boolean
-        attribute :public_ip, :aliases => :PublicIp
-
-        def networks
-          @networks = Fog::Compute::Ecloud::Networks.new(:service => service, :href => href)
-        end
-
-        def associations
-          @associations = Fog::Compute::Ecloud::Associations.new(:service => service, :href => href)
-        end
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/rnats.rb

@@ -1,26 +0,0 @@
-require 'fog/ecloud/models/compute/rnat'
-
-module Fog
-  module Compute
-    class Ecloud
-      class Rnats < Fog::Ecloud::Collection
-        identity :href
-
-        model Fog::Compute::Ecloud::Rnat
-
-        def all
-          data = service.get_rnats(href).body[:Rnats][:Rnat]
-          load(data)
-        end
-
-        def get(uri)
-          if data = service.get_rnat(uri)
-            new(data.body)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/role.rb

@@ -1,23 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Role < Fog::Ecloud::Model
-        identity :href
-
-        attribute :name, :aliases => :Name
-        attribute :environment_name, :aliases => :EnvironmentName
-        attribute :type, :aliases => :Type
-        attribute :other_links, :aliases => :Links
-        attribute :role_type, :aliases => :RoleType
-        attribute :active, :aliases => :Active, :type => :boolean
-        attribute :category, :aliases => :Category
-        attribute :is_admin, :aliases => :IsAdmin, :type => :boolean
-        attribute :business_operations, :aliases => :BusinessOperations
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/roles.rb

@@ -1,36 +0,0 @@
-require 'fog/ecloud/models/compute/role'
-
-module Fog
-  module Compute
-    class Ecloud
-      class Roles < Fog::Ecloud::Collection
-        identity :href
-
-        model Fog::Compute::Ecloud::Role
-
-        def all
-          data = service.get_roles(href).body
-          if data[:OrganizationRole]
-            load(data[:OrganizationRole])
-          else
-            r_data = []
-            data[:EnvironmentRoles][:EnvironmentRole].each do |d|
-              d[:Environment][:EnvironmentName] = d[:Environment][:name]
-              d[:Environment] = d[:Environment].merge(d[:Role]) if d[:Role]
-              r_data << d[:Environment]
-            end
-            load(r_data)
-          end
-        end
-
-        def get(uri)
-          if data = service.get_role(uri)
-            new(data.body)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/row.rb

@@ -1,56 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Row < Fog::Ecloud::Model
-        identity :href
-
-        attribute :name, :aliases => :Name
-        attribute :type, :aliases => :Type
-        attribute :other_links, :aliases => :Links
-        attribute :index, :aliases => :Index
-
-        def groups
-          @groups = self.service.groups(:href => href)
-        end
-
-        def edit(options)
-          options[:uri] = href
-          service.rows_edit(options).body
-        end
-
-        def move_up(options)
-          options[:uri] = href + "/action/moveup"
-          service.rows_moveup(options).body
-        end
-
-        def move_down(options)
-          options[:uri] = href + "/action/movedown"
-          service.rows_movedown(options).body
-        end
-
-        def delete
-          service.rows_delete(href).body
-        end
-
-        def create_group(options = {})
-          options[:uri] = "#{service.base_path}/layoutGroups/environments/#{environment_id}/action/createLayoutGroup"
-          options[:row_name] = name
-          options[:href] = href
-          data = service.groups_create(options).body
-          group = self.service.groups.new(data)
-        end
-
-        def environment_id
-          reload if other_links.nil?
-          other_links[:Link][:href].scan(/\d+/)[0]
-        end
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-
-        alias_method :destroy, :delete
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/rows.rb

@@ -1,39 +0,0 @@
-require 'fog/ecloud/models/compute/row'
-
-module Fog
-  module Compute
-    class Ecloud
-      class Rows < Fog::Ecloud::Collection
-        identity :href
-
-        model Fog::Compute::Ecloud::Row
-
-        def all
-          data = service.get_layout(href).body[:Rows][:Row]
-          load(data)
-        end
-
-        def get(uri)
-          data = service.get_row(uri).body
-          if data == ""
-            nil
-          else
-            new(data)
-          end
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-        def create(options = {})
-          options[:uri] = "#{service.base_path}/layoutRows/environments/#{environment_id}/action/createLayoutRow"
-          data = service.rows_create(options).body
-          new(data)
-        end
-
-        def environment_id
-          href.scan(/\d+/)[0]
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/server.rb

@@ -1,323 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Server < Fog::Ecloud::Model
-        extend Forwardable
-
-        identity :href
-
-        attribute :description,            :aliases => :Description
-        attribute :hardware_configuration, :aliases => :HardwareConfiguration
-        attribute :ip_addresses,           :aliases => :IpAddresses, :squash => :AssignedIpAddresses
-        attribute :layout,                 :aliases => :Layout
-        attribute :name,                   :aliases => :Name
-        attribute :operating_system,       :aliases => :OperatingSystem
-        attribute :other_links,            :aliases => :Links, :squash => :Link
-        attribute :powered_on,             :aliases => :PoweredOn, :type => :boolean
-        attribute :status,                 :aliases => :Status
-        attribute :tags,                   :aliases => :Tags
-        attribute :tools_status,           :aliases => :ToolsStatus
-        attribute :type,                   :aliases => :Type
-
-        def cpus
-          hardware_configuration.processor_count
-        end
-
-        def memory # always in MB
-          hardware_configuration.memory.to_i
-        end
-
-        def location
-        end
-
-        def flavor_id
-          {:ram => hardware_configuration.memory.to_i, :cpus => hardware_configuration.processor_count}
-        end
-
-        def storage
-          hardware_configuration.storage[:Disk]
-        end
-
-        def tasks
-          @tasks ||= self.service.tasks(:href => "#{service.base_path}/tasks/virtualMachines/#{id}")
-        end
-
-        def processes
-          @processes ||= Fog::Compute::Ecloud::GuestProcesses.new(:service, service, :href => "#{service.base_path}/virtualMachines/#{id}/guest/processes")
-        end
-
-        def hardware_configuration=(hardware_configuration)
-          @hardware_configuration = self.service.hardware_configurations.new(hardware_configuration)
-        end
-
-        def hardware_configuration
-          @hardware_configuration ||= self.service.hardware_configurations.new(:href => "#{service.base_path}/virtualMachines/#{id}/hardwareConfiguration")
-          @hardware_configuration.reload
-        end
-
-        def configuration
-          @configuration ||= Fog::Compute::Ecloud::ServerConfigurationOptions.new(:service => service, :href => "#{service.base_path}/virtualMachines/#{id}/configurationOptions")[0]
-        end
-
-        def ips
-          @ips = self.service.virtual_machine_assigned_ips(:virtual_machine_id => self.id)
-        end
-
-        def networks
-          @networks ||= self.service.networks(:href => "#{service.base_path}/virtualMachines/#{id}/assignedIps")
-        end
-
-        def power_on
-          power_operation( :power_on => :powerOn )
-        end
-
-        def power_off
-          power_operation( :power_off => :powerOff )
-        end
-
-        def shutdown
-          power_operation( :power_shutdown => :shutdown )
-        end
-
-        def power_reset
-          power_operation( :power_reset => :reboot )
-        end
-
-        def delete
-          data = service.virtual_machine_delete(href).body
-          self.service.tasks.new(data)
-        end
-
-        def copy(options = {})
-          options = {:type => :copy}.merge(options)
-          options[:source] ||= href
-          if options[:type] == :copy
-            options[:cpus] ||= 1
-            options[:memory] ||= 512
-            options[:customization] ||= :linux
-            options[:tags] ||= []
-            options[:powered_on] ||= false
-            if options[:ips]
-              options[:ips] = options[:ips].is_a?(String) ? [options[:ips]] : options[:ips]
-            else
-              options[:network_uri] = options[:network_uri].is_a?(String) ? [options[:network_uri]] : options[:network_uri]
-              options[:network_uri].each do |uri|
-                index = options[:network_uri].index(uri)
-                ip = Fog::Compute::Ecloud::IpAddresses.new(:service => service, :href => uri).find { |i| i.host == nil }.name
-                options[:ips] ||= []
-                options[:ips][index] = ip
-              end
-            end
-            data = service.virtual_machine_copy("#{service.base_path}/virtualMachines/computePools/#{compute_pool_id}/action/copyVirtualMachine", options).body
-          elsif options[:type] == :identical
-            data = service.virtual_machine_copy_identical("#{service.base_path}/virtualMachines/computePools/#{compute_pool_id}/action/copyIdenticalVirtualMachine", options).body
-          end
-          vm = collection.from_data(data)
-          vm
-        end
-
-        def rnats
-          rnats = Fog::Compute::Ecloud::Rnats.new(:service => service, :href => "#{service.base_path}/rnats/environments/#{environment_id}")
-          associations = nil
-          rnats.each do |rnat|
-            if rnats.index(rnat) == 0
-              associations = rnat.associations.select do |association|
-                ips.any? do |ip|
-                  association.name == ip.name
-                end
-              end
-            else
-              rnat.associations.select do |association|
-                ips.each do |ip|
-                  if ip.name == association.name
-                    associations << association
-                  end
-                end
-              end
-            end
-          end
-          associations
-        end
-
-        def edit(options = {})
-          data = service.virtual_machine_edit(href, options).body
-          if data[:type] == "application/vnd.tmrk.cloud.task"
-            task = Fog::Compute::Ecloud::Tasks.new(:service => service, :href => data[:href])[0]
-          end
-        end
-
-        def create_rnat(options)
-          options[:host_ip_href] ||= ips.first.href
-          options[:uri] = "#{service.base_path}/rnats/environments/#{environment_id}/action/createAssociation"
-          data = service.rnat_associations_create_device(options).body
-          rnat = Fog::Compute::Ecloud::Associations.new(:service => service, :href => data[:href])[0]
-        end
-
-        def disks
-          c = hardware_configuration.reload.storage
-          c = c.is_a?(Hash) ? [c] : c
-          @disks = c
-        end
-
-        def add_disk(size)
-          index = disks.map { |d| d[:Index].to_i }.sort[-1] + 1
-          vm_disks = disks << {:Index => index.to_s, :Size=>{:Unit => "GB", :Value => size.to_s}, :Name => "Hard Disk #{index + 1}"}
-          data = service.virtual_machine_edit_hardware_configuration(href + "/hardwareConfiguration", _configuration_data(:disks => vm_disks)).body
-          task = self.service.tasks.new(data)
-        end
-
-        def detach_disk(index)
-          options               = {}
-          options[:disk]        = disks.find { |disk_hash| disk_hash[:Index] == index.to_s }
-          options[:name]        = self.name
-          options[:description] = self.description
-          data                  = service.virtual_machine_detach_disk(href + "/hardwareconfiguration/disks/actions/detach", options).body
-          detached_disk         = self.service.detached_disks.new(data)
-        end
-
-        def attach_disk(detached_disk)
-          options        = {}
-          options[:name] = detached_disk.name
-          options[:href] = detached_disk.href
-          data           = service.virtual_machine_attach_disk(href + "/hardwareconfiguration/disks/actions/attach", options).body
-          task           = self.service.tasks.new(data)
-        end
-
-        def delete_disk(index)
-          vm_disks = disks.delete_if { |h| h[:Index] == index.to_s }
-          data     = service.virtual_machine_edit_hardware_configuration(href + "/hardwareconfiguration", _configuration_data(:disks => vm_disks)).body
-          task     = self.service.tasks.new(data)
-        end
-
-        def nics
-          c = hardware_configuration.network_cards
-          c = c.is_a?(Hash) ? [c] : c
-          @nics = c
-        end
-
-        def add_nic(network)
-          unit_number = nics.map { |n| n[:UnitNumber].to_i }.sort[-1] + 1
-          vm_nics = nics << {:UnitNumber => unit_number, :Network => {:href => network.href, :name => network.name, :type => "application/vnd.tmrk.cloud.network"}}
-          data = service.virtual_machine_edit_hardware_configuration(href + "/hardwareConfiguration", _configuration_data(:nics => vm_nics)).body
-          task = self.service.tasks.new(:href => data[:href])[0]
-        end
-
-        def add_ip(options)
-          slice_ips = begin
-                        ips
-                      rescue
-                        []
-                      end
-          slice_networks = if slice_ips.empty?
-                             []
-                           else
-                             ips.map { |ip| {:href => ip.network.href, :name => ip.network.name.split(' ')[0], :type => ip.network.type} }.push({:href => options[:href], :name => options[:network_name], :type => "application/vnd.tmrk.cloud.network"}).uniq
-                           end
-          slice_ips = slice_ips.map { |i| {:name => i.address.name, :network_name => i.network.name} }.push({:name => options[:ip], :network_name => options[:network_name]}).uniq
-          slice_ips.each do |ip|
-            slice_networks.each do |network|
-              if network[:name] == ip[:network_name]
-                network[:ips] ||= []
-                network[:ips].push(ip[:name])
-              end
-            end
-          end
-          data = service.virtual_machine_edit_assigned_ips(href + "/assignedIps", slice_networks).body
-          task = self.service.tasks.new(data)
-        end
-
-        def delete_ip(options)
-          slice_ips = begin
-                        ips
-                      rescue
-                        []
-                      end
-          slice_networks = if slice_ips.empty?
-                             []
-                           else
-                             ips.map do |ip|
-                               {
-                                 :href => ip.network.href,
-                                 :name => ip.network.name.split(' ')[0],
-                                 :type => ip.network.type,
-                               }
-                             end#.delete_if { |ip| ip[:href] == options[:href] && ip[:name] == options[:network_name] }
-                           end
-          slice_ips.map! { |i| {:name => i.address.name, :network_name => i.network.name, :network_name => i.network.name } }.delete_if { |ip| ip[:name] == options[:ip] }
-          slice_ips.each do |ip|
-            slice_networks.each do |network|
-              if network[:name] == ip[:network_name]
-                network[:ips].delete(ip[:name])
-              end
-            end
-          end
-          data = service.virtual_machine_edit_assigned_ips(href + "/assignedips", slice_networks).body
-          task = self.service.tasks.new(data)
-        end
-
-        def upload_file(options)
-          service.virtual_machine_upload_file(href + "/guest/action/files", options)
-          true
-        end
-
-        def storage_size
-          vm_disks = disks
-          disks.map! { |d| d[:Size][:Value].to_i }.reduce(0){|sum,item| sum + item} * 1024 * 1024
-        end
-
-        def ready?
-          load_unless_loaded!
-          unless status =~ /NotDeployed|Orphaned|TaskInProgress|CopyInProgress/
-            true
-          else
-            false
-          end
-        end
-
-        def on?
-          powered_on == true
-        end
-
-        def off?
-          powered_on == false
-        end
-
-        def compute_pool_id
-          other_links.find { |l| l[:type] == "application/vnd.tmrk.cloud.computePool" }[:href].scan(/\d+/)[0]
-        end
-
-        def compute_pool
-          reload if other_links.nil?
-          @compute_pool = self.service.compute_pools.new(:href => other_links.find { |l| l[:type] == "application/vnd.tmrk.cloud.computePool" }[:href])
-        end
-
-        def environment_id
-          other_links.find { |l| l[:type] == "application/vnd.tmrk.cloud.environment" }[:href].scan(/\d+/)[0]
-        end
-
-        def id
-          href.scan(/\d+/)[0]
-        end
-
-        private
-
-        def _configuration_data(options = {})
-          {:cpus => (options[:cpus] || hardware_configuration.processor_count), :memory => (options[:memory] || hardware_configuration.memory), :disks => (options[:disks] || disks), :nics => (options[:nics] || nics)}
-        end
-
-        def power_operation(op)
-          requires :href
-          begin
-            service.send(op.keys.first, href + "/action/#{op.values.first}" )
-          rescue Excon::Errors::Conflict => e
-            #Frankly we shouldn't get here ...
-            raise e unless e.to_s =~ /because it is already powered o(n|ff)/
-          end
-          true
-        end
-
-        alias_method :destroy, :delete
-      end
-    end
-  end
-end