fog-huaweicloud 0.0.1 → 0.0.2

data/lib/fog/compute/huaweicloud/models/addresses.rb

@@ -0,0 +1,28 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/address'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Addresses < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::Address
+
+        def all(options = {})
+          load_response(service.list_all_addresses(options), 'floating_ips')
+        end
+
+        def get(address_id)
+          if address = service.get_address(address_id).body['floating_ip']
+            new(address)
+          end
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+
+        def get_address_pools
+          service.list_address_pools.body['floating_ip_pools']
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/aggregate.rb

@@ -0,0 +1,59 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Aggregate < Fog::HuaweiCloud::Model
+        identity :id
+
+        attribute :availability_zone
+        attribute :name
+        attribute :metadata
+        attribute :deleted
+        attribute :deleted_at
+        attribute :updated_at
+        attribute :created_at
+
+        # Detailed
+        attribute :hosts
+
+        def save
+          requires :name
+          identity ? update : create
+        end
+
+        def create
+          requires :name
+          merge_attributes(service.create_aggregate(name, attributes).body['aggregate'])
+          self
+        end
+
+        def update
+          requires :id
+          merge_attributes(service.update_aggregate(id, attributes).body['aggregate'])
+          self
+        end
+
+        def add_host(host_uuid)
+          requires :id
+          service.add_aggregate_host(id, host_uuid)
+        end
+
+        def remove_host(host_uuid)
+          requires :id
+          service.remove_aggregate_host(id, host_uuid)
+        end
+
+        def update_metadata(metadata)
+          service.update_aggregate_metadata(id, metadata)
+        end
+
+        def destroy
+          requires :id
+          service.delete_aggregate(id)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/aggregates.rb

@@ -0,0 +1,26 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/aggregate'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Aggregates < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::Aggregate
+
+        def all(options = {})
+          load_response(service.list_aggregates(options), 'aggregates')
+        end
+
+        def find_by_id(id)
+          new(service.get_aggregate(id).body['aggregate'])
+        end
+        alias get find_by_id
+
+        def destroy(id)
+          aggregate = find_by_id(id)
+          aggregate.destroy
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/availability_zone.rb

@@ -0,0 +1,19 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class AvailabilityZone < Fog::HuaweiCloud::Model
+        identity :zoneName
+
+        attribute :hosts
+        attribute :zoneLabel
+        attribute :zoneState
+
+        def to_s
+          zoneName
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/availability_zones.rb

@@ -0,0 +1,22 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/availability_zone'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class AvailabilityZones < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::AvailabilityZone
+
+        def all(options = {})
+          data = service.list_zones_detailed(options)
+          load_response(data, 'availabilityZoneInfo')
+        end
+
+        def summary(options = {})
+          data = service.list_zones(options)
+          load_response(data, 'availabilityZoneInfo')
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/flavor.rb

@@ -0,0 +1,64 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Flavor < Fog::HuaweiCloud::Model
+        identity :id
+
+        attribute :name
+        attribute :ram
+        attribute :disk
+        attribute :vcpus
+        attribute :links
+        attribute :swap
+        attribute :rxtx_factor
+        attribute :metadata
+        attribute :ephemeral, :aliases => 'OS-FLV-EXT-DATA:ephemeral'
+        attribute :is_public, :aliases => 'os-flavor-access:is_public'
+        attribute :disabled, :aliases => 'OS-FLV-DISABLED:disabled'
+
+        def save
+          requires :name, :ram, :vcpus, :disk
+          attributes[:ephemeral] = ephemeral || 0
+          attributes[:is_public] = is_public || false
+          attributes[:disabled] = disabled || false
+          attributes[:swap] = swap || 0
+          attributes[:rxtx_factor] = rxtx_factor || 1.0
+          merge_attributes(service.create_flavor(attributes).body['flavor'])
+          self
+        end
+
+        def destroy
+          requires :id
+          service.delete_flavor(id)
+          true
+        end
+
+        def metadata
+          service.get_flavor_metadata(id).body['extra_specs']
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+
+        def create_metadata(metadata)
+          service.create_flavor_metadata(id, metadata)
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+
+        def update_metadata(key, value)
+          service.update_flavor_metadata(id, key, value)
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+
+        def delete_metadata(key)
+          service.delete_flavor_metadata(id, key)
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/flavors.rb

@@ -0,0 +1,29 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/flavor'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Flavors < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::Flavor
+
+        def all(options = {})
+          data = service.list_flavors_detail(options)
+          load_response(data, 'flavors')
+        end
+
+        def summary(options = {})
+          data = service.list_flavors(options)
+          load_response(data, 'flavors')
+        end
+
+        def get(flavor_id)
+          data = service.get_flavor_details(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/host.rb

@@ -0,0 +1,28 @@
+require 'fog/compute/models/server'
+require 'fog/compute/huaweicloud/models/metadata'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Host < Fog::HuaweiCloud::Model
+        attribute :host_name
+        attribute :service_name
+        attribute :details
+        attribute :zone
+
+        def initialize(attributes)
+          attributes["service_name"] = attributes.delete "service"
+          # Old 'connection' is renamed as service and should be used instead
+          prepare_service_value(attributes)
+          super
+        end
+
+        def details
+          service.get_host_details(host_name).body['host']
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/hosts.rb

@@ -0,0 +1,26 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/host'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Hosts < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::Host
+
+        def all(options = {})
+          data = service.list_hosts(options)
+          load_response(data, 'hosts')
+        end
+
+        def get(host_name)
+          if host = service.get_host_details(host_name).body['host']
+            new('host_name' => host_name,
+                'details'   => host)
+          end
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/image.rb

@@ -0,0 +1,47 @@
+require 'fog/huaweicloud/models/model'
+require 'fog/compute/huaweicloud/models/metadata'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Image < Fog::HuaweiCloud::Model
+        identity :id
+
+        attribute :name
+        attribute :created_at,  :aliases => 'created'
+        attribute :updated_at,  :aliases => 'updated'
+        attribute :progress
+        attribute :status
+        attribute :minDisk
+        attribute :minRam
+        attribute :server,   :aliases => 'server'
+        attribute :size,     :aliases => 'OS-EXT-IMG-SIZE:size'
+        attribute :metadata
+        attribute :links
+
+        def metadata
+          @metadata ||= begin
+            Fog::Compute::HuaweiCloud::Metadata.new(:service => service,
+                                                  :parent  => self)
+          end
+        end
+
+        def metadata=(new_metadata = {})
+          metas = []
+          new_metadata.each_pair { |k, v| metas << {"key" => k, "value" => v} }
+          metadata.load(metas)
+        end
+
+        def destroy
+          requires :id
+          service.delete_image(id)
+          true
+        end
+
+        def ready?
+          status == 'ACTIVE'
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/images.rb

@@ -0,0 +1,38 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/image'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Images < Fog::HuaweiCloud::Collection
+        attribute :filters
+
+        model Fog::Compute::HuaweiCloud::Image
+
+        attribute :server
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters_arg = filters)
+          filters = filters_arg
+          data = service.list_images_detail(filters)
+          images = load_response(data, 'images')
+          if server
+            replace(select { |image| image.server_id == server.id })
+          end
+          images
+        end
+
+        def get(image_id)
+          data = service.get_image_details(image_id).body['image']
+          new(data)
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/key_pair.rb

@@ -0,0 +1,56 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class KeyPair < Fog::HuaweiCloud::Model
+        identity  :name
+
+        attribute :fingerprint
+        attribute :public_key
+        attribute :private_key
+        attribute :user_id
+        attribute :id
+
+        attr_accessor :public_key
+
+        def destroy
+          requires :name
+
+          service.delete_key_pair(name)
+          true
+        end
+
+        def save
+          requires :name
+
+          data = if public_key
+                   service.create_key_pair(name, public_key, user_id).body['keypair']
+                 else
+                   service.create_key_pair(name, nil, user_id).body['keypair']
+                 end
+          new_attributes = data.reject { |key, _value| !['fingerprint', 'public_key', 'name', 'private_key', 'user_id'].include?(key) }
+          merge_attributes(new_attributes)
+          true
+        end
+
+        def write(path = "#{ENV['HOME']}/.ssh/fog_#{Fog.credential}_#{name}.pem")
+          if writable?
+            split_private_key = private_key.split(/\n/)
+            File.open(path, "w") do |f|
+              split_private_key.each { |line| f.puts line }
+              f.chmod 0600
+            end
+            "Key file built: #{path}"
+          else
+            "Invalid private key"
+          end
+        end
+
+        def writable?
+          !!(private_key && ENV.key?('HOME'))
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/key_pairs.rb

@@ -0,0 +1,29 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/key_pair'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class KeyPairs < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::KeyPair
+
+        def all(options = {})
+          items = []
+          service.list_key_pairs(options).body['keypairs'].each do |kp|
+            items += kp.values
+          end
+          # TODO: convert to load_response?
+          load(items)
+        end
+
+        def get(key_pair_name)
+          if key_pair_name
+            all.select { |kp| kp.name == key_pair_name }.first
+          end
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/metadata.rb

@@ -0,0 +1,65 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/huaweicloud/models/meta_parent'
+require 'fog/compute/huaweicloud/models/metadatum'
+require 'fog/compute/huaweicloud/models/image'
+require 'fog/compute/huaweicloud/models/server'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Metadata < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::Metadatum
+
+        include Fog::Compute::HuaweiCloud::MetaParent
+
+        def all
+          requires :parent
+          metadata = service.list_metadata(collection_name, @parent.id).body['metadata']
+          metas = []
+          metadata.each_pair { |k, v| metas << {"key" => k, "value" => v} } unless metadata.nil?
+          # TODO: convert to load_response?
+          load(metas)
+        end
+
+        def get(key)
+          requires :parent
+          data = service.get_metadata(collection_name, @parent.id, key).body["meta"]
+          metas = []
+          data.each_pair { |k, v| metas << {"key" => k, "value" => v} }
+          new(metas[0])
+        rescue Fog::Compute::HuaweiCloud::NotFound
+          nil
+        end
+
+        def update(data = nil)
+          requires :parent
+          service.update_metadata(collection_name, @parent.id, to_hash(data))
+        end
+
+        def set(data = nil)
+          requires :parent
+          service.set_metadata(collection_name, @parent.id, to_hash(data))
+        end
+
+        def new(attributes = {})
+          requires :parent
+          super({:parent => @parent}.merge!(attributes))
+        end
+
+        def to_hash(data = nil)
+          if data.nil?
+            data = {}
+            each do |meta|
+              if meta.kind_of?(Fog::Compute::HuaweiCloud::Metadatum)
+                data.store(meta.key, meta.value)
+              else
+                data.store(meta["key"], meta["value"])
+              end
+            end
+          end
+          data
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/metadatum.rb

@@ -0,0 +1,27 @@
+require 'fog/huaweicloud/models/model'
+require 'fog/huaweicloud/models/meta_parent'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Metadatum < Fog::HuaweiCloud::Model
+        include Fog::Compute::HuaweiCloud::MetaParent
+
+        identity :key
+        attribute :value
+
+        def destroy
+          requires :identity
+          service.delete_meta(collection_name, @parent.id, key)
+          true
+        end
+
+        def save
+          requires :identity, :value
+          service.update_meta(collection_name, @parent.id, key, value)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/network.rb

@@ -0,0 +1,13 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Network < Fog::HuaweiCloud::Model
+        identity  :id
+        attribute :name
+        attribute :addresses
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/networks.rb

@@ -0,0 +1,30 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/network'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class Networks < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::Network
+
+        attribute :server
+
+        def all
+          requires :server
+
+          networks = []
+          server.addresses.each_with_index do |address, index|
+            networks << {
+              :id        => index + 1,
+              :name      => address[0],
+              :addresses => address[1].map { |a| a['addr'] }
+            }
+          end
+
+          # TODO: convert to load_response?
+          load(networks)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/os_interface.rb

@@ -0,0 +1,15 @@
+require 'fog/huaweicloud/models/model'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class OsInterface < Fog::HuaweiCloud::Model
+        identity  :port_id
+        attribute :fixed_ips, :type => :array
+        attribute :mac_addr
+        attribute :subnet_id
+        attribute :port_state
+      end
+    end
+  end
+end

data/lib/fog/compute/huaweicloud/models/os_interfaces.rb

@@ -0,0 +1,28 @@
+require 'fog/huaweicloud/models/collection'
+require 'fog/compute/huaweicloud/models/os_interface'
+
+module Fog
+  module Compute
+    class HuaweiCloud
+      class OsInterfaces < Fog::HuaweiCloud::Collection
+        model Fog::Compute::HuaweiCloud::OsInterface
+
+        attribute :server
+
+        def all
+          requires :server
+
+          data = service.list_os_interfaces(server.id)
+          load_response(data, 'interfaceAttachments')
+        end
+
+        def get(port_id)
+          requires :server
+
+          data = service.get_os_interface(server.id,port_id)
+          load_response(data, 'interfaceAttachment')
+        end
+      end
+    end
+  end
+end