fog-scaleway 0.1.0

data/lib/fog/scaleway/requests/compute/create_snapshot.rb

@@ -0,0 +1,54 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_snapshot(name, volume_id)
+          create('/snapshots', organization: @organization,
+                               name: name,
+                               volume_id: volume_id)
+        end
+      end
+
+      class Mock
+        def create_snapshot(name, volume_id)
+          body = {
+            organization: @organization,
+            name: name,
+            volume_id: volume_id
+          }
+
+          body = jsonify(body)
+
+          base_volume = lookup(:volumes, body['volume_id'])
+
+          server_id = base_volume['server'] && base_volume['server']['id']
+          server = lookup(:servers, server_id) if server_id
+          in_use = server && server['state'] != 'stopped'
+
+          raise_invalid_request_error('server must be stopped to snapshot') if in_use
+
+          creation_date = now
+
+          snapshot = {
+            'state' => 'snapshotting',
+            'base_volume' => {
+              'id' => base_volume['id'],
+              'name' => base_volume['name']
+            },
+            'name' => body['name'],
+            'modification_date' => creation_date,
+            'organization' => body['organization'],
+            'size' => base_volume['size'],
+            'id' => Fog::UUID.uuid,
+            'volume_type' => base_volume['volume_type'],
+            'creation_date' => creation_date
+          }
+
+          data[:snapshots][snapshot['id']] = snapshot
+
+          response(status: 201, body: { 'snapshot' => snapshot })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/create_volume.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_volume(name, volume_type, options)
+          if options[:size].nil? && options[:base_volume].nil? && options[:base_snapshot].nil?
+            raise ArgumentError, 'size, base_volume or base_snapshot are required to create a volume'
+          end
+
+          body = {
+            organization: @organization,
+            name: name,
+            volume_type: volume_type
+          }
+
+          if !options[:size].nil?
+            body[:size] = options[:size]
+          elsif !options[:base_volume].nil?
+            body[:base_volume] = options[:base_volume]
+          else
+            body[:base_snapshot] = options[:base_snapshot]
+          end
+
+          create('/volumes', body)
+        end
+      end
+
+      class Mock
+        def create_volume(name, volume_type, options)
+          if options[:size].nil? && options[:base_volume].nil? && options[:base_snapshot].nil?
+            raise ArgumentError, 'size, base_volume or base_snapshot are required to create a volume'
+          end
+
+          body = {
+            organization: @organization,
+            name: name,
+            volume_type: volume_type
+          }
+
+          if !options[:size].nil?
+            body[:size] = options[:size]
+          elsif !options[:base_volume].nil?
+            body[:base_volume] = options[:base_volume]
+          else
+            body[:base_snapshot] = options[:base_snapshot]
+          end
+
+          body = jsonify(body)
+
+          creation_date = now
+
+          if body['size']
+            size = body['size']
+          elsif body['base_volume']
+            base_volume = lookup(:volumes, body['base_volume'])
+
+            server_id = base_volume['server'] && base_volume['server']['id']
+            server = lookup(:servers, server_id) if server_id
+            in_use = server && server['state'] != 'stopped'
+
+            raise_invalid_request_error('Base volume is in use') if in_use
+
+            size = base_volume['size']
+          elsif body['base_snapshot']
+            base_snapshot = lookup(:snapshots, body['base_snapshot'])
+            size = base_snapshot['size']
+          end
+
+          volume = {
+            'size' => size,
+            'name' => body['name'],
+            'modification_date' => creation_date,
+            'organization' => body['organization'],
+            'export_uri' => nil,
+            'creation_date' => creation_date,
+            'id' => Fog::UUID.uuid,
+            'volume_type' => body['volume_type'],
+            'server' => nil
+          }
+
+          data[:volumes][volume['id']] = volume
+
+          response(status: 201, body: { 'volume' => volume })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_image.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_image(image_id)
+          delete("/images/#{image_id}")
+        end
+      end
+
+      class Mock
+        def delete_image(image_id)
+          image = lookup(:images, image_id)
+
+          data[:images].delete(image['id'])
+
+          data[:servers].each do |_id, server|
+            if server['image'] && server['image']['id'] == image['id']
+              server['image'] = nil
+            end
+          end
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_ip.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_ip(ip_id)
+          delete("/ips/#{ip_id}")
+        end
+      end
+
+      class Mock
+        def delete_ip(ip_id)
+          ip = lookup(:ips, ip_id)
+
+          data[:ips].delete(ip['id'])
+
+          if ip['server']
+            server = lookup(:servers, ip['server']['id'])
+
+            server['public_ip'] = if server['dynamic_ip_required']
+                                    create_dynamic_ip
+                                  end
+          end
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_security_group.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_security_group(security_group_id)
+          delete("/security_groups/#{security_group_id}")
+        end
+      end
+
+      class Mock
+        def delete_security_group(security_group_id)
+          security_group = lookup(:security_groups, security_group_id)
+
+          unless security_group['servers'].empty?
+            raise_conflict('Group is in use. You cannot delete it.')
+          end
+
+          if security_group['organization_default']
+            raise_conflict('Group is default group. You cannot delete it.')
+          end
+
+          data[:security_groups].delete(security_group['id'])
+
+          data[:security_group_rules].delete(security_group['id'])
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_security_group_rule.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_security_group_rule(security_group_id, rule_id)
+          delete("/security_groups/#{security_group_id}/rules/#{rule_id}")
+        end
+      end
+
+      class Mock
+        def delete_security_group_rule(security_group_id, rule_id)
+          security_group = lookup(:security_groups, security_group_id)
+
+          unless data[:security_group_rules][security_group_id].delete(rule_id)
+            raise_unknown_resource(rule_id)
+          end
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_server(server_id)
+          delete("/servers/#{server_id}")
+        end
+      end
+
+      class Mock
+        def delete_server(server_id)
+          server = lookup(:servers, server_id)
+
+          if server['state'] != 'stopped'
+            raise_invalid_request_error('server should be stopped')
+          end
+
+          data[:servers].delete(server['id'])
+
+          data[:user_data].delete(server['id'])
+
+          data[:server_actions].delete(server['id'])
+
+          if server['public_ip'] && !server['public_ip']['dynamic']
+            ip = lookup(:ips, server['public_ip']['id'])
+            ip['server'] = nil
+          end
+
+          security_group = lookup(:security_groups, server['security_group']['id'])
+          security_group['servers'].reject! { |s| s['id'] == server['id'] }
+
+          volumes = server['volumes'].values
+          volumes.each { |volume| volume['server'] = nil }
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_snapshot.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_snapshot(snapshot_id)
+          delete("/snapshots/#{snapshot_id}")
+        end
+      end
+
+      class Mock
+        def delete_snapshot(snapshot_id)
+          snapshot = lookup(:snapshots, snapshot_id)
+
+          in_use = data[:images].any? do |_id, image|
+            image['root_volume']['id'] == snapshot['id']
+          end
+
+          if in_use
+            raise_invalid_request_error('one or more images are attached to this snapshot')
+          end
+
+          data[:snapshots].delete(snapshot['id'])
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_task.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_task(task_id)
+          delete("/tasks/#{task_id}")
+        end
+      end
+
+      class Mock
+        def delete_task(task_id)
+          task = lookup(:tasks, task_id)
+
+          data[:tasks].delete(task['id'])
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_user_data.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_user_data(server_id, key)
+          delete("/servers/#{server_id}/user_data/#{key}")
+        end
+      end
+
+      class Mock
+        def delete_user_data(server_id, key)
+          server = lookup(:servers, server_id)
+
+          data[:user_data][server['id']].delete(key)
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/delete_volume.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def delete_volume(volume_id)
+          delete("/volumes/#{volume_id}")
+        end
+      end
+
+      class Mock
+        def delete_volume(volume_id)
+          volume = lookup(:volumes, volume_id)
+
+          if volume['server']
+            raise_invalid_request_error('a server is attached to this volume')
+          end
+
+          data[:volumes].delete(volume_id)
+
+          data[:snapshots].each do |_id, snapshot|
+            if snapshot['base_volume'] && snapshot['base_volume']['id'] == volume_id
+              snapshot['base_volume'] = nil
+            end
+          end
+
+          response(status: 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/compute/execute_server_action.rb

@@ -0,0 +1,101 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def execute_server_action(server_id, action)
+          request(method: :post,
+                  path: "/servers/#{server_id}/action",
+                  body: {
+                    action: action
+                  },
+                  expects: [202])
+        end
+      end
+
+      class Mock
+        def execute_server_action(server_id, action)
+          server = lookup(:servers, server_id)
+
+          started_at = now
+
+          task = {
+            'status' => 'pending',
+            'terminated_at' => nil,
+            'href_from' => "/servers/#{server_id}/action",
+            'progress' => 0,
+            'started_at' => started_at,
+            'id' => Fog::UUID.uuid
+          }
+
+          case action
+          when 'poweron'
+            unless server['state'] == 'stopped'
+              raise_invalid_request_error('server should be stopped')
+            end
+
+            task['description'] = 'server_batch_poweron'
+
+            server['ipv6'] = create_ipv6 if server['enable_ipv6']
+
+            server['location'] = {
+              'platform_id' => Fog::Mock.random_numbers(2),
+              'node_id' => Fog::Mock.random_numbers(2),
+              'cluster_id' => Fog::Mock.random_numbers(2),
+              'chassis_id' => Fog::Mock.random_numbers(2)
+            }
+
+            server['private_ip'] = Fog::Mock.random_ip
+
+            if server['dynamic_ip_required'] && server['public_ip'].nil?
+              server['public_ip'] = create_dynamic_ip
+            end
+
+            server['state'] = 'starting'
+            server['state_detail'] = 'provisioning node'
+            server['modification_date'] = started_at
+          when 'poweroff'
+            if server['state'] == 'stopping'
+              raise_invalid_request_error('server is being stopped or rebooted')
+            elsif server['state'] != 'running'
+              raise_invalid_request_error('server should be running')
+            end
+
+            task['description'] = 'server_poweroff'
+
+            server['state'] = 'stopping'
+            server['state_detail'] = 'stopping'
+            server['modification_date'] = started_at
+          when 'reboot'
+            if server['state'] == 'stopping'
+              raise_invalid_request_error('server is being stopped or rebooted')
+            elsif server['state'] != 'running'
+              raise_invalid_request_error('server should be running')
+            end
+
+            task['description'] = 'server_reboot'
+
+            server['state'] = 'stopping'
+            server['state_detail'] = 'rebooting'
+            server['modification_date'] = started_at
+          when 'terminate'
+            if server['state'] == 'stopping'
+              raise_invalid_request_error('server is being stopped or rebooted')
+            elsif server['state'] != 'running'
+              raise_invalid_request_error('server should be running')
+            end
+
+            task['description'] = 'server_terminate'
+
+            server['state'] = 'stopping'
+            server['state_detail'] = 'terminating'
+            server['modification_date'] = started_at
+          end
+
+          data[:tasks][task['id']] = task
+
+          response(status: 202, body: { 'task' => task })
+        end
+      end
+    end
+  end
+end