brightbox-cli 0.13.0

data/lib/brightbox-cli/vendor/fog/lib/fog/terremark/requests/shared/power_reset.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Terremark
+    module Shared
+      module Real
+
+        # Reset a vapp
+        #
+        # ==== Parameters
+        # * vapp_id<~Integer> - Id of vapp to reset
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'endTime'<~String> - endTime of task
+        #     * 'href'<~String> - link to task
+        #     * 'startTime'<~String> - startTime of task
+        #     * 'status'<~String> - status of task
+        #     * 'type'<~String> - type of task
+        #     * 'Owner'<~String> -
+        #       * 'href'<~String> - href of owner
+        #       * 'name'<~String> - name of owner
+        #       * 'type'<~String> - type of owner
+        def power_reset(vapp_id)
+          request(
+            :expects  => 202,
+            :method   => 'POST',
+            :parser   => Fog::Parsers::Terremark::Shared::Task.new,
+            :path     => "vApp/#{vapp_id}/power/action/reset"
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/terremark/requests/shared/power_shutdown.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Terremark
+    module Shared
+      module Real
+
+        # Shutdown a vapp
+        #
+        # ==== Parameters
+        # * vapp_id<~Integer> - Id of vapp to shutdown
+        #
+        # ==== Returns
+        # Nothing
+        def power_shutdown(vapp_id)
+          request(
+            :expects  => 204,
+            :method   => 'POST',
+            :path     => "vApp/#{vapp_id}/power/action/shutdown"
+          )
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,293 @@
+module Fog
+  module Terremark
+    module Shared
+
+      # Commond methods shared by Real and Mock
+      module Common
+
+        def default_organization_id
+          @default_organization_id ||= begin
+            org_list = get_organizations.body['OrgList']
+            if org_list.length == 1
+              org_list.first['href'].split('/').last.to_i
+            else
+              nil
+            end
+          end
+        end
+
+      end
+
+      module Parser
+
+        def parse(data)
+          case data['type']
+          when 'application/vnd.vmware.vcloud.vApp+xml'
+            servers.new(data.merge!(:connection => self))
+          else
+            data
+          end
+        end
+
+      end
+
+      module Real
+        include Common
+
+        private
+
+        def auth_token
+          response = @connection.request({
+            :expects   => 200,
+            :headers   => {
+              'Authorization' => "Basic #{Base64.encode64("#{@terremark_username}:#{@terremark_password}").chomp!}",
+              'Content-Type'  => "application/vnd.vmware.vcloud.orgList+xml"
+            },
+            :host      => @host,
+            :method    => 'POST',
+            :parser    => Fog::Parsers::Terremark::Shared::GetOrganizations.new,
+            :path      => "#{@path}/login"
+          })
+          response.headers['Set-Cookie']
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          unless @cookie
+            @cookie = auth_token
+          end
+          begin
+            do_request(params)
+          rescue Excon::Errors::Unauthorized => e
+            @cookie = auth_token
+            do_request(params)
+          end
+        end
+
+        def do_request(params)
+          headers = {}
+          if @cookie
+            headers.merge!('Cookie' => @cookie)
+          end
+          @connection.request({
+            :body     => params[:body],
+            :expects  => params[:expects],
+            :headers  => headers.merge!(params[:headers] || {}),
+            :host     => @host,
+            :method   => params[:method],
+            :parser   => params[:parser],
+            :path     => "#{@path}/#{params[:path]}"
+          })
+        end
+
+      end
+
+      module Mock
+        include Common
+
+        def self.mock_data
+        {
+          :organizations =>
+          [
+            {
+              :info => {
+                :name => "Boom Inc.",
+                :id => 1
+              },
+              :vdcs => [
+                { :id => 21,
+                  :name => "Boomstick",
+                  :storage => { :used => 105, :allocated => 200 },
+                  :cpu => { :allocated => 10000 },
+                  :memory => { :allocated => 20480 },
+                  :networks => [
+                    { :id => 31,
+                      :name => "1.2.3.0/24",
+                      :subnet => "1.2.3.0/24",
+                      :gateway => "1.2.3.1",
+                      :netmask => "255.255.255.0",
+                      :fencemode => "isolated"
+                    },
+                    { :id => 32,
+                      :name => "4.5.6.0/24",
+                      :subnet => "4.5.6.0/24",
+                      :gateway => "4.5.6.1",
+                      :netmask => "255.255.255.0",
+                      :fencemode => "isolated"
+                    },
+                  ],
+                  :vms => [
+                    { :id => 41,
+                      :name => "Broom 1"
+                    },
+                    { :id => 42,
+                      :name => "Broom 2"
+                    },
+                    { :id => 43,
+                      :name => "Email!"
+                    }
+                  ],
+                  :public_ips => [
+                    { :id => 51,
+                      :name => "99.1.2.3"
+                    },
+                    { :id => 52,
+                      :name => "99.1.2.4"
+                    },
+                    { :id => 53,
+                      :name => "99.1.9.7"
+                    }
+                  ]
+                },
+                { :id => 22,
+                  :storage => { :used => 40, :allocated => 150 },
+                  :cpu => { :allocated => 1000 },
+                  :memory => { :allocated => 2048 },
+                  :name => "Rock-n-Roll",
+                  :networks => [
+                    { :id => 33,
+                      :name => "7.8.9.0/24",
+                      :subnet => "7.8.9.0/24",
+                      :gateway => "7.8.9.1",
+                      :netmask => "255.255.255.0",
+                      :fencemode => "isolated"
+                    }
+                  ],
+                  :vms => [
+                    { :id => 44,
+                      :name => "Master Blaster"
+                    }
+                  ],
+                  :public_ips => [
+                    { :id => 54,
+                      :name => "99.99.99.99"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+        end
+
+        def self.error_headers
+          {"X-Powered-By"=>"ASP.NET",
+           "Date"=> Time.now.to_s,
+           "Content-Type"=>"text/html",
+           "Content-Length"=>"0",
+           "Server"=>"Microsoft-IIS/7.0",
+           "Cache-Control"=>"private"}
+        end
+
+        def self.unathorized_status
+          401
+        end
+
+        def self.headers(body, content_type)
+          {"X-Powered-By"=>"ASP.NET",
+           "Date"=> Time.now.to_s,
+           "Content-Type"=> content_type,
+           "Content-Length"=> body.to_s.length,
+           "Server"=>"Microsoft-IIS/7.0",
+           "Set-Cookie"=>"vcloud-token=ecb37bfc-56f0-421d-97e5-bf2gdf789457; path=/",
+           "Cache-Control"=>"private"}
+        end
+
+        def self.status
+          200
+        end
+
+        def initialize(options={})
+          self.class.instance_eval '
+            def self.data
+              @data ||= Hash.new do |hash, key|
+                hash[key] = Fog::Terremark::Shared::Mock.mock_data
+              end
+            end'
+          self.class.instance_eval '
+            def self.reset
+              @data = nil
+            end
+
+            def self.reset_data(keys=data.keys)
+              for key in [*keys]
+                data.delete(key)
+              end
+            end'
+        end
+      end
+
+      def check_shared_options(options)
+        %w{ecloud vcloud}.each do |cloud|
+          cloud_option_keys = options.keys.select { |key| key.to_s =~ /^terremark_#{cloud}_.*/ }
+          unless cloud_option_keys.length == 0 || cloud_option_keys.length == 2
+            raise ArgumentError.new("terremark_#{cloud}_username and terremark_#{cloud}_password required to access teremark")
+          end
+        end
+      end
+
+      def shared_requires
+        require 'fog/terremark/models/shared/address'
+        require 'fog/terremark/models/shared/addresses'
+        require 'fog/terremark/models/shared/network'
+        require 'fog/terremark/models/shared/networks'
+        require 'fog/terremark/models/shared/server'
+        require 'fog/terremark/models/shared/servers'
+        require 'fog/terremark/models/shared/task'
+        require 'fog/terremark/models/shared/tasks'
+        require 'fog/terremark/models/shared/vdc'
+        require 'fog/terremark/models/shared/vdcs'
+        require 'fog/terremark/parsers/shared/get_catalog'
+        require 'fog/terremark/parsers/shared/get_catalog_item'
+        require 'fog/terremark/parsers/shared/get_internet_services'
+        require 'fog/terremark/parsers/shared/get_network_ips'
+        require 'fog/terremark/parsers/shared/get_node_services'
+        require 'fog/terremark/parsers/shared/get_organization'
+        require 'fog/terremark/parsers/shared/get_organizations'
+        require 'fog/terremark/parsers/shared/get_public_ips'
+        require 'fog/terremark/parsers/shared/get_tasks_list'
+        require 'fog/terremark/parsers/shared/get_vapp_template'
+        require 'fog/terremark/parsers/shared/get_vdc'
+        require 'fog/terremark/parsers/shared/instantiate_vapp_template'
+        require 'fog/terremark/parsers/shared/internet_service'
+        require 'fog/terremark/parsers/shared/network'
+        require 'fog/terremark/parsers/shared/node_service'
+        require 'fog/terremark/parsers/shared/public_ip'
+        require 'fog/terremark/parsers/shared/task'
+        require 'fog/terremark/parsers/shared/vapp'
+        require 'fog/terremark/requests/shared/add_internet_service'
+        require 'fog/terremark/requests/shared/add_node_service'
+        require 'fog/terremark/requests/shared/create_internet_service'
+        require 'fog/terremark/requests/shared/delete_internet_service'
+        require 'fog/terremark/requests/shared/delete_public_ip'
+        require 'fog/terremark/requests/shared/delete_node_service'
+        require 'fog/terremark/requests/shared/delete_vapp'
+        require 'fog/terremark/requests/shared/deploy_vapp'
+        require 'fog/terremark/requests/shared/get_catalog'
+        require 'fog/terremark/requests/shared/get_catalog_item'
+        require 'fog/terremark/requests/shared/get_internet_services'
+        require 'fog/terremark/requests/shared/get_network'
+        require 'fog/terremark/requests/shared/get_network_ips'
+        require 'fog/terremark/requests/shared/get_node_services'
+        require 'fog/terremark/requests/shared/get_organization'
+        require 'fog/terremark/requests/shared/get_organizations'
+        require 'fog/terremark/requests/shared/get_public_ip'
+        require 'fog/terremark/requests/shared/get_public_ips'
+        require 'fog/terremark/requests/shared/get_task'
+        require 'fog/terremark/requests/shared/get_tasks_list'
+        require 'fog/terremark/requests/shared/get_vapp'
+        require 'fog/terremark/requests/shared/get_vapp_template'
+        require 'fog/terremark/requests/shared/get_vdc'
+        require 'fog/terremark/requests/shared/instantiate_vapp_template'
+        require 'fog/terremark/requests/shared/power_off'
+        require 'fog/terremark/requests/shared/power_on'
+        require 'fog/terremark/requests/shared/power_reset'
+        require 'fog/terremark/requests/shared/power_shutdown'
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module Fog
+  module Terremark
+   module Vcloud
+
+     module Bin
+     end
+
+     module Defaults
+       HOST   = 'services.vcloudexpress.terremark.com'
+       PATH   = '/api/v0.8'
+       PORT   = 443
+       SCHEME = 'https'
+     end
+
+     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)
+
+       unless @required
+         shared_requires
+         @required = true
+       end
+
+       check_shared_options(options)
+
+       if Fog.mocking?
+          Fog::Terremark::Vcloud::Mock.new(options)
+       else
+          Fog::Terremark::Vcloud::Real.new(options)
+       end
+     end
+
+     class Real
+
+       include Fog::Terremark::Shared::Real
+       include Fog::Terremark::Shared::Parser
+
+        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])
+        end
+
+        def default_vdc_id
+          if default_organization_id
+            @default_vdc_id ||= begin
+              vdcs = get_organization(default_organization_id).body['Links'].select {|link|
+                link['type'] == 'application/vnd.vmware.vcloud.vdc+xml'
+              }
+              if vdcs.length == 1
+                vdcs.first['href'].split('/').last.to_i
+              else
+                nil
+              end
+            end
+          else
+            nil
+          end
+        end
+
+        def default_network_id
+          if default_vdc_id
+            @default_network_id ||= begin
+              networks = get_vdc(default_vdc_id).body['AvailableNetworks']
+              if networks.length == 1
+                networks.first['href'].split('/').last.to_i
+              else
+                nil
+              end
+            end
+          else
+            nil
+          end
+        end
+
+        def default_public_ip_id
+          if default_vdc_id
+            @default_public_ip_id ||= begin
+              ips = get_public_ips(default_vdc_id).body['PublicIpAddresses']
+              if ips.length == 1
+                ips.first['href'].split('/').last.to_i
+              else
+                nil
+              end
+            end
+          else
+            nil
+          end
+        end
+     end
+
+     class Mock
+       include Fog::Terremark::Shared::Mock
+       include Fog::Terremark::Shared::Parser
+
+       def initialize(option = {})
+         super
+         @base_url = Fog::Terremark::Vcloud::Defaults::SCHEME + "://" +
+                     Fog::Terremark::Vcloud::Defaults::HOST +
+                     Fog::Terremark::Vcloud::Defaults::PATH
+
+         @terremark_username = options[:terremark_vcloud_username]
+       end
+
+       def data
+         self.class.data[@terremark_username]
+       end
+
+       def reset_data
+         self.class.data.delete(@terremark_username)
+       end
+
+     end
+
+   end
+  end
+end
+
+

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

@@ -0,0 +1,11 @@
+require 'fog/core'
+
+require 'fog/terremark/shared'
+require 'fog/terremark/parser'
+require 'fog/terremark/vcloud'
+
+module Fog
+  module Terremark
+    VCLOUD_OPTIONS = [:terremark_vcloud_username, :terremark_vcloud_password]
+  end
+end

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

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'fog', 'core')
+
+module Fog
+
+  unless const_defined?(:VERSION)
+    VERSION = '0.11.0'
+  end
+
+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/cdn'
+require 'fog/dns'
+require 'fog/storage'

data/lib/brightbox-cli/vendor/fog/spec/core/current_machine_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'fog/core/current_machine'
+
+describe Fog::CurrentMachine do
+  context '#ip_address' do
+    before(:each){ described_class.ip_address = nil }
+
+    it 'should be threadsafe' do
+      Net::HTTP.should_receive(:get_response).once{ Struct.new(:body).new('') }
+
+      (1..10).map {
+        Thread.new { described_class.ip_address }
+      }.each{ |t| t.join }
+    end
+
+    it 'should remove trailing endline characters' do
+      Net::HTTP.stub(:get_response){ Struct.new(:body).new("192.168.0.1\n") }
+
+      described_class.ip_address.should == '192.168.0.1'
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/spec/ecloud/bin_spec.rb

@@ -0,0 +1,28 @@
+require 'ecloud/spec_helper'
+
+describe 'Ecloud' do
+
+  it do
+    pending unless Ecloud.available?
+    Ecloud.should have_at_least(1).services
+  end
+
+  describe "when indexing it like an array" do
+
+
+    describe "with a service that exists" do
+      it "should return something when indexed with a configured service" do
+        pending unless Ecloud.available?
+        Fog::Compute[:ecloud].should_not be_nil
+      end
+    end
+
+    describe "with a service that does not exist" do
+      it "should raise an ArgumentError" do
+        pending unless Ecloud.available?
+        lambda {Ecloud[:foozle]}.should raise_error(ArgumentError)
+      end
+    end
+
+  end
+end

data/lib/brightbox-cli/vendor/fog/spec/ecloud/models/backup_internet_service_spec.rb

@@ -0,0 +1,48 @@
+require 'ecloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Compute::Ecloud::BackupInternetService", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud.vdcs[0].backup_internet_services[0] }
+
+    describe :class do
+      subject { Fog::Compute::Ecloud::BackupInternetService }
+
+      it { should have_identity(:href) }
+      it { should have_only_these_attributes([:href, :name, :id, :protocol, :enabled, :description, :timeout, :redirect_url, :monitor]) }
+    end
+
+    context "with no uri" do
+
+      subject { Fog::Compute::Ecloud::BackupInternetService.new() }
+      it { should have_all_attributes_be_nil }
+
+    end
+
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].backup_internet_services[0].reload }
+
+      let(:composed_service_data) { @vcloud.vdcs[0].backup_internet_services[0].send(:_compose_service_data) }
+
+      it { should be_an_instance_of(Fog::Compute::Ecloud::BackupInternetService) }
+
+      its(:href)                  { should == @mock_backup_service.href }
+      its(:identity)              { should == @mock_backup_service.href }
+      its(:name)                  { should == @mock_backup_service.name }
+      its(:id)                    { should == @mock_backup_service.object_id.to_s }
+      its(:protocol)              { should == @mock_backup_service.protocol }
+      its(:enabled)               { should == @mock_backup_service.enabled.to_s }
+      its(:description)           { should == @mock_backup_service.description }
+      its(:timeout)               { should == @mock_backup_service.timeout.to_s }
+      its(:redirect_url)          { should == (@mock_backup_service.redirect_url || "") }
+      its(:monitor)               { should == nil }
+
+      specify { composed_service_data[:href].should == subject.href.to_s }
+      specify { composed_service_data[:name].should == subject.name }
+      specify { composed_service_data[:id].should == subject.id.to_s }
+      specify { composed_service_data[:protocol].should == subject.protocol }
+      specify { composed_service_data[:enabled].should == subject.enabled.to_s }
+      specify { composed_service_data[:description].should == subject.description }
+      specify { composed_service_data[:timeout].should == subject.timeout.to_s }
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/spec/ecloud/models/backup_internet_services_spec.rb

@@ -0,0 +1,28 @@
+require 'ecloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Compute::Ecloud::InternetServices", :type => :mock_tmrk_ecloud_model do
+    context "as an attribute of a VDC" do
+      subject { @vcloud.vdcs[0] }
+
+      it { should respond_to(:backup_internet_services) }
+
+      describe :class do
+        subject { @vcloud.vdcs[0].backup_internet_services.class }
+        its(:model)       { should == Fog::Compute::Ecloud::BackupInternetService }
+      end
+
+      describe :backup_internet_services do
+        subject { @vcloud.vdcs[0].backup_internet_services }
+
+        it { should respond_to(:create) }
+
+        it { should be_an_instance_of(Fog::Compute::Ecloud::BackupInternetServices) }
+
+        its(:length) { should == 1 }
+
+        it { should(have_members_of_the_right_model) }
+      end
+    end
+  end
+end