tecnh-fog 0.2.23.vpc

data/lib/fog/vcloud/requests/login.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Vcloud
+
+    class Real
+
+
+      def login
+        unauthenticated_request({
+          :expects  => 200,
+          :headers  => {
+            'Authorization' => authorization_header
+          },
+          :method   => 'POST',
+          :parse    => true,
+          :uri      => login_uri
+        })
+      end
+
+    end
+
+    class Mock
+
+      def login
+        #
+        # Based off of:
+        # http://support.theenterprisecloud.com/kb/default.asp?id=536&Lang=1&SID=
+        # https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/01-get-login-token.aspx
+        # vCloud API Guide v0.9 - Page 17
+        #
+        xml = Builder::XmlMarkup.new
+
+        mock_it 200,
+          xml.OrgList(xmlns) {
+              mock_data[:organizations].each do |org|
+                xml.Org( :type => "application/vnd.vmware.vcloud.org+xml", :href => org[:info][:href], :name => org[:info][:name] )
+              end
+            },
+            { 'Set-Cookie' => 'vcloud-token=fc020a05-21d7-4f33-9b2a-25d8cd05a44e; path=/',
+              'Content-Type' => 'application/vnd.vmware.vcloud.orgslist+xml' }
+
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,199 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        extend Fog::Vcloud::Extension
+
+        model_path 'fog/vcloud/terremark/ecloud/models'
+        model :catalog_item
+        model :catalog
+        model :firewall_acl
+        model :firewall_acls
+        model :internet_service
+        model :internet_services
+        model :ip
+        model :ips
+        model :network
+        model :networks
+        model :node
+        model :nodes
+        model :public_ip
+        model :public_ips
+        model :server
+        model :servers
+        model :task
+        model :tasks
+        model :vdc
+        model :vdcs
+
+        request_path 'fog/vcloud/terremark/ecloud/requests'
+        request :add_internet_service
+        request :add_node
+        request :clone_vapp
+        request :configure_internet_service
+        request :configure_network
+        request :configure_network_ip
+        request :configure_node
+        request :configure_vapp
+        request :delete_internet_service
+        request :delete_node
+        request :delete_vapp
+        request :get_catalog
+        request :get_catalog_item
+        request :get_customization_options
+        request :get_firewall_acls
+        request :get_firewall_acl
+        request :get_internet_services
+        request :get_network
+        request :get_network_ip
+        request :get_network_ips
+        request :get_network_extensions
+        request :get_node
+        request :get_nodes
+        request :get_public_ip
+        request :get_public_ips
+        request :get_task
+        request :get_task_list
+        request :get_vapp
+        request :get_vapp_template
+        request :get_vdc
+        request :instantiate_vapp_template
+        request :power_off
+        request :power_on
+        request :power_reset
+        request :power_shutdown
+
+        module Mock
+          def self.base_url
+            "https://fakey.com/api/v0.8b-ext2.3"
+          end
+
+          def self.data_reset
+            @mock_data = nil
+            Fog::Vcloud::Mock.data_reset
+          end
+
+          def self.extension_url
+            self.base_url + "/extensions"
+          end
+
+          def self.data( base_url = self.base_url )
+            @mock_data ||= begin
+              vcloud_data = Fog::Vcloud::Mock.data(base_url)
+              vcloud_data.delete( :versions )
+              vcloud_data.merge!( :versions => [ { :version => "v0.8b-ext2.3", :login_url => "#{base_url}/login", :supported => true } ] )
+
+              vcloud_data[:organizations][0][:vdcs][0][:public_ips] =
+                  [
+                    { :id => "51",
+                      :href => extension_url + "/publicIp/51",
+                      :name => "99.1.2.3",
+                      :services => [
+                        { :id => "71", :href => extension_url + "/internetService/71", :port => "80", :protocol => 'HTTP', :enabled => "true",
+                          :timeout => "2", :name => 'Web Site', :description => 'Web Servers', :redirect_url => 'http://fakey.com',
+                          :nodes => [ {:id => "81", :href => extension_url + "/nodeService/81", :ip_address => "1.2.3.5",
+                                       :name => "Test Node 1", :port => "80", :enabled => "true", :description => "web 1" },
+                                      {:id => "82", :href => extension_url + "/nodeService/82", :ip_address => "1.2.3.6",
+                                       :name => "Test Node 2", :port => "80", :enabled => "true", :description => "web 2" },
+                                    ] },
+                        { :id => "72", :href => extension_url + "/internetService/72", :port => "7000", :protocol => 'HTTP', :enabled => "true",
+                          :timeout => "2", :name => 'An SSH Map', :description => 'SSH 1', :redirect_url => '',
+                          :nodes => [ {:id => "83", :href => extension_url + "/nodeService/83", :ip_address => "1.2.3.5",
+                                       :name => "SSH", :port => "22", :enabled => "true", :description => "web ssh" } 
+                                    ] }
+                      ]
+                    },
+                    { :id => "52",
+                      :href => extension_url + "/publicIp/52",
+                      :name => "99.1.2.4",
+                      :services => [
+                        { :id => "73", :href => extension_url + "/internetService/73", :port => "80", :protocol => 'HTTP', :enabled => "true",
+                          :timeout => "2", :name => 'Web Site', :description => 'Web Servers', :redirect_url => 'http://fakey.com',
+                          :nodes => [] },
+                        { :id => "74", :href => extension_url + "/internetService/74", :port => "7000", :protocol => 'HTTP', :enabled => "true",
+                          :timeout => "2", :name => 'An SSH Map', :description => 'SSH 2', :redirect_url => '',
+                          :nodes => [] }
+                      ]
+                    },
+                    { :id => "53",
+                      :href => extension_url + "/publicIp/53",
+                      :name => "99.1.9.7",
+                      :services => []
+                    }
+                  ]
+
+              vcloud_data[:organizations][0][:vdcs][1][:public_ips] =
+                  [
+                    { :id => "54",
+                      :href => extension_url + "/publicIp/54",
+                      :name => "99.99.99.99",
+                      :services => []
+                    }
+                  ]
+
+              vcloud_data[:organizations].each do |organization|
+                organization[:info][:extension_href] = extension_url
+                organization[:vdcs].each do | vdc|
+                  vdc[:extension_href] = "#{base_url}/extensions/vdc/#{vdc[:id]}"
+                  vdc[:networks].each do |network|
+                    network[:extension_href] = "#{extension_url}/network/#{network[:id]}"
+                    network[:rnat] = vdc[:public_ips].first[:name]
+                  end
+                end
+              end
+
+              vcloud_data
+            end
+          end
+
+          def self.public_ip_href(ip)
+            "#{base_url}/extensions/publicIp/#{ip[:id]}"
+          end
+
+          def self.internet_service_href(internet_service)
+            "#{base_url}/extensions/internetService/#{internet_service[:id]}"
+          end
+
+          def ecloud_xmlns
+            { :xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" }
+          end
+
+          def mock_ip_from_service_url(uri)
+            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |pip| pip[:services].detect { |service| service[:href] == uri } }
+          end
+
+          def mock_ip_and_service_from_service_url(uri)
+            if ip = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |pip| pip[:services].detect { |service| service[:href] == uri } }
+              if service = ip[:services].detect { |service| service[:href] == uri }
+                [ip, service]
+              else
+                [ip, nil]
+              end
+            else
+              [nil, nil]
+            end
+          end
+
+          def mock_node_from_url(uri)
+            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.map { |pip| pip[:services] }.flatten.map { |service| service[:nodes] }.flatten.detect { |node| node[:href] == uri }
+          end
+
+          def mock_service_from_node_url(uri)
+            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.map { |pip| pip[:services] }.flatten.map { |service| service }.detect {|service| service[:nodes].map { |node| node[:href] }.include?(uri) }
+          end
+
+          def mock_data
+            Fog::Vcloud::Terremark::Ecloud::Mock.data
+          end
+        end
+
+        module Real
+          def supporting_versions
+            ["v0.8b-ext2.3", "0.8b-ext2.3"]
+          end
+        end
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,31 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class CatalogItem < Fog::Vcloud::Model
+
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i, :xmlns_xsi, :xmlns_xsd
+
+          attribute :type
+          attribute :name
+          attribute :entity, :aliases => :Entity
+          attribute :link, :aliases => :Link
+          attribute :property, :aliases => :Property
+
+          def customization_options
+            load_unless_loaded!
+            if data = connection.get_customization_options( link[:href] ).body
+              data.delete_if { |key, value| [:xmlns_i, :xmlns].include?(key) }
+              data
+            else
+              nil
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class FirewallAcl < Fog::Vcloud::Model
+
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i
+
+          attribute :name, :aliases => :Name
+          attribute :id, :aliases => :Id
+          attribute :protocol, :aliases => :Protocol
+          attribute :source, :aliases => :Source
+          attribute :destination, :aliases => :Destination
+          attribute :permission, :aliases => :Permission
+          attribute :port_start, :aliases => :PortStart
+          attribute :port_end, :aliases => :PortEnd
+          attribute :port_type, :aliases => :PortType
+          attribute :type, :aliases => :Type
+
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,31 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        class FirewallAcls < Fog::Vcloud::Collection
+
+          model Fog::Vcloud::Terremark::Ecloud::FirewallAcl
+
+          attribute :href, :aliases => :Href
+
+          def all
+            if data = connection.get_firewall_acls(href).body[:FirewallAcl]
+              data = [ data ] if data.is_a?(Hash)
+              load(data)
+            end
+          end
+
+          def get(uri)
+            if data = connection.get_firewall_acl(uri).body
+              new(data)
+            end
+          rescue Fog::Errors::NotFound
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        class InternetService < Fog::Vcloud::Model
+
+          identity :href, :Href
+
+          ignore_attributes :xmlns, :xmlns_i
+
+          attribute :name, :aliases => :Name
+          attribute :id, :aliases => :Id
+          attribute :protocol, :aliases => :Protocol
+          attribute :port, :aliases => :Port
+          attribute :enabled, :aliases => :Enabled
+          attribute :description, :aliases => :Description
+          attribute :public_ip, :aliases => :PublicIpAddress
+          attribute :timeout, :aliases => :Timeout
+          attribute :redirect_url, :aliases => :RedirectURL
+          attribute :monitor, :aliases => :Monitor
+
+          def delete
+            requires :href
+
+            connection.delete_internet_service( href )
+          end
+
+          def save
+            if new_record?
+              result = connection.add_internet_service( collection.href, _compose_service_data )
+              merge_attributes(result.body)
+            else
+              connection.configure_internet_service( href, _compose_service_data, _compose_ip_data )
+            end
+          end
+
+          def monitor=(new_monitor = {})
+            if new_monitor.nil?
+              @monitor = nil
+            elsif new_monitor.is_a?(Hash)
+              @monitor = {}
+              @monitor[:type] = new_monitor[:MonitorType] || new_monitor[:type]
+              @monitor[:url_send_string] = new_monitor[:UrlSendString] || new_monitor[:url_send_string]
+              @monitor[:http_headers] = new_monitor[:HttpHeader] || new_monitor[:http_headers]
+              @monitor[:http_headers] = @monitor[:http_headers].split("\n") unless @monitor[:http_headers].is_a?(Array)
+              @monitor[:receive_string] = new_monitor[:ReceiveString] || new_monitor[:receive_string]
+              @monitor[:interval] = new_monitor[:Interval] || new_monitor[:interval]
+              @monitor[:response_timeout] = new_monitor[:ResponseTimeOut] || new_monitor[:response_timeout]
+              @monitor[:downtime] = new_monitor[:DownTime] || new_monitor[:downtime]
+              @monitor[:retries] = new_monitor[:Retries] || new_monitor[:retries]
+              @monitor[:is_enabled] = new_monitor[:IsEnabled] || new_monitor[:is_enabled]
+            else
+              raise RuntimeError.new("monitor needs to either be nil or a Hash")
+            end
+          end
+
+          def nodes
+            @nodes ||= Fog::Vcloud::Terremark::Ecloud::Nodes.new( :connection => connection, :href => href + "/nodeServices" )
+          end
+
+          private
+
+          def _compose_service_data
+            #For some reason inject didn't work
+            service_data = {}
+            self.class.attributes.select{ |attribute| !send(attribute).nil? }.each { |attribute| service_data[attribute] = send(attribute) }
+            service_data
+          end
+
+          def _compose_ip_data
+            if public_ip.nil?
+              {}
+            else
+              { :id => public_ip[:Id], :href => public_ip[:Href], :name => public_ip[:Name] }
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+
+