phpfog-fog 0.4.1

data/lib/fog/compute/terremark_ecloud.rb

@@ -0,0 +1,109 @@
+require 'builder'
+
+module Fog
+  module TerremarkEcloud
+    class Compute < Fog::Service
+
+      requires :terremark_ecloud_username, :terremark_ecloud_password
+      recognizes :versions_endpoint
+
+      request_path 'fog/compute/requests/terremark_ecloud'
+      request :get_catalog
+      request :get_catalog_item
+      request :get_ip_addresses
+      request :get_network
+      request :get_organization
+      request :get_vdc
+
+      class Mock
+
+        def initialize(options={})
+        end
+
+        def organization_href
+          Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        def initialize(options = {})
+          require 'fog/compute/parsers/terremark_ecloud/get_versions'
+          require 'fog/compute/parsers/terremark_ecloud/login'
+
+          @username = options[:terremark_ecloud_username]
+          @password = options[:terremark_ecloud_password]
+          @version  = '0.8b-ext2.6'
+          @versions_endpoint = options[:versions_endpoint] || 'https://services.enterprisecloud.terremark.com/api/versions'
+        end
+
+        def organization_href
+          unless @organization_href
+            get_token_and_organization
+          end
+          @organization_href
+        end
+
+        def request(params)
+          raise ArgumentError.new('Need :href in params') unless params[:href]
+
+          # set auth token
+          if @token.nil?
+            get_token_and_organization
+          end
+
+          begin
+            Fog::Connection.new(params[:href]).request({
+              :parser  => params[:parser],
+              :expects => params[:expects] || 200,
+              :method  => params[:method]  || 'GET',
+              :body    => params[:body],
+              :headers => {
+                'Cookie' => @token
+              }.merge(params[:headers] || {})
+            })
+          rescue Excon::Errors::Unauthorized # expired token
+            get_token_and_organization
+            retry
+          end
+        end
+
+        private
+
+        def get_token_and_organization
+          # lookup LoginUrl for specified version
+          connection = Fog::Connection.new(@versions_endpoint)
+          response = connection.request({
+            :expects  => 200,
+            :method   => 'GET',
+            :parser   => Fog::Parsers::TerremarkEcloud::Compute::GetVersions.new
+          });
+          version_info = response.body['SupportedVersions'].detect {|version_info| version_info['Version'] == @version}
+          unless login_url = version_info && version_info['LoginUrl']
+            # no LoginUrl matches specified version
+            raise "TerremarkEcloud does not support version #{@version}"
+          end
+
+          connection = Fog::Connection.new(login_url)
+          response   = connection.request({
+            :expects => 200,
+            :method  => 'POST',
+            :headers => {
+              'Authorization' => ('Basic ' << Base64.encode64("#{@username}:#{@password}").chomp!),
+              'Content-Type'  => 'application/vnd.vmware.vcloud.orgList+xml'
+            },
+            :parser   => Fog::Parsers::TerremarkEcloud::Compute::Login.new
+          })
+
+          @token = response.headers['Set-Cookie']
+
+          if organization = response.body['OrgList'].first
+            @organization_href = organization['href']
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute.rb

@@ -0,0 +1,40 @@
+module Fog
+  class Compute
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      case provider = attributes[:provider] # attributes.delete(:provider)
+      when 'AWS'
+        require 'fog/compute/aws'
+        Fog::AWS::Compute.new(attributes)
+      when 'Bluebox'
+        require 'fog/compute/bluebox'
+        Fog::Bluebox::Compute.new(attributes)
+      when 'Brightbox'
+        require 'fog/compute/brightbox'
+        Fog::Brightbox::Compute.new(attributes)
+      when 'GoGrid'
+        require 'fog/compute/go_grid'
+        Fog::GoGrid::Compute.new(attributes)
+      when 'Linode'
+        require 'fog/compute/linode'
+        Fog::Linode::Compute.new(attributes)
+      when 'NewServers'
+        require 'fog/compute/new_servers'
+        Fog::NewServers::Compute.new(attributes)
+      when 'Rackspace'
+        require 'fog/compute/rackspace'
+        Fog::Rackspace::Compute.new(attributes)
+      when 'Slicehost'
+        require 'fog/compute/slicehost'
+        Fog::Slicehost::Compute.new(attributes)
+      when 'TerremarkEcloud'
+        require 'fog/compute/terremark_ecloud'
+        Fog::TerremarkEcloud::Compute.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized compute provider")
+      end
+    end
+
+  end
+end

data/lib/fog/core/attributes.rb

@@ -0,0 +1,178 @@
+module Fog
+  module Attributes
+    module ClassMethods
+
+      def _load(marshalled)
+        new(Marshal.load(marshalled))
+      end
+
+      def aliases
+        @aliases ||= {}
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+
+      def attribute(name, options = {})
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            attributes[:#{name}]
+          end
+        EOS
+        case options[:type]
+        when :boolean
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = case new_#{name}
+              when 'true'
+                true
+              when 'false'
+                false
+              end
+            end
+          EOS
+        when :float
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = new_#{name}.to_f
+            end
+          EOS
+        when :integer
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = new_#{name}.to_i
+            end
+          EOS
+        when :string
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = new_#{name}.to_s
+            end
+          EOS
+        when :time
+          class_eval <<-EOS, __FILE__, __LINE__
+            def #{name}=(new_#{name})
+              attributes[:#{name}] = if new_#{name}.nil? || new_#{name} == "" || new_#{name}.is_a?(Time)
+                new_#{name}
+              else
+                Time.parse(new_#{name})
+              end
+            end
+          EOS
+        when :array
+          class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}=(new_#{name})
+            attributes[:#{name}] = [*new_#{name}]
+          end
+          EOS
+        else
+          if squash = options[:squash]
+            class_eval <<-EOS, __FILE__, __LINE__
+              def #{name}=(new_data)
+                if new_data.is_a?(Hash)
+                  if new_data[:#{squash}] || new_data["#{squash}"]
+                    attributes[:#{name}] = new_data[:#{squash}] || new_data["#{squash}"]
+                  else
+                    attributes[:#{name}] = [ new_data ]
+                  end
+                else
+                  attributes[:#{name}] = new_data
+                end
+              end
+            EOS
+          else
+            class_eval <<-EOS, __FILE__, __LINE__
+              def #{name}=(new_#{name})
+                attributes[:#{name}] = new_#{name}
+              end
+            EOS
+          end
+        end
+        @attributes ||= []
+        @attributes |= [name]
+        for new_alias in [*options[:aliases]]
+          aliases[new_alias] = name
+        end
+      end
+
+      def identity(name, options = {})
+        @identity = name
+        self.attribute(name, options)
+      end
+
+      def ignore_attributes(*args)
+        @ignored_attributes = args
+      end
+
+      def ignored_attributes
+        @ignored_attributes ||= []
+      end
+
+    end
+
+    module InstanceMethods
+
+      def _dump
+        Marshal.dump(attributes)
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def identity
+        send(self.class.instance_variable_get('@identity'))
+      end
+
+      def identity=(new_identity)
+        send("#{self.class.instance_variable_get('@identity')}=", new_identity)
+      end
+
+      def merge_attributes(new_attributes = {})
+        for key, value in new_attributes
+          unless self.class.ignored_attributes.include?(key)
+            if aliased_key = self.class.aliases[key]
+              send("#{aliased_key}=", value)
+            elsif (public_methods | private_methods).detect {|method| ["#{key}=", :"#{key}="].include?(method)}
+              send("#{key}=", value)
+            else
+              attributes[key] = value
+            end
+          end
+        end
+        self
+      end
+
+      def new_record?
+        !identity
+      end
+
+      # check that the attributes specified in args exist and is not nil
+      def requires(*args)
+        missing = []
+        for arg in [:connection] | args
+          missing << arg unless send("#{arg}")
+        end
+        unless missing.empty?
+          if missing.length == 1
+            raise(ArgumentError, "#{missing.first} is required for this operation")
+          else
+            raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+          end
+        end
+      end
+
+      private
+
+      def remap_attributes(attributes, mapping)
+        for key, value in mapping
+          if attributes.key?(key)
+            attributes[value] = attributes.delete(key)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/core/collection.rb

@@ -0,0 +1,126 @@
+module Fog
+  class Collection < Array
+
+    extend Fog::Attributes::ClassMethods
+    include Fog::Attributes::InstanceMethods
+
+    Array.public_instance_methods(false).each do |method|
+      unless [:reject, :select].include?(method.to_sym)
+        class_eval <<-RUBY
+          def #{method}(*args)
+            unless @loaded
+              lazy_load
+            end
+            super
+          end
+        RUBY
+      end
+    end
+
+    %w[reject select].each do |method|
+      class_eval <<-RUBY
+        def #{method}(*args)
+          unless @loaded
+            lazy_load
+          end
+          data = super
+          result = self.clone.clear.concat(data)
+        end
+      RUBY
+    end
+
+    def self.model(new_model=nil)
+      if new_model == nil
+        @model
+      else
+        @model = new_model
+      end
+    end
+
+    attr_accessor :connection
+
+    remove_method :clear
+    def clear
+      @loaded = true
+      super
+    end
+
+    def create(attributes = {})
+      object = new(attributes)
+      object.save
+      object
+    end
+
+    def initialize(attributes = {})
+      @loaded = false
+      merge_attributes(attributes)
+    end
+
+    remove_method :inspect
+    def inspect
+      Thread.current[:formatador] ||= Formatador.new
+      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
+      Thread.current[:formatador].indent do
+        unless self.class.attributes.empty?
+          data << "#{Thread.current[:formatador].indentation}"
+          data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+          data << "\n"
+        end
+        data << "#{Thread.current[:formatador].indentation}["
+        unless self.empty?
+          data << "\n"
+          Thread.current[:formatador].indent do
+            data << self.map {|member| member.inspect}.join(",\n")
+            data << "\n"
+          end
+          data << Thread.current[:formatador].indentation
+        end
+        data << "]\n"
+      end
+      data << "#{Thread.current[:formatador].indentation}>"
+      data
+    end
+
+    def load(objects)
+      clear
+      for object in objects
+        self << new(object)
+      end
+      self
+    end
+
+    def model
+      self.class.instance_variable_get('@model')
+    end
+
+    def new(attributes = {})
+      model.new(
+        attributes.merge(
+          :collection => self,
+          :connection => connection
+        )
+      )
+    end
+
+    def reload
+      clear
+      lazy_load
+      self
+    end
+
+    def table(attributes = nil)
+      Formatador.display_table(self.map {|instance| instance.attributes}, attributes)
+    end
+
+    def to_json
+      self.map {|member| member.attributes}.to_json
+    end
+
+    private
+
+    def lazy_load
+      self.all
+    end
+
+  end
+end

data/lib/fog/core/connection.rb

@@ -0,0 +1,35 @@
+module Fog
+  class Connection
+
+    def initialize(url, persistent=false, params={})
+      @excon = Excon.new(url, params)
+      @persistent = persistent
+    end
+
+    def request(params, &block)
+      unless @persistent
+        reset
+      end
+      unless block_given?
+        if (parser = params.delete(:parser))
+          body = Nokogiri::XML::SAX::PushParser.new(parser)
+          block = lambda { |chunk| body << chunk }
+        end
+      end
+
+      response = @excon.request(params, &block)
+
+      if parser
+        body.finish
+        response.body = parser.response
+      end
+
+      response
+    end
+
+    def reset
+      @excon.reset
+    end
+
+  end
+end

data/lib/fog/core/credentials.rb

@@ -0,0 +1,88 @@
+require 'yaml'
+
+module Fog
+  require 'fog/core/deprecation'
+  extend Fog::Deprecation
+  self_deprecate(:config_path, :credentials_path)
+
+  # Assign a new credential to use from configuration file
+  #   @param [String, Symbol] new_credential name of new credential to use
+  #   @ return [String, Symbol] name of the new credential
+  def self.credential=(new_credential)
+    @credential = new_credential
+  end
+
+  # @return [String, Symbol] The credential to use in Fog
+  def self.credential
+    @credential ||= :default
+  end
+
+  # @return [String] The path for configuration_file
+  def self.credentials_path
+    @credential_path ||= File.expand_path(ENV["FOG_RC"] || '~/.fog')
+  end
+
+  # @return [String] The new path for credentials file
+  def self.credentials_path=(new_credentials_path)
+    @credential_path = new_credentials_path
+  end
+
+  # @return [Hash] The credentials pulled from the configuration file
+  # @raise [LoadError] Configuration unavailable in configuration file
+  def self.credentials
+    @credentials  ||= begin
+      if File.exists?(credentials_path)
+        credentials = YAML.load_file(credentials_path)
+        (credentials && credentials[credential]) or raise LoadError.new missing_credentials
+      else
+        {}
+      end
+    end
+  end
+
+private
+
+  # @return [String] The error message that will be raised, if credentials cannot be found
+  def self.missing_credentials
+    <<-YML
+Missing Credentials
+
+To run as '#{credential}', add the following to your resource config file: #{credentials_path}
+An alternate file may be used by placing its path in the FOG_RC environment variable
+
+#######################################################
+# Fog Credentials File
+#
+# Key-value pairs should look like:
+# :aws_access_key_id:                 022QF06E7MXBSAMPLE
+:#{credential}:
+  :aws_access_key_id:
+  :aws_secret_access_key:
+  :bluebox_api_key:
+  :bluebox_customer_id:
+  :brightbox_client_id:
+  :brightbox_secret:
+  :go_grid_api_key:
+  :go_grid_shared_secret:
+  :google_storage_access_key_id:
+  :google_storage_secret_access_key:
+  :linode_api_key:
+  :local_root:
+  :new_servers_password:
+  :new_servers_username:
+  :public_key_path:
+  :private_key_path:
+  :rackspace_api_key:
+  :rackspace_username:
+  :slicehost_password:
+  :terremark_username:
+  :terremark_password:
+  :zerigo_email:
+  :zerigo_token:
+#
+# End of Fog Credentials File
+#######################################################
+
+YML
+  end
+end

data/lib/fog/core/deprecation.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Deprecation
+
+    def deprecate(older, newer)
+      module_eval <<-EOS, __FILE__, __LINE__
+        def #{older}(*args)
+          Formatador.display_line("[yellow][WARN] #{self} => ##{older} is deprecated, use ##{newer} instead[/] [light_black](#{caller.first})[/]")
+          send(:#{newer}, *args)
+        end
+      EOS
+    end
+
+    def self_deprecate(older, newer)
+      module_eval <<-EOS, __FILE__, __LINE__
+        def self.#{older}(*args)
+          Formatador.display_line("[yellow][WARN] #{self} => ##{older} is deprecated, use ##{newer} instead[/] [light_black](#{caller.first})[/]")
+          send(:#{newer}, *args)
+        end
+      EOS
+    end
+
+  end
+end

data/lib/fog/core/errors.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Errors
+
+    class Error < StandardError
+      attr_accessor :verbose
+
+      def self.slurp(error, message = nil)
+        new_error = new(message)
+        new_error.set_backtrace(error.backtrace)
+        new_error.verbose = error.message
+        new_error
+      end
+    end
+
+    class MockNotImplemented < Fog::Errors::Error; end
+
+    class NotFound < Fog::Errors::Error; end
+
+  end
+end

data/lib/fog/core/hmac.rb

@@ -0,0 +1,48 @@
+module Fog
+  class HMAC
+
+    def initialize(type, key)
+      @key = key
+      case type
+      when 'sha1'
+        setup_sha1
+      when 'sha256'
+        setup_sha256
+      end
+    end
+
+    def sign(data)
+      @signer.call(data)
+    end
+
+    private
+
+    def setup_sha1
+      @digest = OpenSSL::Digest::Digest.new('sha1')
+      @signer = lambda do |data|
+        OpenSSL::HMAC.digest(@digest, @key, data)
+      end
+    end
+
+    def setup_sha256
+      begin
+        @digest = OpenSSL::Digest::Digest.new('sha256')
+        @signer = lambda do |data|
+          OpenSSL::HMAC.digest(@digest, @key, data)
+        end
+      rescue RuntimeError => error
+        unless error.message == 'Unsupported digest algorithm (sha256).'
+          raise error
+        else
+          require 'hmac-sha2'
+          @hmac = ::HMAC::SHA256.new(@key)
+          @signer = lambda do |data|
+            @hmac.update(data)
+            @hmac.digest
+          end
+        end
+      end
+    end
+
+  end
+end