fog 1.29.0 → 1.30.0

data/lib/fog/libvirt/requests/compute/list_volumes.rb

@@ -1,88 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def list_volumes(filter = { })
-          data = []
-          if filter.keys.empty?
-            raw_volumes do |pool|
-              pool.list_volumes.each do |volume_name|
-                data << volume_to_attributes(pool.lookup_volume_by_name(volume_name))
-              end
-            end
-          else
-            return [get_volume(filter)]
-          end
-          data.compact
-        end
-
-        private
-
-        def volume_to_attributes(vol)
-          format_type = xml_element(vol.xml_desc, "/volume/target/format", "type") rescue nil # not all volumes have types, e.g. LVM
-          return nil if format_type == "dir"
-
-          {
-            :pool_name   => vol.pool.name,
-            :key         => vol.key,
-            :id          => vol.key,
-            :path        => vol.path,
-            :name        => vol.name,
-            :format_type => format_type,
-            :allocation  => bytes_to_gb(vol.info.allocation),
-            :capacity    => bytes_to_gb(vol.info.capacity),
-          }
-        end
-
-        def bytes_to_gb bytes
-          bytes / 1024**3
-        end
-
-        def raw_volumes
-          client.list_storage_pools.each do |pool_name|
-            pool = client.lookup_storage_pool_by_name(pool_name)
-            yield(pool)
-          end
-        end
-
-        def get_volume filter = { }, raw = false
-          raw_volumes do |pool|
-            vol = case filter.keys.first
-                    when :name
-                      pool.lookup_volume_by_name(filter[:name]) rescue nil
-                    when :key
-                      pool.lookup_volume_by_key(filter[:key]) rescue nil
-                    when :path
-                      pool.lookup_volume_by_path(filter[:path]) rescue nil
-                  end
-            if vol
-              return raw ? vol : volume_to_attributes(vol)
-            end
-          end
-          { }
-        end
-      end
-
-      class Mock
-        def list_volumes(filters={ })
-          vol1 = mock_volume 'vol1'
-          vol2 = mock_volume 'vol2'
-          [vol1, vol2]
-        end
-
-        def mock_volume name
-          {
-              :pool_name   => 'vol.pool.name',
-              :key         => 'vol.key',
-              :id          => 'vol.key',
-              :path        => 'vol.path',
-              :name        => name,
-              :format_type => 'raw',
-              :allocation  => 123,
-              :capacity    => 123,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/fog/libvirt/requests/compute/mock_files/domain.xml

@@ -1,40 +0,0 @@
-<domain type='kvm'>
- <name>fog-449765558356062</name>
- <memory>262144</memory>
- <vcpu>1</vcpu>
- <os>
-  <type arch='x86_64'>hvm</type>
-  <boot dev='hd'/>
-  <boot dev='cdrom'/>
-  <boot dev='network'/>
- </os>
- <features>
-   <acpi/>
-   <apic/>
-   <pae/>
- </features>
- <clock offset='utc'/>
- <devices>
-  <interface type='network'>
-    <mac address="aa:bb:cc:dd:ee:ff" />
-    <source network='net1' />
-    <model type='virtio'/>
-  </interface>
-  <serial type='pty'>
-   <target port='0'/>
-  </serial>
-  <console type='pty'>
-    <target port='0'/>
-  </console>
-  <input type='mouse' bus='ps2'/>
-  <graphics type='vnc' port='-1' autoport='yes'/>
-  <video>
-   <model type='cirrus' vram='9216' heads='1'/>
-  </video>
-  <disk type='file' device='disk'>
-   <driver name='qemu' type='raw'/>
-   <source file='path/to/disk'/>
-   <target dev='vda' bus='virtio'/>
-  </disk>
- </devices>
-</domain>

data/lib/fog/libvirt/requests/compute/pool_action.rb

@@ -1,19 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def pool_action(uuid, action)
-          pool = client.lookup_storage_pool_by_uuid uuid
-          pool.send(action)
-          true
-        end
-      end
-
-      class Mock
-        def pool_action(uuid, action)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/libvirt/requests/compute/update_display.rb

@@ -1,31 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def update_display(options = { })
-          raise ArgumentError, "uuid is a required parameter" unless options.key? :uuid
-          display          = { }
-          display[:type]   = options[:type] || 'vnc'
-          display[:port]   = (options[:port] || -1).to_s
-          display[:listen] = options[:listen].to_s   if options[:listen]
-          display[:passwd] = options[:password].to_s if options[:password]
-          display[:autoport] = 'yes' if display[:port] == '-1'
-
-          builder = Nokogiri::XML::Builder.new { graphics_ (display) }
-          xml     = Nokogiri::XML(builder.to_xml).root.to_s
-
-          client.lookup_domain_by_uuid(options[:uuid]).update_device(xml, 0)
-          # if we got no exceptions, then we're good'
-          true
-        end
-      end
-
-      class Mock
-        def update_display(options = { })
-          raise ArgumentError, "uuid is a required parameter" unless options.key? :uuid
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/libvirt/requests/compute/vm_action.rb

@@ -1,19 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def vm_action(uuid, action)
-          domain = client.lookup_domain_by_uuid(uuid)
-          domain.send(action)
-          true
-        end
-      end
-
-      class Mock
-        def vm_action(uuid, action)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/libvirt/requests/compute/volume_action.rb

@@ -1,18 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def volume_action(key, action, options={})
-          get_volume({:key => key}, true).send(action)
-          true
-        end
-      end
-
-      class Mock
-        def volume_action(action, options={})
-          true
-        end
-      end
-    end
-  end
-end

data/spec/fog/bin/libvirt_spec.rb

@@ -1,10 +0,0 @@
-require "minitest/autorun"
-require "fog"
-require "fog/bin"
-require "helpers/bin"
-
-describe Libvirt do
-  include Fog::BinSpec
-
-  let(:subject) { Libvirt }
-end

data/tests/brightbox/compute/image_selector_tests.rb

@@ -1,103 +0,0 @@
-Shindo.tests("Fog::Brightbox::Compute::ImageSelector.new", ["brightbox"]) do
-
-  sample_images = [
-    {
-      "id" => "img-00000",
-      "name" => "Ubuntu Lucid 10.04 LTS",
-      "official" => true,
-      "arch" => "i686",
-      "created_at" => "2013-04-30T12:34:56"
-    },
-    {
-      "id" => "img-11111",
-      "name" => "ubuntu-precise-12.04-amd64-server",
-      "official" => false,
-      "arch" => "i686",
-      "created_at" => "2013-05-01T12:34:56"
-    },
-    {
-      "id" => "img-22222",
-      "name" => "ubuntu-quantal-12.10-i386-server",
-      "official" => true,
-      "arch" => "i686",
-      "created_at" => "2013-05-01T12:34:56"
-    },
-    {
-      "id" => "img-33333",
-      "name" => "ubuntu-raring-13.04-amd64-server",
-      "official" => true,
-      "arch" => "amd64",
-      "created_at" => "2013-05-01T12:34:56"
-    },
-    {
-      "id" => "img-44444",
-      "name" => "Fedora 17 server",
-      "official" => true,
-      "arch" => "i686",
-      "created_at" => "2013-05-01T12:34:56"
-    },
-    {
-      "id" => "img-ubuntu",
-      "name" => "ubuntu-raring-13.04-i386-server",
-      "official" => true,
-      "arch" => "i686",
-      "created_at" => "2013-05-01T12:34:56"
-    },
-  ]
-
-  @image_selector = Fog::Brightbox::Compute::ImageSelector.new(sample_images)
-
-  test("#respond_to?(:latest_ubuntu)") do
-    @image_selector.respond_to?(:latest_ubuntu)
-  end
-
-  tests("when there are sample of images") do
-    tests("#latest_ubuntu").returns("img-ubuntu") do
-      @image_selector.latest_ubuntu
-    end
-  end
-
-  tests("when only old format names are present") do
-    tests("#latest_ubuntu").returns("img-ubuntu") do
-      sample_images = [
-        {
-          "id" => "img-11111",
-          "name" => "Ubuntu Lucid 10.04 LTS server",
-          "official" => true,
-          "arch" => "i686",
-          "created_at" => "2013-05-01T12:34:56"
-        },
-        {
-          "id" => "img-22222",
-          "name" => "Ubuntu Quantal 12.10 server",
-          "official" => false,
-          "arch" => "x86_64",
-          "created_at" => "2013-05-01T12:34:56"
-        },
-        {
-          "id" => "img-ubuntu",
-          "name" => "Ubuntu Quantal 12.10 server",
-          "official" => true,
-          "arch" => "i686",
-          "created_at" => "2013-05-01T12:34:56"
-        },
-        {
-          "id" => "img-33333",
-          "name" => "Blank disk image",
-          "official" => true,
-          "arch" => "i686",
-          "created_at" => "2013-05-01T12:34:56"
-        }
-      ]
-      @image_selector = Fog::Brightbox::Compute::ImageSelector.new(sample_images)
-      @image_selector.latest_ubuntu
-
-    end
-  end
-
-  tests("when ") do
-    tests("#latest_ubuntu").returns(nil) do
-      Fog::Brightbox::Compute::ImageSelector.new([]).latest_ubuntu
-    end
-  end
-end

data/tests/google/credentials_tests.rb

@@ -1,73 +0,0 @@
-require 'google/api_client'
-
-Shindo.tests('Google | credentials', ['google']) do
-
-  tests('success') do
-    pending if Fog.mocking?
-
-    google_key_location = Fog.credentials[:google_key_location]
-    if google_key_location.nil?
-      tests('Needs a :google_key_location credentials key').pending
-    end
-    google_key_string = File.open(File.expand_path(google_key_location), 'rb') { |io| io.read }
-
-    tests("#using_p12_key_file").succeeds do
-      Fog::Compute::Google.new(:google_key_location => google_key_location,
-                               :google_key_string => nil,
-                               :google_json_key_location => nil,
-                               :google_json_key_string => nil)
-    end
-
-    tests("#using_p12_key_string").succeeds do
-      Fog::Compute::Google.new(:google_key_location => nil,
-                               :google_key_string => google_key_string,
-                               :google_json_key_location => nil,
-                               :google_json_key_string => nil)
-    end
-  end
-
-  tests('success') do
-    pending if Fog.mocking?
-
-    google_json_key_location = Fog.credentials[:google_json_key_location]
-    if google_json_key_location.nil?
-      tests('Needs a :google_json_key_location credentials key').pending
-    end
-    google_json_key_string = File.open(File.expand_path(google_json_key_location), 'rb') { |io| io.read }
-
-    tests("#using_json_key_file").succeeds do
-      Fog::Compute::Google.new(:google_key_location => nil,
-                               :google_key_string => nil,
-                               :google_json_key_location => google_json_key_location,
-                               :google_json_key_string => nil)
-    end
-
-    tests("#using_json_key_string").succeeds do
-      Fog::Compute::Google.new(:google_key_location => nil,
-                               :google_key_string => nil,
-                               :google_json_key_location => nil,
-                               :google_json_key_string => google_json_key_string)
-    end
-  end
-
-  tests('failure') do
-    tests("#missing_google_project").raises(ArgumentError, 'raises ArgumentError when google_project is missing') do
-       Fog::Compute::Google.new(:google_project => nil)
-    end
-
-    tests("#missing_google_client_email").raises(ArgumentError, 'raises ArgumentError when google_client_email is missing') do
-      pending if Fog.mocking? # Mock doesn't check google_client_email
-      Fog::Compute::Google.new(:google_client_email => nil,
-                               :google_json_key_location => nil) # JSON key overrides google_client_email
-    end
-
-    tests("#missing_keys").raises(ArgumentError, 'raises ArgumentError when google keys are missing') do
-      pending if Fog.mocking? # Mock doesn't check missing keys
-      Fog::Compute::Google.new(:google_key_location => nil,
-                               :google_key_string => nil,
-                               :google_json_key_location => nil,
-                               :google_json_key_string => nil)
-    end
-  end
-
-end

data/tests/google/helpers/google_tests_helper.rb

@@ -1,89 +0,0 @@
-require 'securerandom'
-
-# create a disk to be used in tests
-def create_test_disk(connection, zone)
-  zone = 'us-central1-a'
-  random_string = SecureRandom.hex
-
-  disk = connection.disks.create({
-    :name => "fog-test-disk-#{random_string}",
-    :size_gb => "10",
-    :zone => zone,
-    :source_image => "debian-7-wheezy-v20140408",
-  })
-  disk.wait_for { ready? }
-  disk
-end
-
-def create_test_http_health_check(connection)
-  random_string = SecureRandom.hex
-  health_check = connection.http_health_checks.create({
-      :name => "fog-test-check-#{random_string}"
-      })
-  health_check
-end
-
-def create_test_backend_service(connection)
-  random_string = SecureRandom.hex
-  health_check = create_test_http_health_check(connection)
-  backend_service = connection.backend_services.create({
-      :name => "fog-test-backend-service-#{random_string}",
-      :health_checks => [health_check]
-      })
-end
-
-def create_test_url_map(connection)
-  random_string = SecureRandom.hex
-  backend_service = create_test_backend_service(connection)
-  url_map = connection.url_maps.create({
-      :name => "fog-test-url-map-#{random_string}",
-      :defaultService => backend_service.self_link
-      })
-end
-
-def create_test_server(connection, zone)
-  random_string = SecureRandom.hex
-  disk = create_test_disk(connection,zone)
-  server = connection.servers.create({
-      :name => "fog-test-server-#{random_string}",
-      :disks => [disk],
-      :zone => zone,
-      :machine_type => 'n1-standard-1'
-      })
-end
-
-def create_test_target_http_proxy(connection)
-  random_string = SecureRandom.hex
-  url_map = create_test_url_map(connection)
-  proxy = connection.target_http_proxies.create({
-      :name => "fog-test-target-http-proxy-#{random_string}",
-      :urlMap => url_map.self_link
-      })
-end
-
-def create_test_zone_view(connection, zone)
-  random_string = SecureRandom.hex
-  zone_view = connection.zone_views.create({
-      :name => "fog-test-zone-view-#{random_string}",
-      :zone => zone
-      })
-  zone_view.wait_for {ready?}
-  zone_view
-end
-
-def create_test_target_pool(connection, region)
-  random_string = SecureRandom.hex
-  http_health_check = create_test_http_health_check(connection)
-  instance = create_test_server(connection, 'us-central1-a')
-  target_pool = connection.target_pools.create({
-      :name => "fog-test-target-pool-#{random_string}",
-      :region => region,
-      :healthChecks => [http_health_check.self_link],
-      :instances => [instance.self_link]\
-      })
-end
-
-def wait_operation(connection, response)
-  operation = connection.operations.get(response['name'], response['zone'], response['region'])
-  operation.wait_for { ready? }
-end