brightbox-cli 0.13.1 → 0.14.0

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/compute.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'storm_on_demand'))
+require 'fog/compute'
+
+module Fog
+  module Compute
+    class StormOnDemand < Fog::Service
+
+      API_URL = 'https://api.stormondemand.com'
+
+      requires :storm_on_demand_username, :storm_on_demand_password
+      recognizes :storm_on_demand_auth_url
+
+      model_path 'fog/storm_on_demand/models/compute'
+      model       :config
+      collection  :configs
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+      model       :balancer
+      collection  :balancers
+      model       :private_ip
+      collection  :private_ips
+      model       :stat
+      collection  :stats
+      model       :template
+      collection  :templates
+
+      request_path 'fog/storm_on_demand/requests/compute'
+      request :clone_server
+      request :delete_server
+      request :reboot_server
+      request :list_servers
+      request :get_server
+      request :create_server
+      request :resize_server
+      request :remove_balancer_node
+      request :add_balancer_node
+      request :list_balancers
+      request :list_configs
+      request :list_templates
+      request :list_images
+      request :get_stats
+      request :list_private_ips      
+      
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :last_modified => {
+                :images  => {},
+                :servers => {}
+              },
+              :images  => {},
+              :servers => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @storm_on_demand_username = options[:storm_on_demand_username]
+        end
+
+        def data
+          self.class.data[@storm_on_demand_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@storm_on_demand_username)
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'multi_json'
+          uri = URI.parse(options[:storm_on_demand_auth_url] ||= API_URL)
+          @connection_options = options[:connection_options] || {}
+          @host       = uri.host
+          @path       = uri.path
+          @persistent = options[:persistent] || false
+          @port       = uri.port
+          @scheme     = uri.scheme
+          @storm_on_demand_username = options[:storm_on_demand_username]
+          @storm_on_demand_password = options[:storm_on_demand_password]
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge!({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'Authorization' => 'Basic ' << Base64.encode64("#{@storm_on_demand_username}:#{@storm_on_demand_password}").chomp
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}",
+              :expects  => 200,
+              :method   => :post
+            }))
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::StormOnDemand::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          if response.body.keys.include?('full_error')
+            raise(Fog::Compute::StormOnDemand::Error, response.body.inspect)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/balancers.rb

@@ -0,0 +1,21 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/balancer'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class Balancers < Fog::Collection
+
+        model Fog::Compute::StormOnDemand::Balancer
+
+        def all
+          data = connection.list_balancers.body['loadbalancers']
+          load(data)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/configs.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/config'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class Configs < Fog::Collection
+
+        model Fog::Compute::StormOnDemand::Config
+
+        def all
+          data = connection.list_configs.body['configs']
+          load(data)
+        end
+
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/images.rb

@@ -0,0 +1,21 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/image'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::StormOnDemand::Image
+
+        def all
+          data = connection.list_images.body['images']
+          load(data)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/private_ips.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/private_ip'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class PrivateIps < Fog::Collection
+
+        model Fog::Compute::StormOnDemand::PrivateIp
+
+        def all
+          data = connection.list_private_ips.body['networks']
+          load(data)
+        end
+
+        def get(server_id)
+          if server_id && server = connection.get_private_ip(private_ip).body
+            new(server)
+          elsif !server_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/servers.rb

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/server'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::StormOnDemand::Server
+
+        def all
+          data = connection.list_servers.body['servers']
+          load(data)
+        end
+
+        def get(uniq_id)
+          server = connection.get_server(:uniq_id => uniq_id).body
+          new(server)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/stats.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/stat'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class Stats < Fog::Collection
+        model Fog::Compute::StormOnDemand::Stat
+
+        def get(options)
+          data = connection.get_stats(options).body
+          load(data)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/storm_on_demand/models/compute/templates.rb

@@ -0,0 +1,21 @@
+require 'fog/core/collection'
+require 'fog/storm_on_demand/models/compute/template'
+
+module Fog
+  module Compute
+    class StormOnDemand
+
+      class Templates < Fog::Collection
+
+        model Fog::Compute::StormOnDemand::Template
+
+        def all
+          data = connection.list_templates.body['templates']
+          load(data)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/terremark.rb

@@ -1,4 +1,4 @@
-require 'fog/core'
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
 
 require 'fog/terremark/shared'
 require 'fog/terremark/parser'

data/lib/brightbox-cli/vendor/fog/lib/fog/terremark/vcloud.rb

@@ -15,10 +15,7 @@ module Fog
      extend Fog::Terremark::Shared
 
      def self.new(options={})
-       location = caller.first
-       warning = "[yellow][WARN] Fog::Terremark::Vcloud is deprecated, to be replaced with Vcloud 1.0 someday/maybe[/]"
-       warning << " [light_black](" << location << ")[/] "
-       Formatador.display_line(warning)
+       Fog::Logger.warning("Fog::Terremark::Vcloud is deprecated, to be replaced with Vcloud 1.0 someday/maybe [light_black](#{caller.first})[/]")
 
        unless @required
          shared_requires
@@ -42,11 +39,13 @@ module Fog
         def initialize(options={})
           @terremark_password = options[:terremark_vcloud_password]
           @terremark_username = options[:terremark_vcloud_username]
-          @host   = options[:host]   || Fog::Terremark::Vcloud::Defaults::HOST
-          @path   = options[:path]   || Fog::Terremark::Vcloud::Defaults::PATH
-          @port   = options[:port]   || Fog::Terremark::Vcloud::Defaults::PORT
-          @scheme = options[:scheme] || Fog::Terremark::Vcloud::Defaults::SCHEME
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+          @connection_options = options[:connection_options] || {}
+          @host       = options[:host]        || Fog::Terremark::Vcloud::Defaults::HOST
+          @path       = options[:path]        || Fog::Terremark::Vcloud::Defaults::PATH
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || Fog::Terremark::Vcloud::Defaults::PORT
+          @scheme     = options[:scheme]      || Fog::Terremark::Vcloud::Defaults::SCHEME
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end
 
         def default_vdc_id

data/lib/brightbox-cli/vendor/fog/lib/fog/vcloud.rb

@@ -0,0 +1,11 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module Vcloud
+
+    extend Fog::Provider
+
+    service(:compute, 'vcloud/compute')
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/vcloud/compute.rb

@@ -0,0 +1,311 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'vcloud'))
+require 'fog/compute'
+
+module Fog
+  module Vcloud
+    class Collection < Fog::Collection
+
+      def load(objects)
+        objects = [ objects ] if objects.is_a?(Hash)
+        super
+      end
+
+      def check_href!(opts = {})
+        self.href = connection.default_vdc_href unless href
+        unless href
+          if opts.is_a?(String)
+            t = Hash.new
+            t[:parent] = opts
+            opts = t
+          end
+          msg = ":href missing, call with a :href pointing to #{if opts[:message]
+                  opts[:message]
+                elsif opts[:parent]
+                  "the #{opts[:parent]} whos #{self.class.to_s.split('::').last.downcase} you want to enumerate"
+                else
+                  "the resource"
+                end}"
+          raise Fog::Errors::Error.new(msg)
+        end
+      end
+
+    end
+  end
+end
+
+module Fog
+  module Vcloud
+    class Model < Fog::Model
+
+      attr_accessor :loaded
+      alias_method :loaded?, :loaded
+
+      def reload
+        instance = super
+        @loaded = true
+        instance
+      end
+
+      def load_unless_loaded!
+        unless @loaded
+          reload
+        end
+      end
+
+    end
+  end
+end
+
+module Fog
+  module Vcloud
+    class Compute < Fog::Service
+
+      PATH   = '/api/v1.0'
+      PORT   = 443
+      SCHEME = 'https'
+
+      requires   :vcloud_username, :vcloud_password, :vcloud_host
+      recognizes :vcloud_port, :vcloud_scheme, :vcloud_path, :vcloud_default_vdc
+      recognizes :provider # remove post deprecation
+
+      model_path 'fog/vcloud/models/compute'
+      model :catalog
+      collection :catalogs
+      model :catalog_item
+      model :catalog_items
+      model :ip
+      collection :ips
+      model :network
+      collection :networks
+      model :server
+      collection :servers
+      model :task
+      collection :tasks
+      model :vdc
+      collection :vdcs
+
+      request_path 'fog/vcloud/requests/compute'
+      request :clone_vapp
+      request :configure_network
+      request :configure_network_ip
+      request :configure_vapp
+      request :configure_vm_memory
+      request :configure_vm_name_description
+      request :configure_vm_disks
+      request :delete_vapp
+      request :get_catalog
+      request :get_catalog_item
+      request :get_customization_options
+      request :get_network
+      request :get_network_ip
+      request :get_network_ips
+      request :get_network_extensions
+      request :get_organization
+      request :get_task
+      request :get_task_list
+      request :get_vapp
+      request :get_vapp_template
+      request :get_vm_disks
+      request :get_vm_memory
+      request :get_vdc
+      request :instantiate_vapp_template
+      request :login
+      request :power_off
+      request :power_on
+      request :power_reset
+      request :power_shutdown
+      request :undeploy
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        class << self
+
+          def basic_request(*args)
+            self.class_eval <<-EOS, __FILE__,__LINE__
+              def #{args[0]}(uri)
+                request({
+                  :expects => #{args[1] || 200},
+                  :method  => '#{args[2] || 'GET'}',
+                  :headers => #{args[3] ? args[3].inspect : '{}'},
+                  :body => '#{args[4] ? args[4] : ''}',
+                  :parse => true,
+                  :uri     => uri })
+              end
+            EOS
+          end
+
+          def unauthenticated_basic_request(*args)
+            self.class_eval <<-EOS, __FILE__,__LINE__
+              def #{args[0]}(uri)
+                unauthenticated_request({
+                  :expects => #{args[1] || 200},
+                  :method  => '#{args[2] || 'GET'}',
+                  :headers => #{args[3] ? args[3].inspect : '{}'},
+                  :parse => true,
+                  :uri     => uri })
+              end
+            EOS
+          end
+
+        end
+
+        def initialize(options = {})
+          require 'builder'
+          require 'fog/core/parser'
+
+          @connections = {}
+          @connection_options = options[:connection_options] || {}
+          @persistent = options[:persistent]
+
+          @username = options[:vcloud_username]
+          @password = options[:vcloud_password]
+          @host     = options[:vcloud_host]
+          @vdc_href     = options[:vcloud_default_vdc]
+          @path     = options[:vcloud_path]   || Fog::Vcloud::Compute::PATH
+          @port     = options[:vcloud_port]   || Fog::Vcloud::Compute::PORT
+          @scheme   = options[:vcloud_scheme] || Fog::Vcloud::Compute::SCHEME
+        end
+
+        def reload
+          @connections.each_value { |k,v| v.reset if v }
+        end
+
+        def default_organization_uri
+          @default_organization_uri ||= begin
+            unless @login_results
+              do_login
+            end
+            case @login_results.body[:Org]
+            when Array
+              @login_results.body[:Org].first[:href]
+            when Hash
+              @login_results.body[:Org][:href]
+            else
+              nil
+            end
+          end
+        end
+
+        def default_vdc_href
+          @vdc_href
+        end
+
+        # login handles the auth, but we just need the Set-Cookie
+        # header from that call.
+        def do_login
+          @login_results = login
+          @cookie = @login_results.headers['Set-Cookie']
+        end
+
+        def ensure_unparsed(uri)
+          if uri.is_a?(String)
+            uri
+          else
+            uri.to_s
+          end
+        end
+
+        def xmlns
+          { "xmlns" => "http://www.vmware.com/vcloud/v1",
+            "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+            "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
+            "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
+        end
+
+        # If the cookie isn't set, do a get_organizations call to set it
+        # and try the request.
+        # If we get an Unauthorized error, we assume the token expired, re-auth and try again
+        def request(params)
+          unless @cookie
+            do_login
+          end
+          begin
+            do_request(params)
+          rescue Excon::Errors::Unauthorized => e
+            do_login
+            do_request(params)
+          end
+        end
+
+        private
+
+        def ensure_parsed(uri)
+          if uri.is_a?(String)
+            URI.parse(uri)
+          else
+            uri
+          end
+        end
+
+        # Don't need to  set the cookie for these or retry them if the cookie timed out
+        def unauthenticated_request(params)
+          do_request(params)
+        end
+
+        def base_url
+          "#{@scheme}://#{@host}:#{@port}#{@path}"
+        end
+
+        # Use this to set the Authorization header for login
+        def authorization_header
+          "Basic #{Base64.encode64("#{@username}:#{@password}").chomp!}"
+        end
+
+        # Actually do the request
+        def do_request(params)
+          # Convert the uri to a URI if it's a string.
+          if params[:uri].is_a?(String)
+            params[:uri] = URI.parse(params[:uri])
+          end
+          host_url = "#{params[:uri].scheme}://#{params[:uri].host}#{params[:uri].port ? ":#{params[:uri].port}" : ''}"
+
+          # Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
+          # different hosts.
+          @connections[host_url] ||= Fog::Connection.new(host_url, @persistent, @connection_options)
+
+          # Set headers to an empty hash if none are set.
+          headers = params[:headers] || {}
+
+          # Add our auth cookie to the headers
+          if @cookie
+            headers.merge!('Cookie' => @cookie)
+          end
+
+          # Make the request
+          response = @connections[host_url].request({
+            :body     => params[:body] || '',
+            :expects  => params[:expects] || 200,
+            :headers  => headers,
+            :method   => params[:method] || 'GET',
+            :path     => params[:uri].path
+          })
+
+          # Parse the response body into a hash
+          #puts response.body
+          unless response.body.empty?
+            if params[:parse]
+              document = Fog::ToHashDocument.new
+              parser = Nokogiri::XML::SAX::PushParser.new(document)
+              parser << response.body
+              parser.finish
+
+              response.body = document.body
+            end
+          end
+
+          response
+        end
+
+      end
+
+    end
+  end
+end