cifrado 0.1

data/vendor/fog/fog.gemspec

@@ -0,0 +1,70 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'fog'
+  s.version           = '1.9.0'
+  s.date              = '2013-01-19'
+  s.rubyforge_project = 'fog'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "brings clouds to you"
+  s.description = "The Ruby cloud services library. Supports all major cloud providers including AWS, Rackspace, Linode, Blue Box, StormOnDemand, and many others. Full support for most AWS services including EC2, S3, CloudWatch, SimpleDB, ELB, and RDS."
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["geemus (Wesley Beary)"]
+  s.email    = 'geemus@gmail.com'
+  s.homepage = 'http://github.com/fog/fog'
+
+  ## This sections is only necessary if you have C extensions.
+  # s.require_paths << 'ext'
+  # s.extensions = %w[ext/extconf.rb]
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ["fog"]
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('builder')
+  s.add_dependency('excon', '~>0.14')
+  s.add_dependency('formatador', '~>0.2.0')
+  s.add_dependency('multi_json', '~>1.0')
+  s.add_dependency('mime-types')
+  s.add_dependency('net-scp', '~>1.0.4')
+  s.add_dependency('net-ssh', '>=2.1.3')
+  s.add_dependency('nokogiri', '~>1.5.0')
+  s.add_dependency('ruby-hmac')
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('jekyll')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rbvmomi')
+  s.add_development_dependency('yard')
+  s.add_development_dependency('thor')
+  s.add_development_dependency('rspec', '~>1.3.1')
+  s.add_development_dependency('rbovirt', '>=0.0.11')
+  s.add_development_dependency('shindo', '~>0.3.4')
+  s.add_development_dependency('virtualbox', '~>0.9.1')
+  s.add_development_dependency('fission')
+  s.add_development_dependency('pry')
+#  s.add_development_dependency('ruby-libvirt','~>0.4.0')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {spec,tests}/*`.split("\n")
+end

data/vendor/fog/lib/fog.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'fog', 'core')
+
+module Fog
+end
+
+# FIXME: these should go away (force usage of Fog::[Compute, CDN, DNS, Storage]  etc)
+require 'fog/providers'
+require 'fog/terremark'
+
+require 'fog/compute'
+require 'fog/identity'
+require 'fog/image'
+require 'fog/volume'
+require 'fog/cdn'
+require 'fog/dns'
+require 'fog/network'
+require 'fog/storage'

data/vendor/fog/lib/fog/cdn.rb

@@ -0,0 +1,30 @@
+module Fog
+  module CDN
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      case provider = attributes.delete(:provider).to_s.downcase.to_sym
+      when :aws
+        require 'fog/aws/cdn'
+        Fog::CDN::AWS.new(attributes)
+      when :hp
+        require 'fog/hp/cdn'
+        Fog::CDN::HP.new(attributes)
+      when :rackspace
+        require 'fog/rackspace/cdn'
+        Fog::CDN::Rackspace.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized cdn provider")
+      end
+    end
+
+    def self.providers
+      Fog.services[:cdn]
+    end
+
+  end
+end

data/vendor/fog/lib/fog/compute.rb

@@ -0,0 +1,127 @@
+module Fog
+  module Compute
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+
+      case provider
+      when :aws
+        require 'fog/aws/compute'
+        Fog::Compute::AWS.new(attributes)
+      when :bluebox
+        require 'fog/bluebox/compute'
+        Fog::Compute::Bluebox.new(attributes)
+      when :brightbox
+        require 'fog/brightbox/compute'
+        Fog::Compute::Brightbox.new(attributes)
+      when :cloudstack
+        require 'fog/cloudstack/compute'
+        Fog::Compute::Cloudstack.new(attributes)
+      when :clodo
+        require 'fog/clodo/compute'
+        Fog::Compute::Clodo.new(attributes)
+      when :digitalocean
+        require 'fog/digitalocean/compute'
+        Fog::Compute::DigitalOcean.new(attributes)
+      when :ecloud
+        require 'fog/ecloud/compute'
+        Fog::Compute::Ecloud.new(attributes)
+      when :glesys
+        require 'fog/glesys/compute'
+        Fog::Compute::Glesys.new(attributes)
+      when :gogrid
+        require 'fog/go_grid/compute'
+        Fog::Compute::GoGrid.new(attributes)
+      when :hp
+        require 'fog/hp/compute'
+        Fog::Compute::HP.new(attributes)
+      when :ibm
+        require 'fog/ibm/compute'
+        Fog::Compute::IBM.new(attributes)
+      when :joyent
+        require 'fog/joyent/compute'
+        Fog::Compute::Joyent.new(attributes)
+      when :libvirt
+        require 'fog/libvirt/compute'
+        Fog::Compute::Libvirt.new(attributes)
+      when :linode
+        require 'fog/linode/compute'
+        Fog::Compute::Linode.new(attributes)
+      when :new_servers
+        require 'fog/bare_metal_cloud/compute'
+        Fog::Logger.deprecation "`new_servers` is deprecated. Please use `bare_metal_cloud` instead."
+        Fog::Compute::BareMetalCloud.new(attributes)
+      when :baremetalcloud
+        require 'fog/bare_metal_cloud/compute'
+        Fog::Compute::BareMetalCloud.new(attributes)
+      when :ninefold
+        require 'fog/ninefold/compute'
+        Fog::Compute::Ninefold.new(attributes)
+      when :openstack
+        require 'fog/openstack/compute'
+        Fog::Compute::OpenStack.new(attributes)
+      when :ovirt
+        require 'fog/ovirt/compute'
+        Fog::Compute::Ovirt.new(attributes)
+      when :rackspace
+        version = attributes.delete(:version) 
+        version = version.to_s.downcase.to_sym unless version.nil?
+        if version == :v2
+          require 'fog/rackspace/compute_v2'
+           Fog::Compute::RackspaceV2.new(attributes)
+        else
+          Fog::Logger.deprecation "First Gen Cloud Servers are deprecated. Please use `:version => :v2` attribute to use Next Gen Cloud Servers."
+          require 'fog/rackspace/compute'
+          Fog::Compute::Rackspace.new(attributes)
+        end
+      when :serverlove
+        require 'fog/serverlove/compute'
+        Fog::Compute::Serverlove.new(attributes)
+      when :stormondemand
+        require 'fog/storm_on_demand/compute'
+        Fog::Compute::StormOnDemand.new(attributes)
+      when :vcloud
+        require 'fog/vcloud/compute'
+        Fog::Vcloud::Compute.new(attributes)
+      when :virtualbox
+        require 'fog/virtual_box/compute'
+        Fog::Compute::VirtualBox.new(attributes)
+      when :vmfusion
+        require 'fog/vmfusion/compute'
+        Fog::Compute::Vmfusion.new(attributes)
+      when :voxel
+        require 'fog/voxel/compute'
+        Fog::Compute::Voxel.new(attributes)
+      when :vsphere
+        require 'fog/vsphere/compute'
+        Fog::Compute::Vsphere.new(attributes)
+      when :xenserver
+        require 'fog/xenserver/compute'
+        Fog::Compute::XenServer.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized compute provider")
+      end
+    end
+
+    def self.providers
+      Fog.services[:compute]
+    end
+
+    def self.servers
+      servers = []
+      for provider in self.providers
+        begin
+          servers.concat(self[provider].servers)
+        rescue # ignore any missing credentials/etc
+        end
+      end
+      servers
+    end
+
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Server < Fog::Model
+
+      attr_writer :username, :private_key, :private_key_path, :public_key, :public_key_path
+
+      def username
+        @username ||= 'root'
+      end
+
+      def private_key_path
+        @private_key_path ||= Fog.credentials[:private_key_path]
+        @private_key_path &&= File.expand_path(@private_key_path)
+      end
+
+      def private_key
+        @private_key ||= private_key_path && File.read(private_key_path)
+      end
+
+      def public_key_path
+        @public_key_path ||= Fog.credentials[:public_key_path]
+        @public_key_path &&= File.expand_path(@public_key_path)
+      end
+
+      def public_key
+        @public_key ||= public_key_path && File.read(public_key_path)
+      end
+
+
+      def scp(local_path, remote_path, upload_options = {})
+        require 'net/scp'
+        requires :public_ip_address, :username
+
+        scp_options = {:port => ssh_port}
+        scp_options[:key_data] = [private_key] if private_key
+        Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+      end
+
+      alias_method :scp_upload, :scp
+
+      def scp_download(remote_path, local_path, download_options = {})
+        require 'net/scp'
+        requires :public_ip_address, :username
+
+        scp_options = {:port => ssh_port}
+        scp_options[:key_data] = [private_key] if private_key
+        Fog::SCP.new(public_ip_address, username, scp_options).download(remote_path, local_path, download_options)
+      end
+
+      def ssh(commands, options={}, &blk)
+        require 'net/ssh'
+        requires :public_ip_address, :username
+
+        options[:key_data] = [private_key] if private_key
+        options[:port] ||= ssh_port
+        Fog::SSH.new(public_ip_address, username, options).run(commands, &blk)
+      end
+
+      def ssh_port
+        22
+      end
+
+      def sshable?
+        ready? && !public_ip_address.nil? && !!Timeout::timeout(8) { ssh 'pwd' }
+      rescue SystemCallError, Net::SSH::AuthenticationFailed, Timeout::Error
+        false
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+__LIB_DIR__ = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+$LOAD_PATH.unshift __LIB_DIR__ unless
+  $LOAD_PATH.include?(__LIB_DIR__)
+
+# external core dependencies
+require 'base64'
+require 'cgi'
+require 'uri'
+require 'excon'
+require 'fileutils'
+require 'formatador'
+require 'openssl'
+require 'time'
+require 'timeout'
+
+# internal core dependencies
+require "fog/version"
+require 'fog/core/attributes'
+require 'fog/core/collection'
+require 'fog/core/connection'
+require 'fog/core/credentials'
+require 'fog/core/current_machine'
+require 'fog/core/deprecation'
+require 'fog/core/errors'
+require 'fog/core/hmac'
+require 'fog/core/json'
+require 'fog/core/logger'
+require 'fog/core/model'
+require 'fog/core/mock'
+#require 'fog/core/parser' # FIXME: would be better to only load when nokogiri is required
+require 'fog/core/provider'
+require 'fog/core/service'
+require 'fog/core/ssh'
+require 'fog/core/scp'
+require 'fog/core/time'
+require 'fog/core/timeout'
+require 'fog/core/wait_for'

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

@@ -0,0 +1,221 @@
+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'
+                true
+              when false,'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.has_key?(:'#{squash}')
+                    attributes[:#{name}] = new_data[:'#{squash}']
+                  elsif new_data.has_key?("#{squash}")
+                    attributes[:#{name}] = 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.collect {|attr| attr.to_s }
+      end
+
+      def ignored_attributes
+        @ignored_attributes ||= []
+      end
+
+    end
+
+    module InstanceMethods
+
+      def _dump(level)
+        Marshal.dump(attributes)
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def dup
+        copy = super
+        copy.dup_attributes!
+        copy
+      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 self.respond_to?("#{key}=",true)
+              send("#{key}=", value)
+            else
+              attributes[key] = value
+            end
+          end
+        end
+        self
+      end
+
+      # Returns true if a remote resource has been assigned an
+      # identity and we can assume it has been persisted.
+      #
+      # @return [Boolean]
+      def persisted?
+        !!identity
+      end
+
+      # Returns true if a remote resource has not been assigned an
+      # identity.
+      #
+      # This was added for a ActiveRecord like feel but has been
+      # outdated by ActiveModel API using {#persisted?}
+      #
+      # @deprecated Use inverted form of {#persisted?}
+      # @return [Boolean]
+      def new_record?
+        Fog::Logger.deprecation("#new_record? is deprecated, use !persisted? instead [light_black](#{caller.first})[/]")
+        !persisted?
+      end
+
+      # check that the attributes specified in args exist and is not nil
+      def requires(*args)
+        missing = missing_attributes(args)
+        if missing.length == 1
+          raise(ArgumentError, "#{missing.first} is required for this operation")
+        elsif missing.any?
+          raise(ArgumentError, "#{missing[0...-1].join(", ")} and #{missing[-1]} are required for this operation")
+        end
+      end
+
+      def requires_one(*args)
+        missing = missing_attributes(args)
+        if missing.length == args.length
+          raise(ArgumentError, "#{missing[0...-1].join(", ")} or #{missing[-1]} are required for this operation")
+        end
+      end
+
+      protected
+
+      def missing_attributes(args)
+        missing = []
+        for arg in [:service] | args
+          unless send("#{arg}") || attributes.has_key?(arg)
+            missing << arg
+          end
+        end
+        missing
+      end
+
+      def dup_attributes!
+        @attributes = @attributes.dup if @attributes
+      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