fog 0.5.3 → 0.6.0

data/lib/fog/core.rb

@@ -27,5 +27,6 @@ require 'fog/core/mock'
 require 'fog/core/provider'
 require 'fog/core/service'
 require 'fog/core/ssh'
+require 'fog/core/scp'
 require 'fog/core/time'
 require 'fog/core/wait_for'

data/lib/fog/core/credentials.rb

@@ -2,13 +2,12 @@ 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)
+    @credentials = nil
     @credential = new_credential
   end
 
@@ -24,6 +23,7 @@ module Fog
 
   # @return [String] The new path for credentials file
   def self.credentials_path=(new_credentials_path)
+    @credentials = nil
     @credential_path = new_credentials_path
   end
 
@@ -77,8 +77,12 @@ An alternate file may be used by placing its path in the FOG_RC environment vari
   :slicehost_password:
   :terremark_username:
   :terremark_password:
+  :voxel_api_key:
+  :voxel_api_secret:
   :zerigo_email:
   :zerigo_token:
+  :dnsimple_email:
+  :dnsimple_password:
 #
 # End of Fog Credentials File
 #######################################################

data/lib/fog/core/parser.rb

@@ -1,3 +1,5 @@
+require 'nokogiri'
+
 module Fog
   module Parsers
     class Base < Nokogiri::XML::SAX::Document

data/lib/fog/core/scp.rb

@@ -0,0 +1,67 @@
+module Fog
+  module SCP
+
+    def self.new(address, username, options = {})
+      if Fog.mocking?
+        Fog::SCP::Mock.new(address, username, options)
+      else
+        Fog::SCP::Real.new(address, username, options)
+      end
+    end
+
+    def self.reset_data(keys=Mock.data.keys)
+      Mock.reset_data(keys)
+    end
+
+    class Mock
+
+      def self.data
+        @data ||= Hash.new do |hash, key|
+          hash[key] = {}
+        end
+      end
+
+      def initialize(address, username, options)
+        @address  = address
+        @username = username
+        @options  = options
+      end
+
+      def upload(local_path, remote_path)
+        Fog::Mock.not_implemented
+      end
+
+    end
+
+    class Real
+
+      def initialize(address, username, options)
+        require 'net/scp'
+
+        key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
+
+        unless options[:key_data] || options[:keys] || options[:password] || key_manager.agent
+          raise ArgumentError.new(':key_data, :keys, :password or a loaded ssh-agent is required to initialize SSH')
+        end
+
+        @address  = address
+        @username = username
+        @options  = { :paranoid => false }.merge(options)
+      end
+
+      def upload(local_path, remote_path)
+        begin
+          Net::SCP.start(@address, @username, @options) do |scp|
+            scp.upload!(local_path, remote_path) do |ch, name, sent, total|
+              # TODO: handle progress display?
+            end
+          end
+        rescue Exception => error
+          raise error
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fog/dns.rb

@@ -7,6 +7,9 @@ module Fog
       when 'AWS'
         require 'fog/dns/aws'
         Fog::AWS::DNS.new(attributes)
+      when 'Bluebox'
+        require 'fog/dns/bluebox'
+        Fog::Bluebox::DNS.new(attributes)
       when 'Linode'
         require 'fog/dns/linode'
         Fog::Linode::DNS.new(attributes)
@@ -16,6 +19,9 @@ module Fog
       when 'Zerigo'
         require 'fog/dns/zerigo'
         Fog::Zerigo::DNS.new(attributes)
+      when 'DNSimple'
+        require 'fog/dns/dnsimple'
+        Fog::DNSimple::DNS.new(attributes)
       else
         raise ArgumentError.new("#{provider} is not a recognized dns provider")
       end

data/lib/fog/dns/aws.rb

@@ -84,6 +84,8 @@ module Fog
             Formatador.display_line(warning)
           end
 
+          require 'fog/core/parser'
+
           @aws_access_key_id = options[:aws_access_key_id]
           @aws_secret_access_key = options[:aws_secret_access_key]
           @hmac     = Fog::HMAC.new('sha1', @aws_secret_access_key)

data/lib/fog/dns/bluebox.rb

@@ -0,0 +1,110 @@
+module Fog
+  module Bluebox
+    class DNS < Fog::Service
+      requires :bluebox_api_key, :bluebox_customer_id
+      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
+      recognizes :provider # remove post deprecation
+
+      model_path 'fog/dns/models/bluebox'
+      model       :record
+      collection  :records
+      model       :zone
+      collection  :zones
+
+      request_path 'fog/dns/requests/bluebox'
+      request :create_record
+      request :update_record
+      request :delete_record
+      request :create_zone
+      request :update_zone
+      request :delete_zone
+      request :get_record
+      request :get_records
+      request :get_zone
+      request :get_zones
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Bluebox::DNS.new is deprecated, use Fog::DNS.new(:provider => 'Bluebox') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @bluebox_customer_id = options[:bluebox_customer_id]
+          @bluebox_api_key = options[:bluebox_api_key]
+          @data = self.class.data[@bluebox_customer_id]
+          @data = self.class.data[@bluebox_api_key]
+        end
+      end
+
+      class Real
+        def initialize(options ={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Bluebox::DNS.new is deprecated, use Fog::DNS.new(:provider => 'Bluebox') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @bluebox_customer_id = options[:bluebox_customer_id]
+          @bluebox_api_key = options[:bluebox_api_key]
+
+          @host   = options[:bluebox_host]    || "boxpanel.bluebox.net"
+          @port   = options[:bluebox_port]    || 443
+          @scheme = options[:bluebox_scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params[:headers] ||= {}
+
+          params[:headers]['Authorization'] = "Basic #{auth_header}"
+
+          params[:headers]['Accept'] = 'application/xml'
+          case params[:method]
+          when 'POST', 'PUT'
+            params[:headers]['Content-Type'] = 'application/xml'
+          end
+
+          begin
+            response = @connection.request(params.merge!({:host => @host}))
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Bluebox::DNS::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+
+          response
+        end
+
+        protected
+
+        def auth_header
+          @auth_header ||= Base64.encode64("#{@bluebox_customer_id}:#{@bluebox_api_key}").gsub("\n",'')
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/dns/dnsimple.rb

@@ -0,0 +1,95 @@
+module Fog
+  module DNSimple
+    class DNS < Fog::Service
+
+      requires :dnsimple_email, :dnsimple_password
+      recognizes :host, :path, :port, :scheme, :persistent
+      recognizes :provider # remove post deprecation
+
+      model_path 'fog/dns/models/dnsimple'
+      model       :record
+      collection  :records
+      model       :zone
+      collection  :zones
+
+      request_path 'fog/dns/requests/dnsimple'
+      request :list_domains
+      request :create_domain
+      request :get_domain
+      request :delete_domain
+      request :create_record
+      request :list_records
+      request :update_record
+      request :delete_record
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::DNS::DNSimple.new is deprecated, use Fog::DNS.new(:provider => 'DNSimple') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @dnsimple_email = options[:dnsimple_email]
+          @dnsimple_password  = options[:dnsimple_password]
+          @data = self.class.data[@dnsimple_email]
+          @data = self.class.data[@dnsimple_password]
+        end
+      end
+
+      class Real
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::DNSimple::DNS.new is deprecated, use Fog::DNS.new(:provider => 'DNSimple') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          require 'json'
+
+          @dnsimple_email = options[:dnsimple_email]
+          @dnsimple_password  = options[:dnsimple_password]
+          @host   = options[:host]    || "dnsimple.com"
+          @port   = options[:port]    || 443
+          @scheme = options[:scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params[:headers] ||= {}
+          key = "#{@dnsimple_email}:#{@dnsimple_password}"
+          params[:headers].merge!({ "Authorization" => "Basic " + Base64.encode64(key).chomp,
+                                    "Accept" => "application/json",
+                                    "Content-Type" => "application/json" })
+
+          response = @connection.request(params.merge!({:host => @host}))
+
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/dns/models/bluebox/record.rb

@@ -0,0 +1,52 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class DNS
+
+      class Record < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :domain_id,   :aliases => 'domain-id'
+        attribute :domain
+        attribute :type
+        attribute :ip,          :aliases => 'content'
+
+        def initialize(attributes={})
+          super
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_record(@zone.identity, identity)
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          requires :zone, :type, :name, :ip
+          data = unless identity
+            connection.create_record(zone.identity, type, name, ip)
+          else
+            connection.update_record(zone.identity, identity, {:type => type, :name => name, :content => ip})
+          end
+          merge_attributes(data.body)
+          true
+        end
+
+        private
+
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/dns/models/bluebox/records.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/dns/models/bluebox/record'
+
+module Fog
+  module Bluebox
+    class DNS
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::Bluebox::DNS::Record
+
+        def all
+          requires :zone
+          data = connection.get_records(zone.identity).body['records']
+          load(data)
+        end
+
+        def get(record_id)
+          data = connection.get_record(zone.identity, record_id).body
+          new(data)
+        rescue Fog::Service::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end