fog 1.1.0 → 1.2.0

data/lib/fog/brightbox/models/compute/server_group.rb

@@ -16,9 +16,11 @@ module Fog
         attribute :name
         attribute :description
         attribute :default
+        attribute :created_at, :type => :time
+
+        attribute :server_ids, :aliases => "servers"
 
         def save
-          requires :name
           options = {
             :name => name,
             :description => description
@@ -28,30 +30,67 @@ module Fog
           true
         end
 
-        # Add a server to the server group
-        #
-        # == Parameters:
-        # identifiers::
-        #   An array of identifiers for the servers to add to the group
-        #
-        # == Returns:
+        def servers
+          srv_ids = server_ids.collect {|srv| srv["id"]}
+          srv_ids.collect do |srv_id|
+            connection.servers.get(srv_id)
+          end
+        end
+
+        # Adds specified servers to this server group
         #
-        # An excon response object representing the result
+        # @param [Array] identifiers array of server identifier strings to add
+        # @return [Fog::Compute::ServerGroup]
+        def add_servers identifiers
+          requires :identity
+          options = {
+            :servers => server_references(identifiers)
+          }
+          data = connection.add_servers_server_group identity, options
+          merge_attributes data
+        end
+
+        # Removes specified servers from this server group
         #
-        #  <Excon::Response: ...
+        # @param [Array] identifiers array of server identifier strings to remove
+        # @return [Fog::Compute::ServerGroup]
+        def remove_servers identifiers
+          requires :identity
+          options = {
+            :servers => server_references(identifiers)
+          }
+          data = connection.remove_servers_server_group identity, options
+          merge_attributes data
+        end
+
+        # Moves specified servers from this server group to the specified destination server group
         #
-        def add_servers(server_identifiers)
+        # @param [Array] identifiers array of server identifier strings to move
+        # @param [String] destination_group_id destination server group identifier
+        # @return [Fog::Compute::ServerGroup]
+        def move_servers identifiers, destination_group_id
           requires :identity
-          server_references = server_identifiers.map {|ident| {"server" => ident} }
           options = {
-            :servers => server_references
+            :servers => server_references(identifiers),
+            :destination => destination_group_id
           }
-          data = connection.add_servers_server_group(identity, options)
-          merge_attributes(data)
+          data = connection.move_servers_server_group identity, options
+          merge_attributes data
         end
 
-      end
+        def destroy
+          requires :identity
+          connection.destroy_server_group(identity)
+          true
+        end
+
+      protected
 
+        def server_references identifiers
+          identifiers.map {|id| {"server" => id} }
+        end
+
+      end
     end
   end
-end
+end

data/lib/fog/brightbox/requests/compute/remove_firewall_policy.rb

@@ -0,0 +1,14 @@
+module Fog
+  module Compute
+    class Brightbox
+      class Real
+
+        def remove_firewall_policy(identifier, options)
+          return nil if identifier.nil? || identifier == ""
+          request("post", "/1.0/firewall_policies/#{identifier}/remove", [202], options)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/brightbox/requests/compute/update_firewall_rule.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class Brightbox
+      class Real
+
+        def update_firewall_rule(id, options)
+          request("put", "/1.0/firewall_rules/#{id}", [202], options)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/clodo/compute.rb

@@ -0,0 +1,152 @@
+module Fog
+  module Compute
+    class Clodo < Fog::Service
+
+      requires :clodo_api_key, :clodo_username
+      recognizes :clodo_auth_url, :persistent
+      recognizes :clodo_auth_token, :clodo_management_url
+
+      model_path 'fog/clodo/models/compute'
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/clodo/requests/compute'
+      request :create_server
+      request :delete_server
+      request :get_image_details # Not supported by API
+      request :list_images
+      request :list_images_detail
+      request :list_servers
+      request :list_servers_detail
+      request :get_server_details
+      request :server_action
+      request :start_server
+      request :stop_server
+      request :reboot_server
+      request :rebuild_server
+      request :add_ip_address
+      request :delete_ip_address
+      request :move_ip_address
+      # request :list_addresses
+      # request :list_private_addresses
+      # request :list_public_addresses
+      # request :confirm_resized_server
+      # request :revert_resized_server
+      # request :resize_server
+      # request :update_server
+
+      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 initialize(options={})
+          require 'multi_json'
+          @clodo_username = options[:clodo_username]
+        end
+
+        def data
+          self.class.data[@clodo_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@clodo_username)
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'multi_json'
+          @clodo_api_key = options[:clodo_api_key]
+          @clodo_username = options[:clodo_username]
+          @clodo_auth_url = options[:clodo_auth_url]
+          @clodo_servicenet = options[:clodo_servicenet]
+          @clodo_auth_token = options[:clodo_auth_token]
+          @clodo_management_url = options[:clodo_management_url]
+          @clodo_must_reauthenticate = false
+          authenticate
+          Excon.ssl_verify_peer = false if options[:clodo_servicenet] == true
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'Accept' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}"
+            }))
+          rescue Excon::Errors::Unauthorized => error
+            if error.response.body != 'Bad username or password' # token expiration
+              @clodo_must_reauthenticate = true
+              authenticate
+              retry
+            else # bad credentials
+              raise error
+            end
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Compute::Clodo::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+        private
+
+        def authenticate
+          if @clodo_must_reauthenticate || @clodo_auth_token.nil?
+            options = {
+              :clodo_api_key  => @clodo_api_key,
+              :clodo_username => @clodo_username,
+              :clodo_auth_url => @clodo_auth_url
+            }
+            credentials = Fog::Clodo.authenticate(options)
+            @auth_token = credentials['X-Auth-Token']
+            uri = URI.parse(credentials['X-Server-Management-Url'])
+          else
+            @auth_token = @clodo_auth_token
+            uri = URI.parse(@clodo_management_url)
+          end
+          @host   = @clodo_servicenet == true ? "snet-#{uri.host}" : uri.host
+          @path   = uri.path
+          @port   = uri.port
+          @scheme = uri.scheme
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Clodo
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :vps_type
+        attribute :status
+        attribute :os_type
+        attribute :os_bits
+        attribute :os_hvm
+
+        def initialize(new_attributes)
+          super(new_attributes)
+          merge_attributes(new_attributes['_attr']) if new_attributes['_attr']
+        end
+
+        def ready?
+          status == 'ACTIVE'
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/clodo/models/compute/image'
+
+module Fog
+  module Compute
+    class Clodo
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::Clodo::Image
+
+        def all
+          data = connection.list_images_detail.body['images']
+          load(data)
+        end
+
+        def get(image_id)
+          image = connection.get_image_details(image_id).body['image']
+          new(image) if image
+        rescue Fog::Compute::Clodo::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/clodo/models/compute/server.rb

@@ -0,0 +1,163 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Clodo
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :addresses
+        attribute :name
+        attribute :image_id,    :aliases => 'imageId'
+	attribute :type
+        attribute :state,       :aliases => 'status'
+	attribute :type
+        attribute :vps_memory
+        attribute :vps_memory_max
+        attribute :vps_os_title
+        attribute :vps_os_bits
+        attribute :vps_os_type
+        attribute :vps_vnc
+        attribute :vps_cpu_load
+        attribute :vps_cpu_max
+        attribute :vps_cpu_1h_min
+        attribute :vps_cpu_1h_max
+        attribute :vps_mem_load
+        attribute :vps_mem_max
+        attribute :vps_mem_1h_min
+        attribute :vps_mem_1h_max
+        attribute :vps_hdd_load
+        attribute :vps_hdd_max
+        attribute :vps_traf_rx
+        attribute :vps_traf_tx
+        attribute :vps_createdate
+        attribute :vps_billingdate
+        attribute :vps_update
+        attribute :vps_update_days
+        attribute :vps_root_pass, :aliases => ['adminPass','password']
+        attribute :vps_user_pass
+        attribute :vps_vnc_pass
+
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.image_id   ||= attributes[:vps_os] ? attributes[:vps_os] : 666
+          super attributes
+        end
+
+        def destroy
+          requires :id
+          connection.delete_server(id)
+          true
+        end
+
+        def image
+          requires :image_id
+          image_id # API does not support image details request. :-(
+        end
+
+        def private_ip_address
+          nil
+        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_ip_address
+          pubaddrs = addresses && addresses['public'] ? addresses['public'].select {|ip| ip['primary_ip']} : nil
+          pubaddrs && !pubaddrs.empty? ? pubaddrs.first['ip'] : nil
+        end
+
+        def add_ip_address
+          connection.add_ip_address(id)
+        end
+
+        def move_ip_address(ip_address)
+          connection.move_ip_address(id, ip_address)
+        end
+
+        def delete_ip_address(ip_address)
+          connection.delete_ip_address(id, ip_address)
+        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?
+          self.state == 'is_running'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_server(id, type)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :image_id
+          data = connection.create_server(image_id, attributes)
+          merge_attributes(data.body['server'])
+          true
+        end
+
+        def setup(credentials = {})
+          requires :public_ip_address, :identity, :public_key, :username
+          Fog::SSH.new(public_ip_address, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l #{username}},
+            %{echo "#{MultiJson.encode(attributes)}" >> ~/attributes.json},
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :public_ip_address, :identity, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          options[:password] = password if password
+          Fog::SSH.new(public_ip_address, username, options).run(commands)
+        end
+
+        def scp(local_path, remote_path, upload_options = {})
+          requires :public_ip_address, :username
+
+          scp_options = {}
+          scp_options[:key_data] = [private_key] if private_key
+          Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+	def password
+	 vps_root_pass
+        end
+
+        private
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/clodo/models/compute/servers.rb

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

data/lib/fog/clodo/requests/compute/add_ip_address.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+
+        # Bye new IP-address for specified server
+        # ==== Paramaters
+        # * server_id<~Integer> - Id of server to bye IP for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>
+        #
+
+        def add_ip_address(server_id)
+          request(
+                  :expects  => [204],
+                  :method   => 'PUT',
+                  :path     => "servers/#{server_id}/ips"
+                  )
+        end
+      end
+
+      class Mock
+        def add_ip_address(server_id)
+
+          raise Excon::Errors::BadRequest.new(
+                                              "Invalid image ID"
+                                              ) unless server_id > 0
+
+          data = {
+            'primary_ip' => false,
+            'isp' => false,
+            'ip' => "66.6.#{rand(255)}.#{rand(255)}"
+          }
+
+          raise Excon::Errors::BadRequest unless self.data[:servers][server_id]
+
+          raise Excon::Errors::BadRequest.new "No addresses" unless self.data[:servers][server_id]['addresses']
+
+          self.data[:servers][server_id]['addresses']['public'] << data
+
+          response = Excon::Response.new
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/clodo/requests/compute/create_server.rb

@@ -0,0 +1,112 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # Input:
+        # vps_title - VDS title to display in VDS list
+        # vps_type - VDS type (VirtualServer,ScaleServer)
+        # vps_memory - memory size in megabytes (for ScaleServer - low limit)
+        # vps_memory_max - maximum number of ScaleServer memory megabytes to scale up.
+        # vps_hdd - Virtual HDD size im gigabytes.
+        # vps_admin - support level (1 - usual&free, 2 - extended, 3 - VIP)
+        # vps_os - OS ID to install
+        # Output:
+        # id - VDS ID
+        # name - VDS title
+        # imageId - OS ID 
+        # adminPass - root password
+
+        def create_server(image_id, options = {})
+          data = {
+            'server' => {
+              :vps_os   => image_id,
+              :vps_hdd => options[:vps_hdd]?options[:vps_hdd]:5,
+              :vps_memory => options[:vps_memory]?options[:vps_memory]:256,
+              :vps_memory_max => options[:vps_memory_max]?options[:vps_memory_max]:1024,
+              :vps_admin => options[:vps_admin]?options[:vps_admin]:1
+            }
+          }
+
+          data['server'].merge! options if options
+
+          request(
+                  :body     => MultiJson.encode(data),
+                  :expects  => [200, 202],
+                  :method   => 'POST',
+                  :path     => 'servers'
+                  )
+
+        end
+      end
+
+      class Mock
+        def create_server(image_id, options = {})
+
+          raise Excon::Errors::BadRequest.new("Invalid image ID") unless image_id > 0
+
+          response = Excon::Response.new
+          response.status = 202
+
+          id = Fog::Mock.random_numbers(6).to_i
+
+          data = {
+            'id'        => id,
+            'imageId'   => "#{image_id}",
+            'name'      => options['name'] || "VPS #{rand(999)}",
+            'adminPass'    => '23ryh8udbcbyt'
+          }
+
+          self.data[:last_modified][:servers][id] = Time.now
+          self.data[:servers][id] = {
+            'id' => "#{id}",
+            'imageId' => data['imageId'],
+            'name' => data['name'],
+            'vps_os_title' => "OSTitle",
+            'vps_root_pass' => data['adminPass'],
+            'status' => "is_running",
+            'addresses' => {'public' =>[{
+                                          'primary_ip' => true,
+                                          'isp' => false,
+                                          'ip' => '66.6.6.66'
+                                        },
+                                        {
+                                          'primary_ip' => false,
+                                          'isp' => false,
+                                          'ip' => '13.13.13.13'
+                                        }]},
+            'vps_createdate' => "#{Time.now}",
+            'vps_hdd_max' => "5",
+            'vps_traff' => nil,
+            'vps_mem_1h_max' => "0",
+            'vps_mem_load' => "0",
+            'vps_user_pass' => "wer45345ht",
+            'vps_vnc_pass' => "bi65tdfyb",
+            'vps_adddate' => "#{Time.now}",
+            'vps_update' => "#{Time.now}",
+            'vps_mem_1h_min' => "0",
+            'vps_mem_1h_avg' => nil,
+            'vps_memory_max' => options['vps_memory_max'] || "512",
+            'vps_os_version' => "6.6.6",
+            'vps_cpu_1h_max' => "0",
+            'vps_hdd_load' => "0",
+            'vps_disk_load' => "0",
+            'vps_os_type' => options['vps_os_type'] || "VirtualServer",
+            'type' => options['vps_os_type'] || "VirtualServer",
+            'vps_memory' => options['vps_memory'] || "512",
+            'vps_cpu_load' => "0",
+            'vps_update_days' => "0",
+            'vps_os_bits' => "64",
+            'vps_vnc' => "6.6.6.6:5900",
+            'vps_cpu_max' => "0",
+            'vps_cpu_1h_min' => "0",
+            'vps_cpu_1h_avg' => nil
+          }
+
+          response.body = { 'server' => data }
+          response
+        end
+      end
+    end
+  end
+end
+