cifrado 0.1

data/vendor/fog/lib/fog/core/scp.rb

@@ -0,0 +1,96 @@
+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
+
+    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, upload_options = {})
+        self.class.data[@address] << { :username       => @username,
+                                       :options        => @options,
+                                       :local_path     => local_path,
+                                       :remote_path    => remote_path,
+                                       :upload_options => upload_options }
+      end
+
+      def download(remote_path, local_path, download_options = {})
+        self.class.data[@address] << { :username         => @username,
+                                       :options          => @options,
+                                       :remote_path      => remote_path,
+                                       :local_path       => local_path,
+                                       :download_options => download_options }
+      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
+
+        options[:timeout] = 30
+        if options[:key_data] || options[:keys]
+          options[:keys_only] = true
+          #Explicitly set these so net-ssh doesn't add the default keys
+          #as seen at https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/session.rb#L131-146
+          options[:keys] = [] unless options[:keys]
+          options[:key_data] = [] unless options[:key_data]
+        end
+
+        @address  = address
+        @username = username
+        @options  = { :paranoid => false }.merge(options)
+      end
+
+      def upload(local_path, remote_path, upload_options = {})
+        begin
+          Net::SCP.start(@address, @username, @options) do |scp|
+            scp.upload!(local_path, remote_path, upload_options) do |ch, name, sent, total|
+              # TODO: handle progress display?
+            end
+          end
+        rescue Exception => error
+          raise error
+        end
+      end
+
+      def download(remote_path, local_path, download_options = {})
+        begin
+          Net::SCP.start(@address, @username, @options) do |scp|
+            scp.download!(remote_path, local_path, download_options) do |ch, name, sent, total|
+              # TODO: handle progress display?
+            end
+          end
+        rescue Exception => error
+          raise error
+        end
+      end
+
+    end
+
+  end
+end

data/vendor/fog/lib/fog/core/service.rb

@@ -0,0 +1,223 @@
+module Fog
+
+  def self.services
+    @services ||= {}
+  end
+
+  class Service
+
+    class Error < Fog::Errors::Error; end
+    class NotFound < Fog::Errors::NotFound; end
+
+    module NoLeakInspector
+      def inspect
+        "#<#{self.class}:#{self.object_id} #{(self.instance_variables - service.secrets).map {|iv| [iv, self.instance_variable_get(iv).inspect].join('=')}.join(' ')}>"
+      end
+    end
+
+    module Collections
+
+      def collections
+        service.collections
+      end
+
+      def mocked_requests
+        service.mocked_requests
+      end
+
+      def requests
+        service.requests
+      end
+
+    end
+
+    class << self
+
+      def inherited(child)
+        child.class_eval <<-EOS, __FILE__, __LINE__
+          class Error < Fog::Service::Error; end
+          class NotFound < Fog::Service::NotFound; end
+
+          module Collections
+            include Fog::Service::Collections
+
+            def service
+              #{child}
+            end
+          end
+
+          def self.service
+            #{child}
+          end
+        EOS
+      end
+
+      def new(options={})
+        options = Fog.symbolize_credentials(options)
+        options = fetch_credentials(options).merge(options)
+        validate_options(options)
+        coerce_options(options)
+        setup_requirements
+
+        if Fog.mocking?
+          service::Mock.send(:include, service::Collections)
+          service::Mock.new(options)
+        else
+          service::Real.send(:include, service::Collections)
+          service::Real.send(:include, service::NoLeakInspector)
+          service::Real.new(options)
+        end
+      end
+
+      def fetch_credentials(options)
+        # attempt to load credentials from config file
+        begin
+          default_credentials = Fog.credentials.reject {|key, value| !(recognized | requirements).include?(key)}
+        rescue LoadError
+          # if there are no configured credentials, do nothing
+          {}
+        end
+      end
+
+      def setup_requirements
+        if superclass.respond_to?(:setup_requirements)
+          superclass.setup_requirements
+        end
+
+        @required ||= false
+        unless @required
+          for collection in collections
+            require [@model_path, collection].join('/')
+            constant = collection.to_s.split('_').map {|characters| characters[0...1].upcase << characters[1..-1]}.join('')
+            service::Collections.module_eval <<-EOS, __FILE__, __LINE__
+              def #{collection}(attributes = {})
+                #{service}::#{constant}.new({:service => self}.merge(attributes))
+              end
+            EOS
+          end
+          for model in models
+            require [@model_path, model].join('/')
+          end
+          for request in requests
+            require [@request_path, request].join('/')
+            if service::Mock.method_defined?(request)
+              mocked_requests << request
+            else
+              service::Mock.module_eval <<-EOS, __FILE__, __LINE__
+                def #{request}(*args)
+                  Fog::Mock.not_implemented
+                end
+              EOS
+            end
+          end
+          @required = true
+        end
+      end
+
+      def model_path(new_path)
+        @model_path = new_path
+      end
+
+      def collection(new_collection)
+        collections << new_collection
+      end
+
+      def collections
+        @collections ||= []
+      end
+
+      def coerce_options(options)
+        options.each do |key, value|
+          value_string = value.to_s.downcase
+          if value.nil?
+            options.delete(key)
+          elsif value == value_string.to_i.to_s
+            options[key] = value.to_i
+          else
+            options[key] = case value_string
+            when 'false'
+              false
+            when 'true'
+              true
+            else
+              value
+            end
+          end
+        end
+      end
+
+      def mocked_requests
+        @mocked_requests ||= []
+      end
+
+      def model(new_model)
+        models << new_model
+      end
+
+      def models
+        @models ||= []
+      end
+
+      def request_path(new_path)
+        @request_path = new_path
+      end
+
+      def request(new_request)
+        requests << new_request
+      end
+
+      def requests
+        @requests ||= []
+      end
+
+      def secrets(*args)
+        if args.empty?
+          @secrets ||= []
+        else
+          args.inject(secrets) do |secrets, secret|
+            secrets << "@#{secret}".to_sym
+          end
+        end
+      end
+
+      def requires(*args)
+        requirements.concat(args)
+      end
+
+      def requirements
+        @requirements ||= []
+      end
+
+      def recognizes(*args)
+        recognized.concat(args)
+      end
+
+      def recognized
+        @recognized ||= [:connection_options]
+      end
+
+      def validate_options(options)
+        keys = []
+        for key, value in options
+          unless value.nil?
+            keys << key
+          end
+        end
+        missing = requirements - keys
+        unless missing.empty?
+          raise ArgumentError, "Missing required arguments: #{missing.join(', ')}"
+        end
+
+        unless recognizes.empty?
+          unrecognized = options.keys - requirements - recognized
+          unless unrecognized.empty?
+            raise ArgumentError, "Unrecognized arguments: #{unrecognized.join(', ')}"
+          end
+        end
+      end
+
+    end
+
+  end
+end
+

data/vendor/fog/lib/fog/core/ssh.rb

@@ -0,0 +1,137 @@
+require 'delegate'
+
+module Fog
+  module SSH
+
+    def self.new(address, username, options = {})
+      if Fog.mocking?
+        Fog::SSH::Mock.new(address, username, options)
+      else
+        Fog::SSH::Real.new(address, username, options)
+      end
+    end
+
+    class Mock
+
+      def self.data
+        @data ||= Hash.new do |hash, key|
+          hash[key] = []
+        end
+      end
+
+      def self.reset
+        @data= nil
+      end
+
+      def initialize(address, username, options)
+        @address  = address
+        @username = username
+        @options  = options
+      end
+
+      def run(commands, &blk)
+        self.class.data[@address] << {:commands => commands, :username => @username, :options => @options}
+      end
+
+    end
+
+    class Real
+
+      def initialize(address, username, options)
+        require 'net/ssh'
+
+        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
+
+        options[:timeout] = 30
+        if options[:key_data] || options[:keys]
+          options[:keys_only] = true
+          #Explicitly set these so net-ssh doesn't add the default keys
+          #as seen at https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/session.rb#L131-146
+          options[:keys] = [] unless options[:keys]
+          options[:key_data] = [] unless options[:key_data]
+        end
+
+        @address  = address
+        @username = username
+        @options  = { :paranoid => false }.merge(options)
+      end
+
+      def run(commands, &blk)
+        commands = [*commands]
+        results  = []
+        begin
+          Net::SSH.start(@address, @username, @options) do |ssh|
+            commands.each do |command|
+              result = Result.new(command)
+              ssh.open_channel do |ssh_channel|
+                ssh_channel.request_pty
+                ssh_channel.exec(command) do |channel, success|
+                  unless success
+                    raise "Could not execute command: #{command.inspect}"
+                  end
+
+                  channel.on_data do |ch, data|
+                    result.stdout << data
+                    yield [data, ''] if blk
+                  end
+
+                  channel.on_extended_data do |ch, type, data|
+                    next unless type == 1
+                    result.stderr << data
+                    yield ['', data] if blk
+                  end
+
+                  channel.on_request('exit-status') do |ch, data|
+                    result.status = data.read_long
+                  end
+
+                  channel.on_request('exit-signal') do |ch, data|
+                    result.status = 255
+                  end
+                end
+              end
+              ssh.loop
+              results << result
+            end
+          end
+        rescue Net::SSH::HostKeyMismatch => exception
+          exception.remember_host!
+          sleep 0.2
+          retry
+        end
+        results
+      end
+
+    end
+
+    class Result
+
+      attr_accessor :command, :stderr, :stdout, :status
+
+      def display_stdout
+        data = stdout.split("\r\n")
+        if data.is_a?(String)
+          Formatador.display_line(data)
+        elsif data.is_a?(Array)
+          Formatador.display_lines(data)
+        end
+      end
+
+      def display_stderr
+        Formatador.display_line(stderr.split("\r\n"))
+      end
+
+      def initialize(command)
+        @command = command
+        @stderr = ''
+        @stdout = ''
+      end
+
+    end
+
+  end
+end