fog-scaleway 0.1.0

data/lib/fog/scaleway/requests/account/get_token.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def get_token(token_id)
+          get("/tokens/#{token_id}")
+        end
+      end
+
+      class Mock
+        def get_token(token_id)
+          token = lookup(:tokens, token_id)
+
+          response(status: 200, body: { 'token' => token })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/account/get_token_permissions.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def get_token_permissions(token_id)
+          get("/tokens/#{token_id}/permissions")
+        end
+      end
+
+      class Mock
+        def get_token_permission(token_id)
+          token = lookup(:tokens, token_id)
+
+          permissions = lookup(:token_permissions, token['id'])
+
+          response(status: 200, body: { 'permissions' => permissions })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/account/get_user.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def get_user(user_id)
+          get("/users/#{user_id}")
+        end
+      end
+
+      class Mock
+        def get_user(user_id)
+          user = lookup(:users, user_id)
+
+          response(status: 200, body: { 'user' => user })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/account/list_organizations.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def list_organizations
+          get('/organizations')
+        end
+      end
+
+      class Mock
+        def list_organizations
+          organizations = data[:organizations].values
+
+          response(status: 200, body: { 'organizations' => organizations })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/account/list_tokens.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def list_tokens
+          get('/tokens')
+        end
+      end
+
+      class Mock
+        def list_tokens
+          tokens = data[:tokens].values
+
+          response(status: 200, body: { 'tokens' => tokens })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/account/update_token.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def update_token(token_id, options = {})
+          request(method: :patch,
+                  path: "/tokens/#{token_id}",
+                  body: options,
+                  expects: [200])
+        end
+      end
+
+      class Mock
+        def update_token(token_id, options = {})
+          options = jsonify(options)
+
+          token = lookup(:tokens, token_id)
+
+          token['description'] = options['description'] unless options['description'].nil?
+          token['expires'] = (Time.now + 30 * 60).utc.strftime(TIME_FORMAT)
+
+          response(status: 200, body: { 'token' => token })
+        end
+      end
+    end
+  end
+end

data/lib/fog/scaleway/requests/account/update_user.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Scaleway
+    class Account
+      class Real
+        def update_user(user_id, options = {})
+          request(method: :patch,
+                  path: "/users/#{user_id}",
+                  body: options,
+                  expects: [200])
+        end
+      end
+
+      class Mock
+        def update_user(user_id, options = {})
+          options = jsonify(options)
+
+          user = lookup(:users, user_id)
+
+          %w(phone_number firstname lastname).each do |attr|
+            user[attr] = options[attr] if options.key?(attr)
+          end
+
+          user['fullname'] = [user['firstname'], user['lastname']].compact.join(' ')
+
+          if (ssh_public_keys = options['ssh_public_keys'])
+            user['ssh_public_keys'] = ssh_public_keys.map do |key|
+              {
+                'key' => key['key'],
+                'fingerprint' => generate_fingerprint(key['key'])
+              }
+            end
+          end
+
+          response(status: 200, body: { 'user' => user })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_image(name, arch, root_volume, options = {})
+          body = {
+            organization: @organization,
+            name: name,
+            arch: arch,
+            root_volume: root_volume
+          }
+
+          body.merge!(options)
+
+          create('/images', body)
+        end
+      end
+
+      class Mock
+        def create_image(name, arch, root_volume, options = {})
+          body = {
+            organization: @organization,
+            name: name,
+            arch: arch,
+            root_volume: root_volume
+          }
+
+          body.merge!(options)
+
+          body = jsonify(body)
+
+          creation_date = now
+
+          root_volume = lookup(:snapshots, body['root_volume'])
+
+          image = {
+            'default_bootscript' => body['default_bootscript'],
+            'creation_date' => creation_date,
+            'name' => body['name'],
+            'modification_date' => creation_date,
+            'organization' => body['organization'],
+            'extra_volumes' => '[]',
+            'arch' => body['arch'],
+            'id' => Fog::UUID.uuid,
+            'root_volume' => {
+              'size' => root_volume['size'],
+              'id' => root_volume['id'],
+              'volume_type' => root_volume['volume_type'],
+              'name' => root_volume['name']
+            },
+            'public' => false
+          }
+
+          data[:images][image['id']] = image
+
+          response(status: 201, body: { 'image' => image })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_ip(options = {})
+          body = {
+            organization: @organization
+          }
+
+          body.merge!(options)
+
+          create('/ips', body)
+        end
+      end
+
+      class Mock
+        def create_ip(options = {})
+          body = {
+            organization: @organization
+          }
+
+          body.merge!(options)
+
+          body = jsonify(body)
+
+          server = lookup(:servers, body['server']) if body['server']
+
+          ip = {
+            'organization' => body['organization'],
+            'reverse' => nil,
+            'id' => Fog::UUID.uuid,
+            'server' => nil,
+            'address' => Fog::Mock.random_ip
+          }
+
+          if server
+            ip['server'] = {
+              'id' => server['id'],
+              'name' => server['name']
+            }
+          end
+
+          if server && (public_ip = server['public_ip'])
+            if public_ip['dynamic']
+              ip['id'] = public_ip['id']
+              ip['address'] = public_ip['address']
+            else
+              message = "Server '#{server['id']}' is already attached to an IP address"
+              raise_invalid_request_error(message)
+            end
+          end
+
+          data[:ips][ip['id']] = ip
+
+          if server
+            server['public_ip'] = {
+              'dynamic' => false,
+              'id' => ip['id'],
+              'address' => ip['address']
+            }
+          end
+
+          response(status: 201, body: { 'ip' => ip })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_security_group(name, options = {})
+          body = {
+            organization: @organization,
+            name: name
+          }
+
+          body.merge!(options)
+
+          create('/security_groups', body)
+        end
+      end
+
+      class Mock
+        def create_security_group(name, options = {})
+          body = {
+            organization: @organization,
+            name: name
+          }
+
+          body.merge!(options)
+
+          body = jsonify(body)
+
+          security_group = {
+            'description' => body['description'],
+            'enable_default_security' => body.fetch('enable_default_security', true),
+            'servers' => [],
+            'organization' => body['organization'],
+            'organization_default' => body.fetch('organization_default', false),
+            'id' => Fog::UUID.uuid,
+            'name' => body['name']
+          }
+
+          if security_group['organization_default'] && default_security_group
+            raise_conflict('Cannot have more than one organization default group')
+          end
+
+          data[:security_groups][security_group['id']] = security_group
+
+          response(status: 201, body: { 'security_group' => security_group })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_security_group_rule(security_group_id, action, direction, ip_range, protocol, dest_port_from = nil)
+          create("/security_groups/#{security_group_id}/rules", action: action,
+                                                                direction: direction,
+                                                                ip_range: ip_range,
+                                                                protocol: protocol,
+                                                                dest_port_from: dest_port_from)
+        end
+      end
+
+      class Mock
+        def create_security_group_rule(security_group_id, action, direction, ip_range, protocol, dest_port_from = nil)
+          body = {
+            action: action,
+            direction: direction,
+            ip_range: ip_range,
+            protocol: protocol,
+            dest_port_from: dest_port_from
+          }
+
+          body = jsonify(body)
+
+          rules = data[:security_group_rules][security_group_id].values
+
+          position = (rules.map { |r| r[:position] }.max || 0) + 1
+
+          rule = {
+            'direction' => body['direction'],
+            'protocol' => body['protocol'],
+            'ip_range' => body['ip_range'],
+            'dest_port_from' => body['dest_port_from'],
+            'action' => body['action'],
+            'position' => position,
+            'dest_port_to' => nil,
+            'editable' => nil,
+            'id' => Fog::UUID.uuid
+          }
+
+          data[:security_group_rules][security_group_id][rule['id']] = rule
+
+          response(status: 201, body: { 'rule' => rule })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+module Fog
+  module Scaleway
+    class Compute
+      class Real
+        def create_server(name, image, volumes, options = {})
+          body = {
+            organization: @organization,
+            name: name,
+            image: image,
+            volumes: volumes
+          }
+
+          body.merge!(options)
+
+          create('/servers', body)
+        end
+      end
+
+      class Mock
+        def create_server(name, image, volumes, options = {})
+          body = {
+            organization: @organization,
+            name: name,
+            image: image,
+            volumes: volumes
+          }
+
+          body.merge!(options)
+
+          body = jsonify(body)
+
+          image = lookup(:images, body['image'])
+
+          creation_date = now
+
+          volumes = {}
+          body['volumes'].each do |index, volume|
+            volume = lookup(:volumes, volume['id'])
+
+            if volume['server']
+              message = "volume #{volume['id']} is already attached to a server"
+              raise_invalid_request_error(message)
+            end
+
+            volumes[index] = volume
+          end
+
+          root_volume = image['root_volume']
+          volumes['0'] = {
+            'size' => root_volume['size'],
+            'name' => root_volume['name'],
+            'modification_date' => creation_date,
+            'organization' => body['organization'],
+            'export_uri' => nil,
+            'creation_date' => creation_date,
+            'id' => Fog::UUID.uuid,
+            'volume_type' => root_volume['volume_type'],
+            'server' => nil
+          }
+
+          public_ip = nil
+          if body['public_ip']
+            public_ip = lookup(:ips, body['public_ip'])
+
+            public_ip = {
+              'dynamic' => false,
+              'id' => public_ip['id'],
+              'address' => public_ip['address']
+            }
+          end
+
+          dynamic_ip_required = !public_ip && body.fetch('dynamic_ip_required', true)
+
+          default_bootscript_id = image['default_bootscript']['id']
+          bootscript_id = body.fetch('bootscript', default_bootscript_id)
+          bootscript = lookup(:bootscripts, bootscript_id)
+
+          if body['security_group']
+            security_group = lookup(:security_groups, body['security_group'])
+          else
+            security_group = default_security_group
+            security_group ||= create_default_security_group
+          end
+
+          server = {
+            'arch' => image['arch'],
+            'bootscript' => bootscript,
+            'commercial_type' => body.fetch('commercial_type', 'C1'),
+            'creation_date' => creation_date,
+            'dynamic_ip_required' => dynamic_ip_required,
+            'enable_ipv6' => body.fetch('enable_ipv6', false),
+            'extra_networks' => [],
+            'hostname' => body['name'],
+            'id' => Fog::UUID.uuid,
+            'image' => image,
+            'ipv6' => nil,
+            'location' => nil,
+            'modification_date' => creation_date,
+            'name' => body['name'],
+            'organization' => body['organization'],
+            'private_ip' => nil,
+            'public_ip' => public_ip,
+            'security_group' => {
+              'id' => security_group['id'],
+              'name' => security_group['name']
+            },
+            'state' => 'stopped',
+            'state_detail' => '',
+            'tags' => body.fetch('tags', []),
+            'volumes' => volumes
+          }
+
+          data[:servers][server['id']] = server
+
+          data[:volumes][server['volumes']['0']['id']] = server['volumes']['0']
+
+          server['volumes'].each do |_index, volume|
+            volume['server'] = {
+              'id' => server['id'],
+              'name' => server['name']
+            }
+          end
+
+          response(status: 201, body: { 'server' => server })
+        end
+      end
+    end
+  end
+end