tecnh-fog 0.2.23.vpc

data/lib/fog/vcloud/terremark/ecloud/models/servers.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        class Servers < Fog::Vcloud::Collection
+
+          undef_method :create
+
+          model Fog::Vcloud::Terremark::Ecloud::Server
+
+          attribute :href, :aliases => :Href
+
+          def all
+            load(_vapps)
+          end
+
+          def get(uri)
+            if data = connection.get_vapp(uri)
+              new(data.body)
+            end
+          rescue Fog::Errors::NotFound
+            nil
+          end
+
+          def create( catalog_item_uri, options )
+            options[:vdc_uri] = href
+            options[:cpus] ||= 1
+            options[:memory] ||= 512
+            data = connection.instantiate_vapp_template( catalog_item_uri, options ).body
+            object = new(data)
+            object
+          end
+
+          private
+
+          def _resource_entities
+            connection.get_vdc(href).body[:ResourceEntities][:ResourceEntity]
+          end
+
+          def _vapps
+            resource_entities = _resource_entities
+            if resource_entities.nil?
+              []
+            else
+              resource_entities
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/models/task.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class Task < Fog::Vcloud::Model
+
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+          attribute :status
+          attribute :type
+          attribute :result, :aliases => :Result
+          attribute :owner, :aliases => :Owner
+          attribute :start_time, :aliases => :startTime, :type => :time
+          attribute :end_time, :aliases => :endTime, :type => :time
+          attribute :error, :aliases => :Error
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/models/tasks.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        class Tasks < Fog::Vcloud::Collection
+
+          model Fog::Vcloud::Terremark::Ecloud::Task
+
+          attribute :href, :aliases => :Href
+
+          def all
+            if data = connection.get_task_list(href).body[:Task]
+              load(data)
+            end
+          end
+
+          def get(uri)
+            if data = connection.get_task(uri)
+              new(data.body)
+            end
+          rescue Fog::Errors::NotFound
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/models/vdc.rb

@@ -0,0 +1,79 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class Vdc < Fog::Vcloud::Model
+
+          identity :href
+
+          ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd
+
+          attribute :name
+          attribute :type
+          attribute :description, :aliases => :Description
+          attribute :other_links, :aliases => :Link
+          attribute :compute_capacity, :aliases => :ComputeCapacity
+          attribute :storage_capacity, :aliases => :StorageCapacity
+          attribute :available_networks, :aliases => :AvailableNetworks, :squash => :Network
+          attribute :resource_entities, :aliases => :ResourceEntities, :squash => :ResourceEntity
+          attribute :deployed_vm_quota
+          attribute :instantiated_vm_quota
+
+          def public_ips
+            @public_ips ||= collection_based_on_type("application/vnd.tmrk.ecloud.publicIpsList+xml")
+          end
+
+          def internet_services
+            @internet_services ||= collection_based_on_type("application/vnd.tmrk.ecloud.internetServicesList+xml")
+          end
+
+          def networks
+            @networks ||= Fog::Vcloud::Terremark::Ecloud::Networks.
+              new( :connection => connection,
+                   :href => href )
+          end
+
+          def servers
+            @servers ||= Fog::Vcloud::Terremark::Ecloud::Servers.
+              new( :connection => connection,
+                   :href => href )
+          end
+
+          def tasks
+            @tasks ||= Fog::Vcloud::Terremark::Ecloud::Tasks.
+              new( :connection => connection,
+                   :href => href + "/tasksList" )
+          end
+
+          def catalog
+            @catalog ||= collection_based_on_type("application/vnd.vmware.vcloud.catalog+xml")
+          end
+
+          def firewall_acls
+            @firewall_acls ||= collection_based_on_type("application/vnd.tmrk.ecloud.firewallAclsList+xml")
+          end
+
+          private
+
+          def collection_based_on_type(type)
+            load_unless_loaded!
+            if link = other_links.detect { |link| link[:type] == type }
+              case type
+              when "application/vnd.tmrk.ecloud.publicIpsList+xml"
+                Fog::Vcloud::Terremark::Ecloud::PublicIps
+              when "application/vnd.tmrk.ecloud.internetServicesList+xml"
+                Fog::Vcloud::Terremark::Ecloud::InternetServices
+              when "application/vnd.vmware.vcloud.catalog+xml"
+                Fog::Vcloud::Terremark::Ecloud::Catalog
+              when "application/vnd.tmrk.ecloud.firewallAclsList+xml"
+                Fog::Vcloud::Terremark::Ecloud::FirewallAcls
+              end.new( :connection => connection, :href => link[:href] )
+            else
+              [ ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/models/vdcs.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+          def vdcs(options = {})
+            @vdcs ||= Fog::Vcloud::Terremark::Ecloud::Vdcs.new(options.merge(:connection => self))
+          end
+        end
+
+        #FIXME: Should be no need to do this ... duplicte code ... find a better way
+        module Mock
+          def vdcs(options = {})
+            @vdcs ||= Fog::Vcloud::Terremark::Ecloud::Vdcs.new(options.merge(:connection => self))
+          end
+        end
+        #/FIXME
+
+        class Vdcs < Fog::Vcloud::Vdcs
+
+          undef_method :create
+
+          model Fog::Vcloud::Terremark::Ecloud::Vdc
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/add_internet_service.rb

@@ -0,0 +1,140 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def generate_internet_service_request(service_data)
+            builder = Builder::XmlMarkup.new
+            builder.CreateInternetServiceRequest(:"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+                                                 :"xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+                                                 :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              builder.Name(service_data[:name])
+              builder.Protocol(service_data[:protocol])
+              builder.Port(service_data[:port])
+              builder.Enabled(service_data[:enabled])
+              builder.Description(service_data[:description])
+              builder.RedirectURL(service_data[:redirect_url])
+              if monitor = service_data[:monitor]
+                generate_monitor_section(builder,monitor)
+              end
+            }
+          end
+
+          def generate_monitor_section(builder, monitor)
+            builder.Monitor {
+              builder.MonitorType(monitor[:type])
+              builder.UrlSendString(monitor[:url_send_string])
+              builder.HttpHeader(monitor[:http_headers].join("\n"))
+              builder.ReceiveString(monitor[:receive_string])
+              builder.Interval(monitor[:interval])
+              builder.ResponseTimeOut(monitor[:response_timeout])
+              builder.DownTime(monitor[:downtime])
+              builder.Retries(monitor[:retries])
+              builder.IsEnabled(monitor[:is_enabled])
+            }
+          end
+
+          def validate_internet_service_data(service_data, configure=false)
+            required_opts = [:name, :protocol, :port, :description, :enabled]
+            if configure
+              required_opts + [ :id, :href, :timeout ]
+            end
+            unless required_opts.all? { |opt| service_data.keys.include?(opt) }
+              raise ArgumentError.new("Required Internet Service data missing: #{(required_opts - service_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+
+          def validate_internet_service_monitor(monitor)
+            #FIXME: Refactor this type of function into something generic
+            required_opts = [:type, :url_send_string, :http_headers, :receive_string, :is_enabled]
+
+            unless required_opts.all? { |opt| monitor.keys.include?(opt) && monitor[opt] }
+              raise ArgumentError.new("Required Monitor data missing: #{(required_opts - monitor.keys).map(&:inspect).join(", ")}")
+            end
+
+            unless ['HTTP','ECV'].include?(monitor[:type])
+              raise ArgumentError.new("Supported monitor types are: ECV & HTTP")
+            end
+
+            unless monitor[:http_headers].is_a?(Array) || monitor[:http_headers].is_a?(String)
+              raise ArgumentError.new("Monitor :http_headers must be a String or Array")
+            end
+
+            unless [true, false, "true", "false"].include?(monitor[:is_enabled])
+              raise ArgumentError.new("Monitor :is_enabled must be true or false")
+            end
+          end
+
+          def ensure_monitor_defaults!(monitor)
+            if monitor[:http_headers].is_a?(String)
+              monitor[:http_headers] = [ monitor[:http_headers] ]
+            end
+
+            unless monitor[:retries]
+              monitor[:retries] = 3
+            end
+
+            unless monitor[:response_timeout]
+              monitor[:response_timeout] = 2
+            end
+
+            unless monitor[:down_time]
+              monitor[:down_time] = 30
+            end
+
+            unless monitor[:interval]
+              monitor[:interval] = 5
+            end
+          end
+
+          def add_internet_service(internet_services_uri, service_data)
+            validate_internet_service_data(service_data)
+            if monitor = service_data[:monitor]
+              validate_internet_service_monitor(monitor)
+              ensure_monitor_defaults!(monitor)
+            end
+
+            request(
+              :body     => generate_internet_service_request(service_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
+              :method   => 'POST',
+              :uri      => internet_services_uri,
+              :parse    => true
+            )
+          end
+
+        end
+
+        module Mock
+          #
+          # Based on
+          # http://support.theenterprisecloud.com/kb/default.asp?id=561&Lang=1&SID=
+          #
+
+          def add_internet_service(internet_services_uri, service_data)
+            validate_internet_service_data(service_data)
+
+            internet_services_uri = ensure_unparsed(internet_services_uri)
+
+            if ip = ip_from_uri(internet_services_uri)
+              id = rand(1000)
+              new_service = service_data.merge!( { :href => Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href( { :id => id } ),
+                                                   :id => id.to_s,
+                                                   :timeout => 2,
+                                                   :nodes => [] } )
+              ip[:services] << new_service
+              xml = generate_internet_service_response( service_data, ip )
+
+              mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/vcloud/terremark/ecloud/requests/add_node.rb

@@ -0,0 +1,65 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def add_node(nodes_uri, node_data)
+            validate_node_data(node_data)
+
+            request(
+              :body     => generate_node_request(node_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml'},
+              :method   => 'POST',
+              :uri      => nodes_uri,
+              :parse    => true
+            )
+          end
+
+          private
+
+          def generate_node_request(node_data)
+            builder = Builder::XmlMarkup.new
+            builder.CreateNodeServiceRequest(:"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+                                             :"xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+                                             :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              builder.IpAddress(node_data[:ip_address])
+              builder.Name(node_data[:name])
+              builder.Port(node_data[:port])
+              builder.Enabled(node_data[:enabled])
+              builder.Description(node_data[:description])
+            }
+          end
+
+          def validate_node_data(node_data, configure=false)
+            valid_opts = [:name, :port, :enabled, :description, :ip_address]
+            if configure
+              valid_opts.delete_if { |opt| ![:name, :enabled, :description].include?(opt) }
+            end
+            unless valid_opts.all? { |opt| node_data.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - node_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+        end
+
+        module Mock
+
+          def add_node(nodes_uri, node_data)
+            validate_node_data(node_data)
+            nodes_uri = ensure_unparsed(nodes_uri)
+            service_uri = nodes_uri.gsub('/nodeServices','')
+            ip, service = mock_ip_and_service_from_service_url(service_uri)
+            if ip and service
+              id = rand(1000)
+              service[:nodes] << node_data.merge!( :id => id.to_s, :href => Fog::Vcloud::Terremark::Ecloud::Mock.extension_url + "/nodeService/#{id}" )
+              mock_it 200, mock_node_service_response(node_data, ecloud_xmlns), { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/clone_vapp.rb

@@ -0,0 +1,50 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+
+          def validate_clone_vapp_options(options)
+            valid_opts = [:name, :poweron]
+            unless valid_opts.all? { |opt| options.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
+            end
+          end
+
+          def generate_clone_vapp_request(uri, options)
+            xml = Builder::XmlMarkup.new
+            xml.CloneVAppParams(xmlns.merge!(:name => options[:name], :deploy => "true", :powerOn => options[:poweron])) {
+              xml.VApp( :href => uri, :type => "application/vnd.vmware.vcloud.vApp+xml",
+                        :xmlns => "http://www.vmware.com/vcloud/v0.8")
+            }
+          end
+
+          def clone_vapp(vdc_uri, vapp_uri, options = {})
+            unless options.has_key?(:poweron)
+              options[:poweron] = "false"
+            end
+
+            validate_clone_vapp_options(options)
+
+            request(
+              :body     => generate_clone_vapp_request(vapp_uri, options),
+              :expects  => 202,
+              :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.cloneVAppParams+xml'},
+              :method   => 'POST',
+              :uri      => vdc_uri + '/action/clonevapp',
+              :parse    => true
+            )
+          end
+        end
+
+        module Mock
+          def clone_vapp(vdc_uri, vapp_uri, customization_data)
+            validate_customization_data(customization_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end