fog-scaleway 0.1.0

data/lib/fog/scaleway/models/compute/security_group.rb

@@ -0,0 +1,77 @@
+module Fog
+  module Scaleway
+    class Compute
+      class SecurityGroup < Fog::Model
+        identity :id
+
+        attribute :description
+        attribute :enable_default_security
+        attribute :name
+        attribute :organization
+        attribute :organization_default
+        attribute :servers
+
+        def servers=(value)
+          attributes[:servers] = value.map do |v|
+            case v
+            when Hash
+              service.servers.new(v)
+            when String
+              service.servers.new(identity: v)
+            else
+              v
+            end
+          end
+        end
+
+        def rules
+          service.security_group_rules(security_group: self)
+        end
+
+        def save
+          if persisted?
+            update
+          else
+            create
+          end
+        end
+
+        def destroy
+          requires :identity
+
+          service.delete_security_group(identity)
+          true
+        end
+
+        private
+
+        def create
+          requires :name
+
+          options = {}
+          options[:description] = description unless description.nil?
+          options[:enable_default_security] = enable_default_security unless enable_default_security.nil?
+          options[:organization_default] = organization_default unless organization_default.nil?
+
+          if (security_group = service.create_security_group(name, options).body['security_group'])
+            merge_attributes(security_group)
+            true
+          else
+            false
+          end
+        end
+
+        def update
+          requires :identity
+
+          if (security_group = service.update_security_group(identity, self).body['security_group'])
+            merge_attributes(security_group)
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/models/compute/security_group_rule.rb

@@ -0,0 +1,59 @@
+module Fog
+  module Scaleway
+    class Compute
+      class SecurityGroupRule < Fog::Model
+        attr_accessor :security_group
+
+        identity :id
+
+        attribute :action
+        attribute :dest_port_from
+        attribute :dest_port_to
+        attribute :direction
+        attribute :editable
+        attribute :ip_range
+        attribute :position
+        attribute :protocol
+
+        def save
+          if persisted?
+            update
+          else
+            create
+          end
+        end
+
+        def destroy
+          requires :security_group, :identity
+
+          service.delete_security_group_rule(security_group.identity, identity)
+          true
+        end
+
+        private
+
+        def create
+          requires :security_group, :action, :direction, :ip_range, :protocol
+
+          if (rule = service.create_security_group_rule(security_group.identity, action, direction, ip_range, protocol, dest_port_from).body['rule'])
+            merge_attributes(rule)
+            true
+          else
+            false
+          end
+        end
+
+        def update
+          requires :security_group, :identity
+
+          if (rule = service.update_security_group_rule(security_group.identity, identity, self).body['rule'])
+            merge_attributes(rule)
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/models/compute/security_group_rules.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Scaleway
+    class Compute
+      class SecurityGroupRules < Fog::Collection
+        model Fog::Scaleway::Compute::SecurityGroupRule
+
+        attribute :security_group
+
+        def all
+          requires :security_group
+
+          rules = service.list_security_group_rules(security_group.identity).body['rules'] || []
+          load(rules)
+        end
+
+        def get(identity)
+          requires :security_group
+
+          if (rule = service.get_security_group_rule(security_group.identity, identity).body['rule'])
+            new(rule)
+          end
+        rescue Fog::Scaleway::Compute::UnknownResource
+          nil
+        end
+
+        def new(attributes = {})
+          requires :security_group
+
+          super({ security_group: security_group }.merge(attributes))
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/models/compute/security_groups.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Scaleway
+    class Compute
+      class SecurityGroups < Fog::Collection
+        model Fog::Scaleway::Compute::SecurityGroup
+
+        def all
+          security_groups = service.list_security_groups.body['security_groups'] || []
+          load(security_groups)
+        end
+
+        def get(identity)
+          if (security_group = service.get_security_group(identity).body['security_group'])
+            new(security_group)
+          end
+        rescue Fog::Scaleway::Compute::UnknownResource
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Scaleway
+    class Compute
+      class Server < Fog::Compute::Server
+        identity :id
+
+        attribute :arch
+        attribute :bootscript
+        attribute :commercial_type
+        attribute :creation_date
+        attribute :dynamic_ip_required
+        attribute :enable_ipv6
+        attribute :extra_networks
+        attribute :hostname
+        attribute :image
+        attribute :ipv6
+        attribute :location
+        attribute :modification_date
+        attribute :name
+        attribute :organization
+        attribute :private_ip
+        attribute :public_ip
+        attribute :security_group
+        attribute :state
+        attribute :state_detail
+        attribute :tags
+        attribute :volumes, default: {}
+
+        def bootscript=(value)
+          attributes[:bootscript] = case value
+                                    when Hash
+                                      service.bootscripts.new(value)
+                                    when String
+                                      service.bootscripts.new(identity: value)
+                                    else
+                                      value
+                                    end
+        end
+
+        def image=(value)
+          attributes[:image] = case value
+                               when Hash
+                                 service.images.new(value)
+                               when String
+                                 service.images.new(identity: value)
+                               else
+                                 value
+                               end
+        end
+
+        def public_ip=(value)
+          attributes[:public_ip] = case value
+                                   when Hash
+                                     service.ips.new(value)
+                                   when String
+                                     service.ips.new(identity: value)
+                                   else
+                                     value
+                                   end
+        end
+
+        def security_group=(value)
+          attributes[:security_group] = case value
+                                        when Hash
+                                          service.security_groups.new(value)
+                                        when String
+                                          service.security_groups.new(identity: value)
+                                        else
+                                          value
+                                        end
+        end
+
+        def volumes=(value)
+          attributes[:volumes] = Hash[value.map { |i, v| [i, to_volume(v)] }]
+        end
+
+        def public_dns_name
+          "#{identity}.pub.cloud.scaleway.com"
+        end
+
+        def private_dns_name
+          "#{identity}.priv.cloud.scaleway.com"
+        end
+
+        def ready?
+          state == 'running'
+        end
+
+        def save
+          if persisted?
+            update
+          else
+            create
+          end
+        end
+
+        def destroy
+          requires :identity
+
+          service.delete_server(identity)
+          true
+        end
+
+        def poweron(async = true)
+          requires :identity
+
+          if (task = service.execute_server_action(identity, 'poweron').body['task'])
+            service.tasks.new(task).tap do |task|
+              unless async
+                task.wait_for { task.success? }
+                reload
+              end
+            end
+          end
+        end
+
+        def poweroff(async = true)
+          requires :identity
+
+          if (task = service.execute_server_action(identity, 'poweroff').body['task'])
+            service.tasks.new(task).tap do |task|
+              unless async
+                task.wait_for { task.success? }
+                reload
+              end
+            end
+          end
+        end
+
+        def reboot(async = true)
+          requires :identity
+
+          if (task = service.execute_server_action(identity, 'reboot').body['task'])
+            service.tasks.new(task).tap do |task|
+              unless async
+                task.wait_for { task.success? }
+                reload
+              end
+            end
+          end
+        end
+
+        def terminate(async = true)
+          requires :identity
+
+          if (task = service.execute_server_action(identity, 'terminate').body['task'])
+            service.tasks.new(task).tap do |task|
+              unless async
+                task.wait_for { task.success? }
+                reload
+              end
+            end
+          end
+        end
+
+        def attach_volume(volume)
+          volumes[next_volume_index] = to_volume(volume)
+
+          save if persisted?
+        end
+
+        def detach_volume(volume)
+          volumes.reject! { |_k, v| v == to_volume(volume) }
+
+          save if persisted?
+        end
+
+        def public_ip_address
+          public_ip.address if public_ip
+        end
+
+        def private_ip_address
+          private_ip
+        end
+
+        private
+
+        def create
+          requires :name, :image, :volumes
+
+          options = {}
+          options[:commercial_type] = commercial_type unless commercial_type.nil?
+          options[:enable_ipv6] = enable_ipv6 unless enable_ipv6.nil?
+          options[:dynamic_ip_required] = dynamic_ip_required unless dynamic_ip_required.nil?
+          options[:public_ip] = public_ip.identity unless public_ip.nil?
+          options[:tags] = tags unless tags.nil?
+
+          if (server = service.create_server(name, image.identity, volumes, options).body['server'])
+            merge_attributes(server)
+            true
+          else
+            false
+          end
+        end
+
+        def update
+          requires :identity
+
+          body = attributes.dup
+
+          unless public_ip.nil?
+            body[:public_ip] = {
+              id: public_ip.identity,
+              address: public_ip.address
+            }
+          end
+
+          unless security_group.nil?
+            body[:security_group] = {
+              id: security_group.identity,
+              name: security_group.name
+            }
+          end
+
+          if (server = service.update_server(identity, body).body['server'])
+            merge_attributes(server)
+            true
+          else
+            false
+          end
+        end
+
+        def to_volume(value)
+          case value
+          when Hash
+            service.volumes.new(value)
+          when String
+            service.volumes.new(identity: value)
+          else
+            value
+          end
+        end
+
+        def next_volume_index
+          used = volumes.keys.map(&:to_i)
+          (1..Float::INFINITY).find { |i| !used.include?(i) }.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Servers < Fog::Collection
+        model Fog::Scaleway::Compute::Server
+
+        def all
+          servers = service.list_servers.body['servers'] || []
+          load(servers)
+        end
+
+        def get(identity)
+          if (server = service.get_server(identity).body['server'])
+            new(server)
+          end
+        rescue Fog::Scaleway::Compute::UnknownResource
+          nil
+        end
+
+        def bootstrap(new_attributes = {})
+          require 'securerandom'
+          name = "scw-#{SecureRandom.hex(3)}"
+
+          public_ip = new_attributes[:public_ip]
+
+          public_ip = service.ips.create(new_attributes) if public_ip.nil?
+
+          defaults = {
+            name: name,
+            image: '75c28f52-6c64-40fc-bb31-f53ca9d02de9',
+            commercial_type: 'C2S',
+            dynamic_ip_required: false,
+            public_ip: public_ip
+          }
+
+          server = create(defaults.merge(new_attributes))
+
+          server.poweron(false)
+
+          server.wait_for { sshable? }
+
+          server
+        end
+      end
+    end
+  end
+end