bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws.rb

@@ -0,0 +1,214 @@
+require 'nokogiri'
+require 'fog/core/parser'
+
+module Fog
+  module AWS
+
+    extend Fog::Provider
+
+    service_path 'fog/aws'
+    service 'cdn'
+    service 'compute'
+    service 'ec2'
+    service 'elb'
+    service 'iam'
+    service 's3'
+    service 'simpledb'
+    service 'storage'
+
+    def self.indexed_param(key, values)
+      params = {}
+      unless key.include?('%d')
+        key << '.%d'
+      end
+      [*values].each_with_index do |value, index|
+        params[format(key, index + 1)] = value
+      end
+      params
+    end
+
+    def self.indexed_filters(filters)
+      params = {}
+      filters.keys.each_with_index do |key, key_index|
+        key_index += 1
+        params[format('Filter.%d.Name', key_index)] = key
+        [*filters[key]].each_with_index do |value, value_index|
+          value_index += 1
+          params[format('Filter.%d.Value.%d', key_index, value_index)] = value
+        end
+      end
+      params
+    end
+
+    def self.signed_params(params, options = {})
+      params.merge!({
+        'AWSAccessKeyId'    => options[:aws_access_key_id],
+        'SignatureMethod'   => 'HmacSHA256',
+        'SignatureVersion'  => '2',
+        'Timestamp'         => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        'Version'           => options[:version]
+      })
+
+      body = ''
+      for key in params.keys.sort
+        unless (value = params[key]).nil?
+          body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
+        end
+      end
+      string_to_sign = "POST\n#{options[:host]}\n#{options[:path]}\n" << body.chop
+      signed_string = options[:hmac].sign(string_to_sign)
+      body << "Signature=#{CGI.escape(Base64.encode64(signed_string).chomp!).gsub(/\+/, '%20')}"
+
+      body
+    end
+
+    class Mock
+
+      def self.availability_zone
+        "us-east-1" << random_selection('abcd', 1)
+      end
+
+      def self.box_usage
+        sprintf("%0.10f", rand / 100).to_f
+      end
+
+      def self.dns_name_for(ip_address)
+        "ec2-#{ip_address.gsub('.','-')}.compute-1.amazonaws.com"
+      end
+
+      def self.private_dns_name_for(ip_address)
+        "ip-#{ip_address.gsub('.','-')}.ec2.internal"
+      end
+
+      def self.etag
+        hex(32)
+      end
+
+      def self.image
+        path = []
+        (rand(3) + 2).times do
+          path << letters(rand(9) + 8)
+        end
+        {
+          "imageOwnerId"   => letters(rand(5) + 4),
+          "blockDeviceMapping" => [],
+          "productCodes"   => [],
+          "kernelId"       => kernel_id,
+          "ramdiskId"      => ramdisk_id,
+          "imageState"     => "available",
+          "imageId"        => image_id,
+          "architecture"   => "i386",
+          "isPublic"       => true,
+          "imageLocation"  => path.join('/'),
+          "imageType"      => "machine",
+          "rootDeviceType" => ["ebs","instance-store"][rand(2)],
+          "rootDeviceName" => "/dev/sda1"
+        }
+      end
+
+      def self.image_id
+        "ami-#{hex(8)}"
+      end
+
+      def self.key_fingerprint
+        fingerprint = []
+        20.times do
+          fingerprint << hex(2)
+        end
+        fingerprint.join(':')
+      end
+
+      def self.instance_id
+        "i-#{hex(8)}"
+      end
+
+      def self.ip_address
+        ip = []
+        4.times do
+          ip << numbers(rand(3) + 1).to_i.to_s # remove leading 0
+        end
+        ip.join('.')
+      end
+
+      def self.kernel_id
+        "aki-#{hex(8)}"
+      end
+
+      def self.key_material
+        key_material = ['-----BEGIN RSA PRIVATE KEY-----']
+        20.times do
+          key_material << base64(76)
+        end
+        key_material << base64(67) + '='
+        key_material << '-----END RSA PRIVATE KEY-----'
+        key_material.join("\n")
+      end
+
+      def self.owner_id
+        numbers(12)
+      end
+
+      def self.ramdisk_id
+        "ari-#{hex(8)}"
+      end
+
+      def self.request_id
+        request_id = []
+        request_id << hex(8)
+        3.times do
+          request_id << hex(4)
+        end
+        request_id << hex(12)
+        request_id.join('-')
+      end
+
+      def self.reservation_id
+        "r-#{hex(8)}"
+      end
+
+      def self.snapshot_id
+        "snap-#{hex(8)}"
+      end
+
+      def self.volume_id
+        "vol-#{hex(8)}"
+      end
+
+      private
+      
+      def self.random_selection(characters, length)
+        selection = ''
+        length.times do
+          position = rand(characters.length)
+          selection << characters[position..position]
+        end
+        selection
+      end
+
+      def self.letters(length)
+        random_selection(
+          'abcdefghijklmnopqrstuvwxyz',
+          length
+        )
+      end
+
+      def self.numbers(length)
+        max = ('9' * length).to_i
+        rand(max).to_s
+      end
+
+      def self.hex(length)
+        max = ('f' * length).to_i(16)
+        rand(max).to_s(16).rjust(length, '0')
+      end
+
+      def self.base64(length)
+        random_selection(
+          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+          length
+        )
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/bin.rb

@@ -0,0 +1,25 @@
+class Bluebox < Fog::Bin
+  class << self
+
+      def [](service)
+        @@connections ||= Hash.new do |hash, key|
+          hash[key] = case key
+          when :blocks
+            location = caller.first
+            warning = "[yellow][WARN] Bluebox[:blocks] is deprecated, use Bluebox[:compute] instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+            Fog::Bluebox::Compute.new
+          when :compute
+            Fog::Bluebox::Compute.new
+          end
+        end
+        @@connections[service]
+      end
+
+      def services
+        [:compute]
+      end
+
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/compute.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Bluebox
+    class Compute < Fog::Service
+
+      requires :bluebox_api_key, :bluebox_customer_id
+
+      model_path 'fog/bluebox/models/compute'
+      model       :flavor
+      collection  :flavors
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/bluebox/requests/compute'
+      request :create_block
+      request :destroy_block
+      request :get_block
+      request :get_blocks
+      request :get_product
+      request :get_products
+      request :get_template
+      request :get_templates
+      request :reboot_block
+
+      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={})
+          @bluebox_api_key = options[:bluebox_api_key]
+          @data = self.class.data[@bluebox_api_key]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'json'
+          @bluebox_api_key      = options[:bluebox_api_key]
+          @bluebox_customer_id  = options[:bluebox_customer_id]
+          @host   = options[:bluebox_host]    || "boxpanel.blueboxgrp.com"
+          @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].merge!({
+            'Authorization' => "Basic #{Base64.encode64([@bluebox_customer_id, @bluebox_api_key].join(':')).delete("\r\n")}"
+          })
+
+          begin
+            response = @connection.request(params.merge!({:host => @host}))
+          rescue Excon::Errors::Error => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Bluebox::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/models/compute/flavor.rb

@@ -0,0 +1,45 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :cost
+        attribute :description
+
+        def bits
+          # 64
+          raise StandardError.new("Figure me out!?!")
+        end
+
+        def cores
+          # # 2 quad-cores >= 2Ghz = 8 cores
+          # 8 * case ram
+          # when 256
+          #   1/64.0
+          # when 512
+          #   1/32.0
+          # when 1024
+          #   1/16.0
+          # when 2048
+          #   1/8.0
+          # when 4096
+          #   1/4.0
+          # when 8192
+          #   1/2.0
+          # when 15872
+          #   1
+          # end
+          raise StandardError.new("Figure me out!?!")
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/models/compute/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/bluebox/models/compute/flavor'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::Bluebox::Compute::Flavor
+
+        def all
+          data = connection.get_products.body
+          load(data)
+        end
+
+        def get(product_id)
+          response = connection.get_product(product_id)
+          new(response.body)
+        rescue Fog::Bluebox::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/models/compute/image.rb

@@ -0,0 +1,19 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :description
+        attribute :public
+        attribute :created_at, :aliases => 'created'
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/models/compute/images.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/bluebox/models/compute/image'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Images < Fog::Collection
+
+        model Fog::Bluebox::Compute::Image
+
+        def all
+          data = connection.get_templates.body
+          load(data)
+        end
+
+        def get(template_id)
+          response = connection.get_template(template_id)
+          new(response.body)
+        rescue Fog::Bluebox::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/models/compute/server.rb

@@ -0,0 +1,123 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class BlockInstantiationError < StandardError; end
+
+      class Server < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:ssh_key, :public_key)
+        deprecate(:ssh_key=, :public_key=)
+        deprecate(:user, :username)
+        deprecate(:user=, :username=)
+
+        identity :id
+
+        attribute :cpu
+        attribute :description
+        attribute :flavor_id,   :aliases => :product, :squash => 'id'
+        attribute :hostname
+        attribute :image_id
+        attribute :ips
+        attribute :memory
+        attribute :status
+        attribute :storage
+        attribute :template
+
+        attr_accessor :password
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.flavor_id ||= '94fd37a7-2606-47f7-84d5-9000deda52ae'
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.destroy_block(id)
+          true
+        end
+
+        def flavor
+          requires :flavor_id
+          connection.flavors.get(flavor_id)
+        end
+
+        def image
+          requires :image_id
+          connection.images.get(image_id)
+        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 ready?
+          status == 'running'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_block(id, type)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :flavor_id, :image_id
+          options = if !password && !public_key
+            raise(ArgumentError, "password or public_key is required for this operation")
+          elsif public_key
+            {'ssh_public_key' => public_key}
+          elsif @password
+            {'password' => password}
+          end
+          options['username'] = username
+          data = connection.create_block(flavor_id, image_id, options)
+          merge_attributes(data.body)
+          true
+        end
+
+        def setup(credentials = {})
+          requires :identity, :ips, :public_key, :username
+          Fog::SSH.new(ips.first['address'], username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l root},
+            %{echo "#{attributes.to_json}" >> ~/attributes.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :identity, :ips, :private_key, :username
+          Fog::SSH.new(ips.first['address'], username, :key_data => [private_key]).run(commands)
+        end
+
+        def username
+          @username ||= 'deploy'
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/models/compute/servers.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/bluebox/models/compute/server'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Servers < Fog::Collection
+
+        model Fog::Bluebox::Compute::Server
+
+        def all
+          data = connection.get_blocks.body
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server.setup(:key_data => [server.private_key])
+          server
+        end
+
+        def get(server_id)
+          if server_id && server = connection.get_block(server_id).body
+            new(server)
+          end
+        rescue Fog::Bluebox::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/requests/compute/create_block.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Bluebox
+    class Compute
+      class Real
+
+        # Create a new block
+        #
+        # ==== Parameters
+        # * product_id<~Integer> - Id of product to create block with
+        # * template_id<~Integer> - Id of template to create block with
+        # * options<~Hash>:
+        #     * password<~String> - Password for block
+        #   or
+        #     * ssh_key<~String> - ssh public key
+        #   * username<~String> - optional, defaults to deploy
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        # TODO
+        def create_block(product_id, template_id, options = {})
+          request(
+            :expects  => 200,
+            :method   => 'POST',
+            :path     => '/api/blocks.json',
+            :query    => {'product' => product_id, 'template' => template_id}.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_block(product_id, template_id, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/bluebox/requests/compute/destroy_block.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Bluebox
+    class Compute
+      class Real
+
+        # Destroy a block
+        #
+        # ==== Parameters
+        # * block_id<~Integer> - Id of block to destroy
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        # TODO
+        def destroy_block(block_id)
+          request(
+            :expects  => 200,
+            :method   => 'DELETE',
+            :path     => "api/blocks/#{block_id}.json"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def destroy_block(block_id)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end