cifrado 0.1

data/vendor/fog/lib/fog/network.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Network
+
+    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 :openstack
+        require 'fog/openstack/network'
+        Fog::Network::OpenStack.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} has no network service")
+      end
+    end
+
+    def self.providers
+      Fog.services[:network]
+    end
+
+  end
+end

data/vendor/fog/lib/fog/openstack.rb

@@ -0,0 +1,214 @@
+require 'fog/core'
+
+Cifrado::Log.debug 'Loading vendored fog'
+
+module Fog
+  module OpenStack
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error
+        attr_reader :response_data
+
+        def self.slurp(error)
+          if error.response.body.empty?
+            data = nil
+            message = nil
+          else
+            data = Fog::JSON.decode(error.response.body)
+            message = data['message']
+            if message.nil? and !data.values.first.nil?
+              message = data.values.first['message']
+            end
+          end
+
+          new_error = super(error, message)
+          new_error.instance_variable_set(:@response_data, data)
+          new_error
+        end
+      end
+
+      class ServiceUnavailable < ServiceError; end
+
+      class BadRequest < ServiceError
+        attr_reader :validation_errors
+
+        def self.slurp(error)
+          new_error = super(error)
+          unless new_error.response_data.nil? or new_error.response_data['badRequest'].nil?
+            new_error.instance_variable_set(:@validation_errors, new_error.response_data['badRequest']['validationErrors'])
+          end
+          new_error
+        end
+      end
+    end
+
+    service(:compute , 'openstack/compute' , 'Compute' )
+    service(:identity, 'openstack/identity', 'Identity')
+    service(:network, 'openstack/network', 'Network')
+    service(:storage, 'openstack/storage', 'Storage')
+
+    # legacy v1.0 style auth
+    def self.authenticate_v1(options, connection_options = {})
+      uri = options[:openstack_auth_uri]
+      connection = Fog::Connection.new(uri.to_s, false, connection_options)
+      @openstack_api_key  = options[:openstack_api_key]
+      @openstack_username = options[:openstack_username]
+
+      response = connection.request({
+        :expects  => [200, 204],
+        :headers  => {
+          'X-Auth-Key'  => @openstack_api_key,
+          'X-Auth-User' => @openstack_username
+        },
+        :host     => uri.host,
+        :method   => 'GET',
+        :path     =>  (uri.path and not uri.path.empty?) ? uri.path : 'v1.0'
+      })
+
+      return {
+        :token => response.headers['X-Auth-Token'],
+        :server_management_url => response.headers['X-Server-Management-Url'],
+        :identity_public_endpoint => response.headers['X-Keystone']
+      }
+    end
+
+    # Keystone Style Auth
+    def self.authenticate_v2(options, connection_options = {})
+      uri                   = options[:openstack_auth_uri]
+      tenant_name           = options[:openstack_tenant]
+      service_type          = options[:openstack_service_type]
+      service_name          = options[:openstack_service_name]
+      identity_service_type = options[:openstack_identity_service_type]
+      endpoint_type         = (options[:openstack_endpoint_type] || 'publicURL').to_s
+      openstack_region      = options[:openstack_region]
+
+
+      body = retrieve_tokens_v2(options, connection_options)
+      service = get_service(body, service_type, service_name)
+
+      options[:unscoped_token] = body['access']['token']['id']
+
+      unless service
+        unless tenant_name
+          response = Fog::Connection.new(
+            "#{uri.scheme}://#{uri.host}:#{uri.port}/v2.0/tenants", false, connection_options).request({
+            :expects => [200, 204],
+            :headers => {'Content-Type' => 'application/json',
+                         'Accept' => 'application/json',
+                         'X-Auth-Token' => body['access']['token']['id']},
+            :host    => uri.host,
+            :method  => 'GET'
+          })
+
+          body = Fog::JSON.decode(response.body)
+          if body['tenants'].empty?
+            raise Fog::Errors::NotFound.new('No Tenant Found')
+          else
+            options[:openstack_tenant] = body['tenants'].first['name']
+          end
+        end
+
+        body = retrieve_tokens_v2(options, connection_options)
+        service = get_service(body, service_type, service_name)
+
+      end
+
+      service['endpoints'] = service['endpoints'].select do |endpoint|
+        endpoint['region'] == openstack_region
+      end if openstack_region
+
+      if service['endpoints'].empty?
+        raise Errors::NotFound.new("No endpoints available for region '#{openstack_region}'")
+      end if openstack_region
+
+      unless service
+        available = body['access']['serviceCatalog'].map { |endpoint|
+          endpoint['type']
+        }.sort.join ', '
+
+        missing = service_type
+
+        message = "Could not find service #{missing}.  Have #{available}"
+
+        raise Fog::Errors::NotFound, message
+      end
+
+      if service['endpoints'].count > 1
+        regions = service["endpoints"].map{ |e| e['region'] }.uniq.join(',')
+        raise Fog::Errors::NotFound.new("Multiple regions available choose one of these '#{regions}'")
+      end
+
+      identity_service = get_service(body, identity_service_type) if identity_service_type
+      tenant = body['access']['token']['tenant']
+      user = body['access']['user']
+
+      management_url = service['endpoints'].detect{|s| s[endpoint_type]}[endpoint_type]
+      identity_url   = identity_service['endpoints'].detect{|s| s['publicURL']}['publicURL'] if identity_service
+
+      {
+        :user                     => user,
+        :tenant                   => tenant,
+        :identity_public_endpoint => identity_url,
+        :server_management_url    => management_url,
+        :token                    => body['access']['token']['id'],
+        :expires                  => body['access']['token']['expires'],
+        :current_user_id          => body['access']['user']['id'],
+        :unscoped_token           => options[:unscoped_token]
+      }
+
+    end
+
+    def self.get_service(body, service_type=[], service_name=nil)
+      body['access']['serviceCatalog'].detect do |s|
+        if service_name.nil? or service_name.empty?
+          service_type.include?(s['type'])
+        else
+          service_type.include?(s['type']) and s['name'] == service_name
+        end
+      end
+    end
+
+    def self.retrieve_tokens_v2(options, connection_options = {})
+      api_key     = options[:openstack_api_key].to_s
+      username    = options[:openstack_username].to_s
+      tenant_name = options[:openstack_tenant].to_s
+      auth_token  = options[:openstack_auth_token] || options[:unscoped_token]
+      uri         = options[:openstack_auth_uri]
+
+      connection = Fog::Connection.new(uri.to_s, false, connection_options)
+      request_body = {:auth => Hash.new}
+
+      if auth_token
+        request_body[:auth][:token] = {
+          :id => auth_token
+        }
+      else
+        request_body[:auth][:passwordCredentials] = {
+          :username => username,
+          :password => api_key
+        }
+      end
+      request_body[:auth][:tenantName] = tenant_name if tenant_name
+
+      response = connection.request({
+        :expects  => [200, 204],
+        :headers  => {'Content-Type' => 'application/json'},
+        :body     => Fog::JSON.encode(request_body),
+        :host     => uri.host,
+        :method   => 'POST',
+        :path     => (uri.path and not uri.path.empty?) ? uri.path : 'v2.0'
+      })
+
+      Fog::JSON.decode(response.body)
+    end
+    
+    # CGI.escape, but without special treatment on spaces
+    def self.escape(str,extra_exclude_chars = '')
+      str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+        '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+      end
+    end
+
+  end
+end

data/vendor/fog/lib/fog/openstack/README.identity.md

@@ -0,0 +1,69 @@
+# OpenStack Identity Service (Keystone) Example
+
+    require 'fog'
+    require 'pp'
+    
+    auth_url = "https://example.net/v2.0/tokens"
+    username = 'admin@example.net'
+    password = 'secret'
+    
+    keystone = Fog::Identity.new :provider           => 'OpenStack',
+                                 :openstack_auth_url => auth_url,
+                                 :openstack_username => username,
+                                 :openstack_api_key  => password
+                                 # Optional, self-signed certs
+                                 #:connection_options => { :ssl_verify_peer => false }
+    
+    #
+    # Listing keystone tenants
+    #
+    keystone.tenants.each do |tenant|
+      # <Fog::Identity::OpenStack::Tenant
+      #   id="46b4ab...",
+      #   description=nil,
+      #   enabled=1,
+      #   name="admin@example.net"
+      # >
+      #pp tenant
+    end
+    
+    #
+    # List users
+    #
+    keystone.users.each do |user|
+      # <Fog::Identity::OpenStack::User
+      #   id="c975f...",
+      #   email="quantum@example.net",
+      #   enabled=true,
+      #   name="quantum",
+      #   tenant_id="00928...",
+      #   password=nil
+      # >
+      # ...
+      #pp user
+    end
+    
+    #
+    # Create a new tenant
+    #
+    tenant = keystone.tenants.create :name        => 'rubiojr@example.net',
+                                     :description => 'My foo tenant'
+    
+    #
+    # Create a new user
+    #
+    user = keystone.users.create :name      => 'rubiojr@example.net',
+                                 :tenant_id => tenant.id,
+                                 :password  => 'rubiojr@example.net',
+                                 :email     => 'rubiojr@example.net'
+    
+    
+    # Find the recently created tenant
+    tenant = keystone.tenants.find { |t| t.name == 'rubiojr@example.net' }
+    # Destroy the tenant
+    tenant.destroy
+    
+    # Find the recently created user 
+    user = keystone.users.find { |u| u.name == 'rubiojr@example.net' }
+    # Destroy the user
+    user.destroy

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

@@ -0,0 +1,423 @@
+require 'fog/compute'
+require 'fog/openstack'
+
+module Fog
+  module Compute
+    class OpenStack < Fog::Service
+
+      requires :openstack_auth_url
+      recognizes :openstack_auth_token, :openstack_management_url,
+                 :persistent, :openstack_service_type, :openstack_service_name,
+                 :openstack_tenant,
+                 :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
+                 :current_user, :current_tenant, :openstack_region,
+                 :openstack_endpoint_type
+
+      ## MODELS
+      #
+      model_path 'fog/openstack/models/compute'
+      model       :server
+      collection  :servers
+      model       :image
+      collection  :images
+      model       :flavor
+      collection  :flavors
+      model       :metadatum
+      collection  :metadata
+      model       :address
+      collection  :addresses
+      model       :security_group
+      collection  :security_groups
+      model       :key_pair
+      collection  :key_pairs
+      model       :tenant
+      collection  :tenants
+      model       :volume
+      collection  :volumes
+      model       :network
+      collection  :networks
+      model       :snapshot
+      collection  :snapshots
+      model       :host
+      collection  :hosts
+
+      ## REQUESTS
+      #
+      request_path 'fog/openstack/requests/compute'
+
+      # Server CRUD
+      request :list_servers
+      request :list_servers_detail
+      request :create_server
+      request :get_server_details
+      request :update_server
+      request :delete_server
+
+      # Server Actions
+      request :server_actions
+      request :server_action
+      request :reboot_server
+      request :rebuild_server
+      request :resize_server
+      request :confirm_resize_server
+      request :revert_resize_server
+      request :pause_server
+      request :unpause_server
+      request :suspend_server
+      request :resume_server
+      request :rescue_server
+      request :change_server_password
+      request :add_fixed_ip
+      request :remove_fixed_ip
+      request :server_diagnostics
+      request :boot_from_snapshot
+      request :reset_server_state
+
+      # Server Extenstions
+      request :get_console_output
+      request :get_vnc_console
+      request :live_migrate_server
+      request :migrate_server
+
+      # Image CRUD
+      request :list_images
+      request :list_images_detail
+      request :create_image
+      request :get_image_details
+      request :delete_image
+
+      # Flavor CRUD
+      request :list_flavors
+      request :list_flavors_detail
+      request :get_flavor_details
+      request :create_flavor
+      request :delete_flavor
+
+      # Metadata
+      request :list_metadata
+      request :get_metadata
+      request :set_metadata
+      request :update_metadata
+      request :delete_metadata
+
+      # Address
+      request :list_addresses
+      request :list_address_pools
+      request :list_all_addresses
+      request :list_private_addresses
+      request :list_public_addresses
+      request :get_address
+      request :allocate_address
+      request :associate_address
+      request :release_address
+      request :disassociate_address
+
+      # Security Group
+      request :list_security_groups
+      request :get_security_group
+      request :create_security_group
+      request :create_security_group_rule
+      request :delete_security_group
+      request :delete_security_group_rule
+
+      # Key Pair
+      request :list_key_pairs
+      request :create_key_pair
+      request :delete_key_pair
+
+      # Tenant
+      request :list_tenants
+      request :set_tenant
+      request :get_limits
+
+      # Volume
+      request :list_volumes
+      request :create_volume
+      request :get_volume_details
+      request :delete_volume
+      request :attach_volume
+      request :detach_volume
+      request :get_server_volumes
+
+      request :create_volume_snapshot
+      request :list_snapshots
+      request :get_snapshot_details
+      request :delete_snapshot
+
+      # Usage
+      request :list_usages
+      request :get_usage
+
+      # Quota
+      request :get_quota
+      request :get_quota_defaults
+      request :update_quota
+
+      # Hosts
+      request :list_hosts
+      request :get_host_details
+
+
+      class Mock
+        attr_reader :auth_token
+        attr_reader :auth_token_expiration
+        attr_reader :current_user
+        attr_reader :current_tenant
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :last_modified => {
+                :images  => {},
+                :servers => {},
+                :key_pairs => {},
+                :security_groups => {},
+                :addresses => {}
+              },
+              :images  => {
+                "0e09fbd6-43c5-448a-83e9-0d3d05f9747e" => {
+                  "id"=>"0e09fbd6-43c5-448a-83e9-0d3d05f9747e",
+                  "name"=>"cirros-0.3.0-x86_64-blank",
+                  'progress'  => 100,
+                  'status'    => "ACTIVE",
+                  'updated'   => "",
+                  'minRam'    => 0,
+                  'minDisk'   => 0,
+                  'metadata'  => {},
+                  'links'     => [{"href"=>"http://nova1:8774/v1.1/admin/images/1", "rel"=>"self"}, {"href"=>"http://nova1:8774/admin/images/2", "rel"=>"bookmark"}]
+                }
+              },
+              :servers => {},
+              :key_pairs => {},
+              :security_groups => {
+                0 => {
+                  "id"          => 0,
+                  "tenant_id"   => Fog::Mock.random_hex(8),
+                  "name"        => "default",
+                  "description" => "default",
+                  "rules"       => [
+                    { "id"              => 0,
+                      "parent_group_id" => 0,
+                      "from_port"       => 68,
+                      "to_port"         => 68,
+                      "ip_protocol"     => "udp",
+                      "ip_range"        => { "cidr" => "0.0.0.0/0" },
+                      "group"           => {}, },
+                  ],
+                },
+              },
+              :server_security_group_map => {},
+              :addresses => {},
+              :quota => {
+                'security_group_rules' => 20,
+                'security_groups' => 10,
+                'injected_file_content_bytes' => 10240,
+                'injected_file_path_bytes' => 256,
+                'injected_files' => 5,
+                'metadata_items' => 128,
+                'floating_ips'   => 10,
+                'instances'      => 10,
+                'key_pairs'      => 10,
+                'gigabytes'      => 5000,
+                'volumes'        => 10,
+                'cores'          => 20,
+                'ram'            => 51200
+              }
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @openstack_username = options[:openstack_username]
+          @openstack_auth_uri = URI.parse(options[:openstack_auth_url])
+
+          @current_tenant = options[:openstack_tenant]
+
+          @auth_token = Fog::Mock.random_base64(64)
+          @auth_token_expiration = (Time.now.utc + 86400).iso8601
+
+          management_url = URI.parse(options[:openstack_auth_url])
+          management_url.port = 8774
+          management_url.path = '/v1.1/1'
+          @openstack_management_url = management_url.to_s
+
+          identity_public_endpoint = URI.parse(options[:openstack_auth_url])
+          identity_public_endpoint.port = 5000
+          @openstack_identity_public_endpoint = identity_public_endpoint.to_s
+        end
+
+        def data
+          self.class.data["#{@openstack_username}-#{@current_tenant}"]
+        end
+
+        def reset_data
+          self.class.data.delete("#{@openstack_username}-#{@current_tenant}")
+        end
+
+        def credentials
+          { :provider                 => 'openstack',
+            :openstack_auth_url       => @openstack_auth_uri.to_s,
+            :openstack_auth_token     => @auth_token,
+            :openstack_management_url => @openstack_management_url,
+            :openstack_identity_endpoint => @openstack_identity_public_endpoint }
+        end
+      end
+
+      class Real
+        attr_reader :auth_token
+        attr_reader :auth_token_expiration
+        attr_reader :current_user
+        attr_reader :current_tenant
+
+        def initialize(options={})
+          @openstack_auth_token = options[:openstack_auth_token]
+          @auth_token        = options[:openstack_auth_token]
+          @openstack_identity_public_endpoint = options[:openstack_identity_endpoint]
+
+          unless @auth_token
+            missing_credentials = Array.new
+            @openstack_api_key  = options[:openstack_api_key]
+            @openstack_username = options[:openstack_username]
+
+            missing_credentials << :openstack_api_key  unless @openstack_api_key
+            missing_credentials << :openstack_username unless @openstack_username
+            raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+          end
+
+          @openstack_tenant     = options[:openstack_tenant]
+          @openstack_auth_uri   = URI.parse(options[:openstack_auth_url])
+          @openstack_management_url       = options[:openstack_management_url]
+          @openstack_must_reauthenticate  = false
+          @openstack_service_type = options[:openstack_service_type] || ['nova', 'compute']
+          @openstack_service_name = options[:openstack_service_name]
+          @openstack_identity_service_type = options[:openstack_identity_service_type] || 'identity'
+          @openstack_endpoint_type = options[:openstack_endpoint_type] || 'publicURL'
+          @openstack_region      = options[:openstack_region]
+
+          @connection_options = options[:connection_options] || {}
+
+          @current_user = options[:current_user]
+          @current_tenant = options[:current_tenant]
+
+          authenticate
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def credentials
+          { :provider                 => 'openstack',
+            :openstack_auth_url       => @openstack_auth_uri.to_s,
+            :openstack_auth_token     => @auth_token,
+            :openstack_management_url => @openstack_management_url,
+            :openstack_identity_endpoint => @openstack_identity_public_endpoint,
+            :openstack_region         => @openstack_region,
+            :current_user             => @current_user,
+            :current_tenant           => @current_tenant }
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'Accept' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{@tenant_id}/#{params[:path]}",
+              :query    => params[:query] || ('ignore_awful_caching' << Time.now.to_i.to_s)
+            }))
+          rescue Excon::Errors::Unauthorized => error
+            if error.response.body != 'Bad username or password' # token expiration
+              @openstack_must_reauthenticate = true
+              authenticate
+              retry
+            else # Bad Credentials
+              raise error
+            end
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+              when Excon::Errors::NotFound
+                Fog::Compute::OpenStack::NotFound.slurp(error)
+              else
+                error
+              end
+          end
+
+          unless response.body.empty?
+            response.body = Fog::JSON.decode(response.body)
+          end
+
+          response
+        end
+
+        private
+
+        def authenticate
+          if !@openstack_management_url || @openstack_must_reauthenticate
+            options = {
+              :openstack_api_key    => @openstack_api_key,
+              :openstack_username   => @openstack_username,
+              :openstack_auth_token => @auth_token,
+              :openstack_auth_uri   => @openstack_auth_uri,
+              :openstack_region     => @openstack_region,
+              :openstack_tenant     => @openstack_tenant,
+              :openstack_service_type => @openstack_service_type,
+              :openstack_service_name => @openstack_service_name,
+              :openstack_identity_service_type => @openstack_identity_service_type,
+              :openstack_endpoint_type => @openstack_endpoint_type
+            }
+
+            if @openstack_auth_uri.path =~ /\/v2.0\//
+
+              credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)
+            else
+              credentials = Fog::OpenStack.authenticate_v1(options, @connection_options)
+            end
+
+            @current_user = credentials[:user]
+            @current_tenant = credentials[:tenant]
+
+            @openstack_must_reauthenticate = false
+            @auth_token               = credentials[:token]
+            @auth_token_expiration    = credentials[:expires]
+            @openstack_management_url = credentials[:server_management_url]
+            @openstack_identity_public_endpoint  = credentials[:identity_public_endpoint]
+          end
+
+          uri = URI.parse(@openstack_management_url)
+          @host   = uri.host
+          @path, @tenant_id = uri.path.scan(/(\/.*)\/(.*)/).flatten
+
+          @path.sub!(/\/$/, '')
+          unless @path.match(/1\.1|v2/)
+            raise Fog::OpenStack::Errors::ServiceUnavailable.new(
+                    "OpenStack binding only supports version 2 (a.k.a. 1.1)")
+          end
+
+          @port   = uri.port
+          @scheme = uri.scheme
+           
+          # Not all implementations have identity service in the catalog
+          if @openstack_identity_public_endpoint || @openstack_management_url
+            @identity_connection = Fog::Connection.new(
+              @openstack_identity_public_endpoint || @openstack_management_url,
+              false, @connection_options)
+          end
+
+          true
+        end
+
+      end
+    end
+  end
+end