fog-terremark 0.0.1

data/lib/fog/compute/terremark/models/address.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    module Terremark
+      class Address < Fog::Model
+        identity :id
+
+        attribute :ip, :aliases => 'name'
+
+        def destroy
+          requires :id
+          service.delete_public_ip(id)
+          true
+        end
+
+        private
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/addresses.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    module Terremark
+      class Addresses < Fog::Collection
+        model Fog::Compute::Terremark::Address
+
+        def all
+          load(service.get_public_ips(vdc_id).body['PublicIpAddresses'])
+        end
+
+        def get(ip_id)
+          if ip_id && ip = service.get_public_ip(ip_id).body
+            new(ip)
+          elsif !ip_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def vdc_id
+          @vdc_id ||= service.default_vdc_id
+        end
+
+        private
+
+        def vdc_id=(new_vdc_id)
+          @vdc_id = new_vdc_id
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/image.rb

@@ -0,0 +1,17 @@
+module Fog
+  module Compute
+    module Terremark
+      class Image < Fog::Model
+        identity :id
+
+        attribute :name
+      end
+
+      private
+
+      def href=(new_href)
+        self.id = new_href.split('/').last.to_i
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/images.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    module Terremark
+      class Images < Fog::Collection
+        model Fog::Compute::Terremark::Image
+
+        def all
+          data = service.get_catalog(vdc_id).body['CatalogItems'].select do |entity|
+            entity['type'] == "application/vnd.vmware.vcloud.catalogItem+xml"
+          end
+          load(data)
+        end
+
+        def vdc_id
+          @vdc_id ||= service.default_vdc_id
+        end
+
+        private
+
+        def vdc_id=(new_vdc_id)
+          @vdc_id = new_vdc_id
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/internetservice.rb

@@ -0,0 +1,60 @@
+module Fog
+  module Compute
+    module Terremark
+      class InternetService < Fog::Model
+        identity :Id
+
+        attribute :Name
+        attribute :Port
+        attribute :Protocol
+        attribute :Description
+        attribute :PublicIpAddress
+        attribute :public_ip_address_id
+
+        def destroy(delete_public_ip = true)
+          service.delete_internet_service(self.Id)
+          service.delete_public_ip(self.PublicIpAddress["Id"]) if delete_public_ip
+          true
+        end
+
+        def save
+          requires :Name, :Protocol, :Port
+          if !public_ip_address_id
+            #Create the first internet service and allocate public IP
+            data = service.create_internet_service(
+                vdc = service.default_vdc_id,
+                name = self.Name,
+                protocol = self.Protocol,
+                port = self.Port,
+                options = {
+                    'Enabled' => 'true',
+                    "Description" => self.Name
+                }
+            )
+          else
+            #create additional services to existing Public IP
+            data = service.add_internet_service(
+                ip_id = public_ip_address_id,
+                name = self.Name,
+                protocol = self.Protocol,
+                port = self.Port,
+                options = {
+                    'Enabled' => 'true',
+                    "Description" => self.Name
+                }
+            )
+          end
+          merge_attributes(data.body)
+          true
+        end
+        private
+
+        attr_writer :type, :size, :Links
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/internetservices.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    module Terremark
+      class InternetServices < Fog::Collection
+        model Fog::Compute::Terremark::InternetService
+
+        def all
+          data = service.get_internet_services(vdc_id).body["InternetServices"]
+          load(data)
+        end
+
+        def get(service_id)
+          service.get_internet_services(vdc_id)
+          internet_service = services.body["InternetServices"].select {|item| item["Id"] == service_id}
+          new(internet_service)
+        end
+
+        def vdc_id
+          @vdc_id ||= service.default_vdc_id
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/network.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    module Terremark
+      class Network < Fog::Model
+        identity :id
+
+        attribute :name
+        attribute :subnet
+        attribute :gateway
+        attribute :netmask
+        attribute :fencemode
+        attribute :links
+
+        def ips
+          #Until there is a real models for these ?
+          service.get_network_ips(id).body['IpAddresses']
+        end
+
+        private
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+
+        def type=(_new_type); end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/networks.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    module Terremark
+      class Networks < Fog::Collection
+        model Fog::Compute::Terremark::Network
+
+        def all
+          data = service.get_vdc(vdc_id).body['AvailableNetworks'].map do |network|
+            service.get_network(network["href"].split("/").last).body
+          end
+          load(data)
+        end
+
+        def get(network_id)
+          network = service.get_network(network_id).body
+          if network_id && network
+            new(network)
+          elsif !network_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def vdc_id
+          @vdc_id ||= service.default_vdc_id
+        end
+
+        private
+
+        def vdc_id=(new_vdc_id)
+          @vdc_id = new_vdc_id
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/nodeservice.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    module Terremark
+      class NodeService < Fog::Model
+        identity :Id
+        attribute :Name
+        attribute :Href
+        attribute :Port
+        attribute :Description
+        attribute :IpAddress
+        attribute :Enabled
+        attribute :InternetServiceId
+
+        def destroy
+          service.delete_node_service(self.Id)
+        end
+
+        def save
+          requires :Name, :Port, :InternetServiceId
+          data = service.add_node_service(
+              service_id = self.InternetServiceId,
+              ip = self.IpAddress,
+              name = self.Name,
+              port = self.Port,
+              options = {"Enabled" => 'true',
+                         "Description" => self.Name,
+              }
+
+          )
+          merge_attributes(data.body)
+          true
+        end
+
+        private
+
+        attr_writer :type, :size, :Links
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/terremark/models/nodeservices.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Compute
+    module Terremark
+      class NodeServices < Fog::Collection
+        model Fog::Compute::Terremark::NodeService
+
+        def all(internet_service_id)
+          data = service.get_node_services(internet_service_id).body["NodeServices"]
+          load(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+module Fog
+  module Compute
+    module Terremark
+      class Server < Fog::Model
+        module VAppStatus
+          BEING_CREATED = "0"
+          BEING_DEPLOYED = "1"
+          POWERED_OFF = "2"
+          POWERED_ON = "4"
+        end
+
+        identity :id
+
+        attribute :name
+        attribute :image
+        attribute :vcpus
+        attribute :memory
+        attribute :sshkeyFingerPrint
+        attribute :powerOn
+        attribute :status
+        attribute :OperatingSystem
+        attribute :VirtualHardware
+        attribute :IpAddress
+
+        def reload
+          merge_attributes(service.get_vapp(id).body)
+        end
+
+        def destroy
+          case self.status
+            when VAppStatus::BEING_CREATED, VAppStatus::BEING_DEPLOYED
+              return false
+            when VAppStatus::POWERED_ON
+              service.power_off(self.id).body
+              wait_for { off? }
+          end
+          #Failsafe .. Always check if we are ready
+          wait_for { ready? }
+          service.delete_vapp(self.id)
+          true
+        end
+
+        def PublicIpAddress
+          @PublicIpAddress ||=
+              if internet_services.size > 0
+                internet_services[0].PublicIpAddress["Name"]
+              end
+          @PublicIpAddress
+        end
+
+        def internet_services
+          @internet_services ||= service.internetservices.all.select { |item| item.Name == self.name }
+        end
+
+        def delete_internet_services
+          #Find the internet service
+
+          while (inet_service = internet_services.pop) do
+
+            nodes = service.nodeservices.all(inet_service.Id)
+            #Delete all the associated nodes
+            nodes.select { |item| item.destroy }
+            #Clear out the services
+            inet_service.destroy(delete_public_ip = !(internet_services.size > 0))
+          end
+          true
+        end
+
+        # { '0' => 'Being created', '2' => 'Powered Off', '4' => 'Powered On'}
+        def ready?
+          status == VAppStatus::POWERED_OFF
+        end
+
+        def on?
+          status == VAppStatus::POWERED_ON
+        end
+
+        def off?
+          status == VAppStatus::POWERED_OFF
+        end
+
+        def power_on(_options = {})
+          requires :id
+          begin
+            service.power_on(id)
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered on/
+          end
+          true
+        end
+
+        def power_off
+          requires :id
+          begin
+            service.power_off(id)
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered off/
+          end
+          true
+        end
+
+        def shutdown
+          requires :id
+          begin
+            service.power_shutdown(id)
+          rescue Excon::Errors::InternalServerError => e
+            #Frankly we shouldn't get here ...
+            raise e unless e.to_s =~ /because it is already powered off/
+          end
+          true
+        end
+
+        def power_reset
+          requires :id
+          service.power_reset(id)
+          true
+        end
+
+        def graceful_restart
+          requires :id
+          shutdown
+          wait_for { off? }
+          power_on
+        end
+
+        def create_internet_services(internet_spec)
+          public_ip_info = nil
+          internet_service_id = nil
+          internet_spec.each do |proto, ports|
+            for port in ports
+              if not public_ip_info
+                #Create the first internet service and allocate public IP
+                inet_services = service.internetservices.create({
+                                                                    "Name" => self.name,
+                                                                    "Protocol" => proto,
+                                                                    "Port" => port,
+                                                                })
+                internet_service_id = inet_services.Id
+                public_ip_info = inet_services.PublicIpAddress
+
+              else
+                #create additional services to existing Public IP
+                inet_services = service.internetservices.create({
+                                                                    "public_ip_address_id" => public_ip_info["Id"],
+                                                                    "Name" => self.name,
+                                                                    "Protocol" => proto,
+                                                                    "Port" => port,
+                                                                }
+                )
+                internet_service_id = inet_services.Id
+              end
+
+              #Create the associate node service to the server
+              service.nodeservices.create({"Name" => self.name,
+                                           "IpAddress" => self.IpAddress,
+                                           "Port" => port,
+                                           "InternetServiceId" => internet_service_id
+                                          })
+            end
+          end
+          true
+        end
+
+        def save
+          requires :name
+          if powerOn
+          end
+          data = service.instantiate_vapp_template(
+              server_name=name,
+              vapp_template=image,
+              options={
+                  'ssh_key_fingerprint' => sshkeyFingerPrint,
+                  'cpus' => vcpus,
+                  'memory' => memory
+              })
+
+          merge_attributes(data.body)
+          wait_for { ready? }
+
+          #Optional, incase further configuration required.
+          if powerOn
+            power_on
+            wait_for { ready? }
+          end
+
+          true
+        end
+
+        private
+
+        attr_writer :type, :size, :Links
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+      end
+    end
+  end
+end