phpfog-fog 0.4.1

data/lib/fog/storage/requests/rackspace/head_object.rb

@@ -0,0 +1,32 @@
+module Fog
+  module Rackspace
+    class Storage
+      class Real
+
+        # Get headers for object
+        #
+        # ==== Parameters
+        # * container<~String> - Name of container to look in
+        # * object<~String> - Name of object to look for
+        #
+        def head_object(container, object)
+          response = request({
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "#{CGI.escape(container)}/#{CGI.escape(object)}"
+          }, false)
+          response
+        end
+
+      end
+
+      class Mock
+
+        def head_object(container, object)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/storage/requests/rackspace/put_container.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Rackspace
+    class Storage
+      class Real
+
+        # Create a new container
+        #
+        # ==== Parameters
+        # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        #
+        def put_container(name)
+          response = request(
+            :expects  => [201, 202],
+            :method   => 'PUT',
+            :path     => CGI.escape(name)
+          )
+          response
+        end
+
+      end
+
+      class Mock
+
+        def put_container(name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/storage/requests/rackspace/put_object.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Rackspace
+    class Storage
+      class Real
+
+        # Create a new object
+        #
+        # ==== Parameters
+        # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        #
+        def put_object(container, object, data, options = {})
+          data = parse_data(data)
+          headers = data[:headers].merge!(options)
+          response = request(
+            :body     => data[:body],
+            :expects  => 201,
+            :headers  => headers,
+            :method   => 'PUT',
+            :path     => "#{CGI.escape(container)}/#{CGI.escape(object)}"
+          )
+          response
+        end
+
+      end
+
+      class Mock
+
+        def put_object(container, object, data, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/storage.rb

@@ -0,0 +1,25 @@
+module Fog
+  class Storage
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      case provider = attributes[:provider] # attributes.delete(:provider)
+      when 'AWS'
+        require 'fog/storage/aws'
+        Fog::AWS::Storage.new(attributes)
+      when 'Google'
+        require 'fog/storage/google'
+        Fog::Google::Storage.new(attributes)
+      when 'Local'
+        require 'fog/storage/local'
+        Fog::Local::Storage.new(attributes)
+      when 'Rackspace'
+        require 'fog/storage/rackspace'
+        Fog::Rackspace::Storage.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized storage provider")
+      end
+    end
+
+  end
+end

data/lib/fog/terremark/ecloud.rb

@@ -0,0 +1,73 @@
+module Fog
+  module Terremark
+    module Ecloud
+
+      module Bin
+      end
+
+      module Defaults
+        HOST   = 'services.enterprisecloud.terremark.com'
+        PATH   = '/api/v0.8a-ext2.0'
+        PORT   = 443
+        SCHEME = 'https'
+      end
+
+      extend Fog::Terremark::Shared
+
+      def self.new(options={})
+        location = caller.first
+        warning = "[yellow][WARN] Fog::Terremark::Ecloud is deprecated, use Fog::Compute.new(:provider => 'TerremarkEcloud')[/]"
+        warning << " [light_black](" << location << ")[/] "
+        Formatador.display_line(warning)
+
+        unless @required
+          shared_requires
+          @required = true
+        end
+
+        check_shared_options(options)
+
+        if Fog.mocking?
+          Fog::Terremark::Ecloud::Mock.new(options)
+        else
+          Fog::Terremark::Ecloud::Real.new(options)
+        end
+
+      end
+
+      class Real
+        # requires :terremark_ecloud_password, :terremark_ecloud_username
+        # recognizes :host, :path, :port, :scheme, :persistent
+        
+        include Fog::Terremark::Shared::Real
+        include Fog::Terremark::Shared::Parser
+
+        def initialize(options={})
+          @terremark_password = options[:terremark_ecloud_password]
+          @terremark_username = options[:terremark_ecloud_username]
+          @host   = options[:host]   || Fog::Terremark::Ecloud::Defaults::HOST
+          @path   = options[:path]   || Fog::Terremark::Ecloud::Defaults::PATH
+          @port   = options[:port]   || Fog::Terremark::Ecloud::Defaults::PORT
+          @scheme = options[:scheme] || Fog::Terremark::Ecloud::Defaults::SCHEME
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+      end
+
+      class Mock
+        include Fog::Terremark::Shared::Mock
+        include Fog::Terremark::Shared::Parser
+
+        def initialize(option = {})
+          super
+          @base_url = Fog::Terremark::Ecloud::Defaults::SCHEME + "://" +
+          Fog::Terremark::Ecloud::Defaults::HOST +
+          Fog::Terremark::Ecloud::Defaults::PATH
+          @data = self.class.data[:terremark_ecloud_username]
+        end
+      end
+
+    end
+  end
+end
+

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

@@ -0,0 +1,29 @@
+require 'fog/core/model'
+
+module Fog
+  module Terremark
+    module Shared
+
+      class Address < Fog::Model
+
+        identity :id
+
+        attribute :ip, :aliases => 'name'
+
+        def destroy
+         requires :id
+         connection.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/terremark/models/shared/addresses.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Terremark
+    module Shared
+
+      module Mock
+        def addresses(options = {})
+          Fog::Terremark::Shared::Addresses.new(options.merge(:connection => self))
+        end
+      end
+
+      module Real
+        def addresses(options = {})
+          Fog::Terremark::Shared::Addresses.new(options.merge(:connection => self))
+        end
+      end
+
+      class Addresses < Fog::Collection
+
+        model Fog::Terremark::Shared::Address
+
+        def all
+          load(connection.get_public_ips(vdc_id).body['PublicIpAddresses'])
+        end
+
+        def get(ip_id)
+          if ip_id && ip = connection.get_public_ip(ip_id).body
+            new(ip)
+          elsif !ip_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def vdc_id
+          @vdc_id ||= connection.default_vdc_id
+        end
+
+        private
+
+        def vdc_id=(new_vdc_id)
+          @vdc_id = new_vdc_id
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/core/model'
+
+module Fog
+  module Terremark
+    module Shared
+
+      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 model for these ?
+          connection.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/terremark/models/shared/networks.rb

@@ -0,0 +1,52 @@
+module Fog
+  module Terremark
+    module Shared
+
+      module Mock
+        def networks(options = {})
+          Fog::Terremark::Shared::Networks.new(options.merge(:connection => self))
+        end
+      end
+
+      module Real
+        def networks(options = {})
+          Fog::Terremark::Shared::Networks.new(options.merge(:connection => self))
+        end
+      end
+
+      class Networks < Fog::Collection
+
+        model Fog::Terremark::Shared::Network
+
+        def all
+          data = connection.get_vdc(vdc_id).body['AvailableNetworks'].map do |network|
+            connection.get_network(network["href"].split("/").last).body
+          end
+          load(data)
+        end
+
+        def get(network_id)
+          if network_id && network = connection.get_network(network_id).body
+            new(network)
+          elsif !network_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def vdc_id
+          @vdc_id ||= connection.default_vdc_id
+        end
+
+        private
+
+        def vdc_id=(new_vdc_id)
+          @vdc_id = new_vdc_id
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'fog/core/model'
+
+module Fog
+  module Terremark
+    module Shared
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :status
+        attribute :OperatingSystem
+        attribute :VirtualHardware
+
+        def destroy
+          requires :id
+          data = connection.power_off(id).body
+          task = connection.tasks.new(data)
+          task.wait_for { ready? }
+          connection.delete_vapp(id)
+          true
+        end
+
+        # { '0' => 'Being created', '2' => 'Powered Off', '4' => 'Powered On'}
+        def ready?
+          status == '2'
+        end
+
+        def on?
+          status == '4'
+        end
+
+        def off?
+          status == '2'
+        end
+
+        def power_on(options = {})
+          requires :id
+          begin
+            connection.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
+            connection.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
+            connection.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
+          connection.power_reset(id)
+          true
+        end
+
+        def graceful_restart
+          requires :id
+          shutdown
+          wait_for { off? }
+          power_on
+        end
+
+        def save
+          requires :name
+          data = connection.instantiate_vapp(name)
+          merge_attributes(data.body)
+          task = connection.deploy_vapp(id)
+          task.wait_for { ready? }
+          task = connection.power_on(id)
+          task.wait_for { ready? }
+          true
+        end
+
+        private
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+
+        def type=(new_type); @type = new_type; end
+        def size=(new_size); @size = new_size; end
+        def IpAddress=(new_ipaddress); @IpAddress = new_ipaddress; end
+        def Links=(new_links); @Links = new_links; end
+
+      end
+
+    end
+  end
+end

data/lib/fog/terremark/models/shared/servers.rb

@@ -0,0 +1,55 @@
+require 'fog/core/collection'
+require 'fog/terremark/models/shared/server'
+
+module Fog
+  module Terremark
+    module Shared
+
+      module Mock
+        def servers(options = {})
+          Fog::Terremark::Shared::Servers.new(options.merge(:connection => self))
+        end
+      end
+
+      module Real
+        def servers(options = {})
+          Fog::Terremark::Shared::Servers.new(options.merge(:connection => self))
+        end
+      end
+
+      class Servers < Fog::Collection
+
+        model Fog::Terremark::Shared::Server
+
+        def all
+          data = connection.get_vdc(vdc_id).body['ResourceEntities'].select do |entity|
+            entity['type'] == 'application/vnd.vmware.vcloud.vApp+xml'
+          end
+          load(data)
+        end
+
+        def get(server_id)
+          if server_id && server = connection.get_vapp(server_id).body
+            new(server)
+          elsif !server_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def vdc_id
+          @vdc_id ||= connection.default_vdc_id
+        end
+
+        private
+
+        def vdc_id=(new_vdc_id)
+          @vdc_id = new_vdc_id
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/terremark/models/shared/task.rb

@@ -0,0 +1,50 @@
+require 'fog/core/model'
+
+module Fog
+  module Terremark
+    module Shared
+
+      class Task < Fog::Model
+
+        identity :id
+
+        attribute :end_time,    :aliases => 'endTime'
+        attribute :owner,       :aliases => 'Owner'
+        attribute :result,      :aliases => 'Result'
+        attribute :start_time,  :aliases => 'startTime'
+        attribute :status
+        attribute :link,        :aliases => 'Link'
+        attribute :error,       :aliases => 'Error'
+
+        def initialize(attributes = {})
+          new_owner  = attributes.delete('Owner')
+          new_result = attributes.delete('Result')
+          new_error = attributes.delete('Error')
+          new_cancel_link = attributes.delete('Link')
+
+          super
+          self.owner = connection.parse(new_owner)
+          if new_result
+            self.result = connection.parse(new_result)
+          end
+          self.error = connection.parse(new_error) if new_error
+          @cancel_link = connection.parse(new_cancel_link) if new_cancel_link
+        end
+
+        def ready?
+          @status == 'success'
+        end
+
+        private
+
+        def href=(new_href)
+          @id = new_href.split('/').last.to_i
+        end
+
+        def type=(new_type); end
+
+      end
+
+    end
+  end
+end

data/lib/fog/terremark/models/shared/tasks.rb

@@ -0,0 +1,58 @@
+require 'fog/core/collection'
+require 'fog/terremark/models/shared/server'
+
+module Fog
+  module Terremark
+    module Shared
+
+      module Mock
+        def tasks
+          Fog::Terremark::Shared::Tasks.new(:connection => self)
+        end
+      end
+
+      module Real
+        def tasks
+          Fog::Terremark::Shared::Tasks.new(:connection => self)
+        end
+      end
+
+      class Tasks < Fog::Collection
+
+        model Fog::Terremark::Shared::Task
+
+        def all
+          data = connection.get_tasks_list(task_list_id).body['Tasks']
+          load(data)
+        end
+
+        def get(task_id)
+          if task_id && task = connection.get_task(task_id).body
+            new(task)
+          elsif !task_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def task_list_id
+          @task_list_id ||=
+            if connection.default_organization_id && organization = connection.get_organization(connection.default_organization_id).body
+              organization['Links'].detect {|link| link['type'] == 'application/vnd.vmware.vcloud.tasksList+xml'}['href'].split('/').last.to_i
+            else
+              nil
+            end
+        end
+
+        private
+
+        def task_list_id=(new_task_list_id)
+          @task_list_id = new_task_list_id
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/terremark/models/shared/vdc.rb

@@ -0,0 +1,39 @@
+require 'fog/core/model'
+
+module Fog
+  module Terremark
+    module Shared
+
+      class Vdc < Fog::Model
+
+        identity :id
+
+        attribute :name
+
+        def networks
+          connection.networks(:vdc_id => id)
+        end
+
+        def addresses
+          connection.addresses(:vdc_id => id)
+        end
+
+        def servers
+          connection.servers(:vdc_id => id)
+        end
+
+        private
+
+        def href=(new_href)
+          self.id = new_href.split('/').last.to_i
+        end
+
+        def type=(new_type); end
+
+        def rel=(new_rel); end
+
+      end
+
+    end
+  end
+end