fog 1.9.0 → 1.10.0

data/lib/fog/ecloud/requests/compute/get_detached_disk.rb

@@ -12,7 +12,7 @@ module Fog
 
           if detached_disk
             response(:body => Fog::Ecloud.slice(detached_disk, :id, :compute_pool_id))
-          else response(:status => 404) # ?
+          else raise Fog::Errors::NotFound
           end
         end
       end

data/lib/fog/ecloud/requests/compute/get_internet_service.rb

@@ -14,7 +14,7 @@ module Fog
 
           if internet_service
             response(:body => Fog::Ecloud.slice(internet_service, :id, :public_ip))
-          else response(:status => 404) # ?
+          else raise Fog::Errors::NotFound
           end
         end
       end

data/lib/fog/ecloud/requests/compute/get_node.rb

@@ -13,7 +13,7 @@ module Fog
 
           if node_service
             response(:body => Fog::Ecloud.slice(node_service, :id, :internet_service_id))
-          else response(:status => 404) # ?
+          else raise Fog::Errors::NotFound
           end
         end
       end

data/lib/fog/ecloud/requests/compute/get_public_ip.rb

@@ -12,7 +12,7 @@ module Fog
 
           if public_ip
             response(:body => Fog::Ecloud.slice(public_ip, :id, :environment_id))
-          else response(:status => 404) # ?
+          else raise Fog::Errors::NotFound
           end
         end
       end

data/lib/fog/ecloud/requests/compute/get_server.rb

@@ -13,7 +13,7 @@ module Fog
           server = self.data[:servers][server_id]
           if server
             response(:body => Fog::Ecloud.slice(server, :id, :compute_pool_id))
-          else response(:status => 404) # ?
+          else raise Fog::Errors::NotFound
           end
         end
       end

data/lib/fog/ecloud/requests/compute/virtual_machine_create_from_template.rb

@@ -90,8 +90,8 @@ module Fog
                     end
                   end
                 end
+                xml.SshKey(:href => options[:ssh_key_uri])
               end
-              xml.SshKey(:href => options[:ssh_key_uri])
             end
             xml.PoweredOn options[:powered_on]
             xml.Template(:href => options[:template_uri], :type => options[:template_type])

data/lib/fog/glesys/compute.rb

@@ -15,6 +15,8 @@ module Fog
       model       :ip
 
       request_path 'fog/glesys/requests/compute'
+
+      # Server
       request :create
       request :destroy
       request :list_servers
@@ -23,9 +25,11 @@ module Fog
       request :start
       request :reboot
       request :stop
+
       # Templates
       request :template_list
-      # IP operations
+
+      # IP
       request :ip_list_free
       request :ip_list_own
       request :ip_details

data/lib/fog/glesys/models/compute/ip.rb

@@ -1,72 +1,73 @@
 require 'fog/core/model'
 
 module Fog
-  module Glesys
-    class Compute
+  module Compute
+    class Glesys
 
       class Ip < Fog::Model
+
         extend Fog::Deprecation
 
-        identity :serverid
+        identity :ip
 
+        attribute :ip, :aliases => "ipaddress"
         attribute :datacenter
-        attribute :version
+        attribute :version, :aliases => "ipversion"
         attribute :platform
-        attribute :ip
-
-        def list_own
-          service.list_own
-        end
+        attribute :netmask
+        attribute :broadcast
+        attribute :gateway
+        attribute :nameservers
+        attribute :serverid
+        attribute :reserved
+        attribute :ptr
+        attribute :cost
 
-        def list_free
-          requires :version, :datacenter, :platform
-          service.ip_list_free(
-            :ipversion => version,
-            :platform => platform,
-            :datacenter => datacenter
-          ).body['response']['iplist']
+        def attached?
+          !serverid.nil?
         end
 
-        def details
-          requires :version, :ip
-          service.ip_details(
-            :ipversion => version,
-            :ipaddress => ip
+        # Return an unused ip-address to the pool of free ips.
+        def release
+          requires :ip
+          raise Fog::Errors::Error.new('You can\'t release a ip that is attached to a server') if attached?
+          service.ip_release(
+            :ipaddress => identity
           )
         end
 
-        def take
-          requires :version, :ip
-          service.ip_take(
-            :ipversion => version,
-            :ipaddress => ip
-          )
+        # Add an ip-adress to the server.
+        def attach(server)
+          requires :ip
+          server = server.serverid if server.is_a?(Fog::Compute::Glesys::Server)
+          raise Fog::Errors::Error.new("Ip is already attached to a server, #{serverid}") unless serverid.nil?
+          data = service.ip_add(
+            :ipaddress => identity,
+            :serverid  => server
+          ).body["response"]["details"]
+          merge_attributes data
         end
 
-        def release
-          requires :version, :ip
-          service.ip_release(
-            :ipversion => version,
-            :ipaddress => ip
-          )
+        # Remove an ip from the server
+        def remove(options = {})
+          requires :ip
+          raise Fog::Errors::Error.new('Ip is not attached to a server.') if serverid.nil?
+          data = service.ip_remove({:ipaddress => ip}.merge!(options)).body["response"]["details"]
+          merge_attributes data
         end
 
-        def add
-          requires :serverid, :version, :ip
-          service.ip_add(
-            :serverid  => serverid,
-            :ipversion => version,
-            :ipaddress => ip
-          )
+        # Remove the ip from a server and release it
+        def destroy
+          requires :ip
+          remove(:release => true)
         end
 
-        def remove
-          requires :serverid, :version, :ip
-          service.ip_remove(
-            :serverid  => serverid,
-            :ipversion => version,
+        def take
+          requires :ip
+          data = service.ip_take(
             :ipaddress => ip
-          )
+          ).body["response"]["details"]
+          merge_attributes data
         end
 
       end

data/lib/fog/glesys/models/compute/ips.rb

@@ -7,30 +7,113 @@ module Fog
 
       class Ips < Fog::Collection
 
-        model Fog::Glesys::Compute::Ip
+        model Fog::Compute::Glesys::Ip
 
         attribute :serverid
+        attribute :server
 
         def all
-          data = service.ip_list_own.body['response']['iplist']
-          load(data)
+          attributes = {}
+          attributes[:serverid] = serverid unless serverid.nil?
+          ips  = service.ip_list_own(attributes).body['response']['iplist']
+          load(ips)
         end
 
-        def get(identifier)
-          return nil if identifier.nil? || identifier == ""
+        def get(ip)
+          data = service.ip_details( :ipaddress => ip).body['response']['details']
+          new data
+        end
+
+        def attached
+          all.select { |ip| !ip.serverid.nil? }
+        end
+
+        def available
+          all.select { |ip| ip.serverid.nil? }
+        end
+
+        def free(options = {})
+          default_options = {
+            :version => 4
+          }
+
+          if !server.nil?
+            default_options[:datacenter] = server.datacenter
+            default_options[:platform] = server.platform
+          end
+
+          options = default_options.merge!(options)
+
+          %w{platform datacenter version}.each do |attr|
+            raise Fog::Errors::Error.new("You need to specify ':#{attr}'") if !options.has_key?(attr.to_sym)
+          end
+
+          options[:ipversion] = options[:version]
+          options.delete(:version)
+
+          service.ip_list_free(options).body["response"]["iplist"]["ipaddresses"]
+        end
+
+        def take(ip, options = {})
+
+          default_options = {
+            :attach => false
+          }
+
+          options = default_options.merge!(options)
 
-          self.new( :serverid => identifier )
+          data = service.ip_take(
+            :ipaddress => ip_from_object(ip)
+          ).body["response"]["details"]
 
-          data  = service.ip_list_own(:serverid => identifier).body['response']
-          if data['iplist'].empty?
-            nil
+          ip = new data
+
+          if options[:attach] && serverid
+            server.ips.attach ip, serverid
+            ip.serverid = serverid
+          end
+
+          ip
+        end
+
+        def release(ip)
+          service.ip_release(
+            :ipaddress => ip_from_object(ip)
+          )
+        end
+
+        def attach(ip, server_id=nil)
+
+          if server_id.nil?
+            server_id = serverid
+          end
+
+          if server_id.nil?
+            raise Fog::Errors::Error.new("You need to specify a server id")
+          end
+
+          server_id = server_id.serverid if server_id.is_a?(Fog::Compute::Glesys::Server)
+
+          service.ip_add(
+            :ipaddress => ip_from_object(ip),
+            :serverid  => server_id
+          )
+
+          if server.nil?
+            true
           else
-            new(data['iplist'].first)
+            server.reload
           end
         end
 
-        def new(attributes = {})
-          super({ :serverid => serverid }.merge!(attributes))
+        def remove(ip, options = {})
+          new service.ip_remove({:ipaddress => ip_from_object(ip)}.merge!(options)).data.body["response"]["details"]
+        end
+
+        private
+
+        def ip_from_object(ip)
+          ip.is_a?(Fog::Compute::Glesys::Ip) ? ip.ip : ip
         end
 
       end

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

@@ -15,16 +15,18 @@ module Fog
         attribute :memorysize
         attribute :disksize
         attribute :transfer
+        attribute :uptime
         attribute :templatename
         attribute :managedhosting
         attribute :platform
         attribute :cost
         attribute :rootpassword
-        attribute :keepip
         attribute :state
         attribute :iplist
-        attribute :ipversion
-        attribute :ip
+        attribute :description
+        attribute :usage
+        attribute :glera_enabled, :aliases => "gleraenabled"
+        attribute :supported_features, :aliases => "supportedfeatures"
 
         def ready?
           state == 'running'
@@ -45,9 +47,9 @@ module Fog
           service.reboot(:serverid => identity)
         end
 
-        def destroy
+        def destroy(options = {})
           requires :identity
-          service.destroy(:serverid => identity, :keepip => keepip)
+          service.destroy(options.merge!({:serverid => identity}))
         end
 
         def save
@@ -70,6 +72,65 @@ module Fog
           data.status == 200 ? true : false
         end
 
+        def setup(credentials = {})
+          requires :public_ip_address, :username
+          require 'net/ssh'
+
+          attrs = attributes.dup
+          attrs.delete(:rootpassword)
+
+          commands = [
+            %{mkdir -p .ssh},
+            %{echo "#{Fog::JSON.encode(Fog::JSON.sanitize(attrs))}" >> ~/attributes.json}
+          ]
+          if public_key
+            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
+          end
+
+          # wait for aws to be ready
+          wait_for { sshable? }
+
+          if credentials[:password].nil? && !rootpassword.nil?
+            credentials[:password] = rootpassword
+          end
+
+          Fog::SSH.new(public_ip_address, username, credentials).run(commands)
+        end
+
+        def ssh(command, options={}, &block)
+          if options[:password].nil? && !rootpassword.nil?
+            options[:password] = rootpassword
+          end
+          super(command, options, &block)
+        end
+
+        def ips
+          Fog::Compute::Glesys::Ips.new(:serverid => identity, :server => self, :service => service).all
+        end
+
+        def ip(ip)
+          Fog::Compute::Glesys::Ips.new(:serverid => identity, :server => self, :service => service).get(ip)
+        end
+
+        def public_ip_address(options = {})
+
+          return nil if iplist.nil?
+
+          type = options[:type] || nil
+
+          ips = case type
+            when :ipv4 then iplist.select { |ip| ip["version"] == 4 }
+            when :ipv6 then iplist.select { |ip| ip["version"] == 6 }
+            else iplist.sort_by { |ip| ip["version"] }
+          end
+
+          if ips.empty?
+            nil
+          else
+            ips.first["ipaddress"]
+          end
+        end
+
       end
     end
   end

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

@@ -24,8 +24,14 @@ module Fog
             if details.empty? || status.empty?
               nil
             else
-              status['server'].merge!({ :serverid => identifier})
+              details['server']['usage'] = Hash.new
+
+              %w|cpu memory disk transfer|.each do |attr|
+                details['server']['usage'][attr] = status['server'].delete(attr)
+              end
+
               details['server'].merge!(status['server'])
+
               new(details['server'])
             end
           rescue

data/lib/fog/glesys/models/compute/template.rb

@@ -1,24 +1,16 @@
 require 'fog/core/model'
 
 module Fog
-  module Glesys
-    class Compute
-
+  module Compute
+    class Glesys
       class Template < Fog::Model
-        extend Fog::Deprecation
-
-        identity :templateid
-
+        identity :name
         attribute :platform
-        attribute :name
-        attribute :os
-        attribute :min_mem_size
-        attribute :min_disk_size
-
-        def list
-          service.template_list
-        end
-
+        attribute :operating_system, :aliases => "operatingsystem"
+        attribute :minimum_memory_size, :aliases => "minimummemorysize"
+        attribute :minimum_disk_size, :aliases => "minimumdisksize"
+        attribute :instance_cost, :aliases => "instancecost"
+        attribute :license_cost, :aliases => "licensecost"
       end
     end
   end