fog 0.7.1 → 2.3.0

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

@@ -0,0 +1,121 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Clodo
+      class Server < Fog::Compute::Server
+        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
+
+        def initialize(attributes={})
+          self.image_id   ||= attributes[:vps_os] ? attributes[:vps_os] : 666
+          super attributes
+        end
+
+        def destroy
+          requires :id
+          service.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 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
+          service.add_ip_address(id)
+        end
+
+        def move_ip_address(ip_address)
+          service.move_ip_address(id, ip_address)
+        end
+
+        def delete_ip_address(ip_address)
+          service.delete_ip_address(id, ip_address)
+        end
+
+        def ready?
+          self.state == 'is_running'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          service.reboot_server(id, type)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :image_id
+          data = service.create_server(image_id, attributes)
+          merge_attributes(data.body['server'])
+          true
+        end
+
+        def setup(credentials = {})
+          requires :ssh_ip_address, :identity, :public_key, :username
+          Fog::SSH.new(ssh_ip_address, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l #{username}},
+            %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json},
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          super(commands, password ? {:password => password} : {})
+        end
+
+        def password
+          vps_root_pass
+        end
+
+        private
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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 = service.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 = service.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,47 @@
+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,109 @@
+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     => Fog::JSON.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

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

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # Delete IP-address from specified server
+        # ==== Paramaters
+        # * server_id<~Integer> - Id of server to delete IP from
+        # * ip<~String> - IP-address to delete
+        #
+        # ==== Returns
+        # * response<~Excon::Response>
+        #
+
+        def delete_ip_address(server_id, ip)
+          data = {'ip' => ip}
+
+          request(
+                  :expects  => [204],
+                  :method   => 'DELETE',
+                  :path     => "servers/#{server_id}/ips",
+                  :body     => Fog::JSON.encode(data)
+                  )
+        end
+      end
+
+      class Mock
+        def delete_ip_address(server_id, ip)
+          server = self.data[:servers][server_id]
+
+          raise Excon::Errors::BadRequest.new "Server not found" unless server
+
+          pa = server['addresses']['public']
+
+          raise Excon::Errors::BadRequest.new "Address not found" unless pa && pa.reject! {|addr|
+            addr['ip'] == ip
+          }
+
+          response = Excon::Response.new
+          response.status = 204
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # Delete an existing server
+        #
+        # ==== Parameters
+        # * id<~Integer> - Id of server to delete
+        #
+        def delete_server(server_id)
+          request(
+            :expects => 204,
+            :method => 'DELETE',
+            :path   => "servers/#{server_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_server(server_id)
+          response = Excon::Response.new
+
+          if server = list_servers_detail.body['servers'].find {|_| _['id'].to_i == server_id }
+            if server['status'] == 'is_install'
+              response.status = 405
+              raise(Excon::Errors.status_error({:expects => 204}, response))
+            else
+              self.data[:last_modified][:servers].delete(server_id)
+              self.data[:servers].delete(server_id)
+              response.status = 204
+            end
+            response
+          else
+            raise Fog::Compute::Clodo::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        def get_image_details(image_id)
+          request(:expects => [200,203],
+                  :method => 'GET',
+                  :path => "images/#{image_id}")
+        end
+      end
+      class Mock
+        def get_image_details(image_id)
+          response = Excon::Response.new
+          response.status = 404
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # Get details about a server
+        #
+        # ==== Parameters
+        # * server_id<~Integer> - Id of server to get details for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * 'server'<~Hash>:
+        #     * 'addresses'<~Hash>:
+        #       * 'public'<~Array> - public address strings
+        #       * 'private'<~Array> - private address strings
+        #     * 'id'<~Integer> - Id of server
+        #     * 'imageId'<~Integer> - Id of image used to boot server
+        #     * 'name<~String> - Name of server
+        #     * 'status'<~String> - Current server status
+        def get_server_details(server_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "servers/#{server_id}"
+          )
+        end
+      end
+
+      class Mock
+        def get_server_details(server_id)
+          response = Excon::Response.new
+          if server = list_servers_detail.body['servers'].find {|_| _['id'] == "#{server_id}"}
+            response.status = [200, 203][rand(1)]
+            response.body = { 'server' => server }
+            response.body['server']['id'] = server['id'].to_i
+            response
+          else
+            raise Fog::Compute::Clodo::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # List all images (IDs and names only)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'id'<~Integer> - Id of the image
+        #     * 'name'<~String> - Name of the image
+        #     * 'status'<~String> - Status of the image
+        #     * 'vps_type'<~String> - VirtualServer or ScaleServer
+        def list_images
+          request(
+                  :expects  => [200, 203],
+                  :method   => 'GET',
+                  :path     => 'images'
+                  )
+        end
+      end
+
+      class Mock
+        def list_images
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'images' => [
+                         { 'name' => 'Debian 6 64 bits',
+                           'id' => "541",
+                           'vps_type' => 'ScaleServer',
+                           'status' => 'ACTIVE' },
+                         { 'name' => 'CentOS 5.5 32 bits',
+                           'id' => "31",
+                           'vps_type' => 'VirtualServer',
+                           'status' => 'ACTIVE' }
+                        ]
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # List all images
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'os_type'<~String> - OS distribution
+        #     * 'os_bits'<~Integer> - OS bits
+        #     * 'os_hvm'<~Integer> - HVM flag
+	#     * '_attr'<~Hash>:
+        #      * 'id'<~Integer> - Id of the image
+        #      * 'name'<~String> - Name of the image
+        #      * 'status'<~String> - Status of the image
+        #      * 'vps_type'<~String> - VirtualServer or ScaleServer
+
+        def list_images_detail
+          request(
+                  :expects  => [200, 203],
+                  :method   => 'GET',
+                  :path     => 'images/detail'
+                  )
+        end
+      end
+
+      class Mock
+        def list_images_detail
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'images' => [{ 'os_type' => 'debian',
+                           'os_bits' => "64",
+                           'os_hvm' => "0",
+                           '_attr' => {
+                             'id' => "541",
+                             'name' => 'Debian 6 64 bits',
+                             'status' => 'ACTIVE',
+                             'vps_type' => 'ScaleServer'
+                           }},
+                         { 'os_type' => 'centos',
+                           'os_bits' => "32",
+                           'os_hvm' => "0",
+                           '_attr' => {
+                             'name' => 'CentOS 5.5 32 bits',
+                             'id' => "31",
+                             'vps_type' => 'VirtualServer',
+                             'status' => 'ACTIVE',
+                           }}]
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # List all servers (IDs and names only)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * 'servers'<~Array>:
+        #     * 'id'<~String> - Id of server
+        #     * 'name'<~String> - Name of server
+        #     * 'addresses'<~Hash>:
+        #       * 'public'<~Array>:
+        #         * 'dosprotect'<~Bool> - DDoS protection enabled
+        #         * 'primary_ip'<~Bool> - Is a primary IP-address
+        #         * 'isp'<~Bool> - ISPManager license enabled
+        #         * 'ip'<~String> - IP-address
+        #     * 'imageId'<~String> - ID of OS image installed
+        #     * 'type'<~String> - Type (ScaleServer or Virtual Server)
+        #     * 'status'<~String> - Server's status
+        def list_servers
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => 'servers'
+          )
+        end
+      end
+
+      class Mock
+        def list_servers
+          response = Excon::Response.new
+          data = list_servers_detail.body['servers']
+          servers = []
+          for server in data
+            servers << server.reject { |key, value| !['id', 'name', 'addresses', 'imageId', 'type', 'status', 'state'].include?(key) }
+          end
+          response.status = [200, 203][rand(1)]
+          response.body = { 'servers' => servers }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  module Compute
+    class Clodo
+      class Real
+        # List all servers details
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * 'servers'<~Array>:
+        #     * 'id'<~Integer> - Id of server
+        #     * 'name<~String> - Name of server
+        #     * 'imageId'<~Integer> - Id of image used to boot server
+        #     * 'status'<~String> - Current server status
+        #     * 'addresses'<~Hash>:
+        #       * 'public'<~Array> - public address strings
+        def list_servers_detail
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => 'servers/detail'
+          )
+        end
+      end
+
+      class Mock
+        def list_servers_detail
+          response = Excon::Response.new
+
+          servers = self.data[:servers].values
+          for server in servers
+            case server['status']
+            when 'is_install'
+              if Time.now - self.data[:last_modified][:servers][server['id']] > Fog::Mock.delay * 2
+                server['status'] = 'is_running'
+              end
+            end
+          end
+
+          response.status = [200, 203][rand(1)]
+          response.body = { 'servers' => servers }
+          response
+        end
+      end
+    end
+  end
+end