ey-core 3.4.2 → 3.4.5

data/lib/ey-core/requests/create_provider.rb

@@ -1,90 +1,90 @@
-class Ey::Core::Client
-  class Real
-    def create_provider(params={})
-      if account_id = params["account"]
-        request(
-          :method => :post,
-          :path   => "/accounts/#{account_id}/providers",
-          :body   => params,
-        )
-      elsif url = params.delete("url")
-        request(
-          :method => :post,
-          :url    => url,
-          :body   => params,
-        )
-      else
-        raise "Need params for either Account ID (account) or URL"
-      end
-    end
-  end # Real
-
-  class Mock
-    def create_provider(params={})
-      resource_id    = self.serial_id
-      request_id     = self.uuid
-      account_id     = params["account"]
-      url            = params.delete("url")
-
-      account_id ||= url && path_params(url)["accounts"]
-
-      find(:accounts, account_id)
-
-      provider_params = params["provider"]
-
-      provider = {
-        "account"            => url_for("/accounts/#{account_id}"),
-        "id"                 => resource_id,
-        "resource_url"       => url_for("/providers/#{resource_id}"),
-        "provider_locations" => url_for("/providers/#{resource_id}/locations"),
-        "storages"           => url_for("/providers/#{resource_id}/storages"),
-        "servers"            => url_for("/providers/#{resource_id}/servers"),
-        "untracked_servers"  => url_for("/providers/#{resource_id}/untracked-servers"),
-        "provisioned_id"     => provider_params["provisioned_id"] || SecureRandom.uuid,
-        "created_at"         => Time.now,
-        "updated_at"         => Time.now,
-        "type"               => provider_params["type"].to_s,
-        "credentials"        => provider_params["credentials"],
-        "shared"             => provider_params.fetch(:shared, false),
-      }
-
-      unless ["aws", "azure"].include?(provider["type"])
-        response(status: 422, body: {"errors" => ["Unknown provider type: #{provider["type"]}"]})
-      end
-
-      self.data[:possible_provider_locations][provider["type"].to_s].each do |location|
-        provider_location_id = self.uuid
-        provider_location = {
-          "id"          => provider_location_id,
-          "location_id" => location["id"],
-          "provider"    => url_for("/providers/#{resource_id}"),
-          "name"        => location["name"],
-          "data"        => {},
-        }
-        self.data[:provider_locations][provider_location_id] = provider_location
-      end
-
-      request = provider.merge(
-        "resource"    => [:providers, resource_id, provider],
-        "type"        => "provider",
-        "started_at"  => Time.now,
-        "finished_at" => nil,
-        "successful"  => "true",
-        "id"          => request_id,
-      )
-
-      self.data[:requests][request_id]   = request
-
-      response_hash = request.dup
-      response_hash.delete("resource")
-
-      response(
-        :body    => {"request" => response_hash},
-        :status  => 201,
-        :headers => {
-          "Content-Type" => "application/json; charset=utf8"
-        }
-      )
-    end
-  end # Mock
-end # Ey::Core::Client
+class Ey::Core::Client
+  class Real
+    def create_provider(params={})
+      if account_id = params["account"]
+        request(
+          :method => :post,
+          :path   => "/accounts/#{account_id}/providers",
+          :body   => params,
+        )
+      elsif url = params.delete("url")
+        request(
+          :method => :post,
+          :url    => url,
+          :body   => params,
+        )
+      else
+        raise "Need params for either Account ID (account) or URL"
+      end
+    end
+  end # Real
+
+  class Mock
+    def create_provider(params={})
+      resource_id    = self.serial_id
+      request_id     = self.uuid
+      account_id     = params["account"]
+      url            = params.delete("url")
+
+      account_id ||= url && path_params(url)["accounts"]
+
+      find(:accounts, account_id)
+
+      provider_params = params["provider"]
+
+      provider = {
+        "account"            => url_for("/accounts/#{account_id}"),
+        "id"                 => resource_id,
+        "resource_url"       => url_for("/providers/#{resource_id}"),
+        "provider_locations" => url_for("/providers/#{resource_id}/locations"),
+        "storages"           => url_for("/providers/#{resource_id}/storages"),
+        "servers"            => url_for("/providers/#{resource_id}/servers"),
+        "untracked_servers"  => url_for("/providers/#{resource_id}/untracked-servers"),
+        "provisioned_id"     => provider_params["provisioned_id"] || SecureRandom.uuid,
+        "created_at"         => Time.now,
+        "updated_at"         => Time.now,
+        "type"               => provider_params["type"].to_s,
+        "credentials"        => provider_params["credentials"],
+        "shared"             => provider_params.fetch(:shared, false),
+      }
+
+      unless ["aws", "azure"].include?(provider["type"])
+        response(status: 422, body: {"errors" => ["Unknown provider type: #{provider["type"]}"]})
+      end
+
+      self.data[:possible_provider_locations][provider["type"].to_s].each do |location|
+        provider_location_id = self.uuid
+        provider_location = {
+          "id"          => provider_location_id,
+          "location_id" => location["id"],
+          "provider"    => url_for("/providers/#{resource_id}"),
+          "name"        => location["name"],
+          "data"        => {},
+        }
+        self.data[:provider_locations][provider_location_id] = provider_location
+      end
+
+      request = provider.merge(
+        "resource"    => [:providers, resource_id, provider],
+        "type"        => "provider",
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "successful"  => "true",
+        "id"          => request_id,
+      )
+
+      self.data[:requests][request_id]   = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 201,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

data/lib/ey-core/requests/create_server.rb

@@ -1,121 +1,121 @@
-class Ey::Core::Client
-  class Real
-    def create_server(params={})
-      request(
-        :method => :post,
-        :path   => "/servers",
-        :url    => params.delete("url"),
-        :body   => params,
-      )
-    end
-  end
-
-  class Mock
-    def create_server(params={})
-      params = Cistern::Hash.stringify_keys(params)
-      server = params["server"]
-
-      require_parameters(params, "environment")
-      require_parameters(params["server"], "role", "location", "flavor")
-      if server["role"] == "util"
-        require_parameters(params["server"], "name")
-      end
-
-      request_id     = self.uuid
-      resource_id    = self.serial_id
-      provisioned_id = "i-#{SecureRandom.hex(4)}"
-      environment_id = resource_identity(params["environment"])
-      environment    = find(:environments, environment_id)
-      account        = resource_identity(environment["account"])
-      provider       = self.data[:providers].values.detect { |p| p["account"] == url_for("/accounts/#{account}") }
-
-      servers = self.data[:servers].values.select { |s| s["environment"] == url_for("/environments/#{environment_id}") }
-
-      if servers.count == 1 && servers.first["role"] == "solo" && server["role"] == "db_slave"
-        response(
-          :status => 422,
-          :body   => {"errors" => ["Cannot add a DB Slave"]},
-        )
-      end
-
-      resource = {
-        "account"          => url_for("/accounts/#{account}"),
-        "alerts"           => url_for("/servers/#{resource_id}/alerts"),
-        "created_at"       => Time.now.to_s,
-        "dedicated"        => !!server["dedicated"],
-        "deprovisioned_at" => nil,
-        "devices"          => block_device_map(server),
-        "enabled"          => true,
-        "environment"      => url_for("/environments/#{environment["id"]}"),
-        "flavor"           => { "id" => server["flavor"] },
-        "id"               => resource_id,
-        "location"         => environment["region"],
-        "logs"             => url_for("/servers/#{resource_id}/logs"),
-        "name"             => server["name"],
-        "private_hostname" => "#{provisioned_id}.private.example.org",
-        "provider"         => url_for("/providers/#{provider["id"]}"),
-        "provisioned_at"   => Time.now.to_s,
-        "provisioned_id"   => provisioned_id,
-        "public_hostname"  => "#{provisioned_id}.public.example.org",
-        "public_key"       => mock_ssh_key[:fingerprint],
-        "ssh_port"         => 22,
-        "state"            => "running",
-        "token"            => SecureRandom.hex(16),
-        "updated_at"       => Time.now.to_s,
-        "volumes"          => url_for("/servers/#{resource_id}/volumes"),
-        "role"             => server["role"],
-        "resource_url"     => url_for("/servers/#{resource_id}"),
-      }
-
-      request = {
-        "id"           => request_id,
-        "type"         => "provision_server",
-        "successful"   => "true",
-        "started_at"   => Time.now,
-        "finished_at"  => nil,
-        "resource_url" => url_for("/servers/#{resource_id}"),
-        "resource"     => [:servers, resource_id, resource],
-      }
-
-      self.data[:requests][request_id] = request
-
-      response_hash = request.dup
-      response_hash.delete("resource")
-
-      response(
-        :body   => {"request" => response_hash},
-        :status => 201,
-      )
-    end
-
-    def block_device_map(params={})
-      [
-        {
-          "mount"                 => "/",
-          "file_system"           => "ext4",
-          "device"                => "/dev/sda",
-          "size"                  => 100,
-          "delete_on_termination" => true,
-          "volume_type"           => "gp2",
-        },
-        {
-          "mount"                 => "/mnt",
-          "file_system"           => "ext4",
-          "device"                => "/dev/sdo",
-          "delete_on_termination" => true,
-          "size"                  => params["mnt_volume_size"] || 100,
-          "volume_type"           => "gp2",
-        },
-        {
-          "mount"                 => nil,
-          "file_system"           => "swap",
-          "device"                => "/dev/sdp",
-          "delete_on_termination" => true,
-          "size"                  => 8,
-          "volume_type"           => "gp2",
-        },
-        { "device" => "/dev/sdb", "name"   => "ephemeral0", },
-      ]
-    end
-  end
-end
+class Ey::Core::Client
+  class Real
+    def create_server(params={})
+      request(
+        :method => :post,
+        :path   => "/servers",
+        :url    => params.delete("url"),
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def create_server(params={})
+      params = Cistern::Hash.stringify_keys(params)
+      server = params["server"]
+
+      require_parameters(params, "environment")
+      require_parameters(params["server"], "role", "location", "flavor")
+      if server["role"] == "util"
+        require_parameters(params["server"], "name")
+      end
+
+      request_id     = self.uuid
+      resource_id    = self.serial_id
+      provisioned_id = "i-#{SecureRandom.hex(4)}"
+      environment_id = resource_identity(params["environment"])
+      environment    = find(:environments, environment_id)
+      account        = resource_identity(environment["account"])
+      provider       = self.data[:providers].values.detect { |p| p["account"] == url_for("/accounts/#{account}") }
+
+      servers = self.data[:servers].values.select { |s| s["environment"] == url_for("/environments/#{environment_id}") }
+
+      if servers.count == 1 && servers.first["role"] == "solo" && server["role"] == "db_slave"
+        response(
+          :status => 422,
+          :body   => {"errors" => ["Cannot add a DB Slave"]},
+        )
+      end
+
+      resource = {
+        "account"          => url_for("/accounts/#{account}"),
+        "alerts"           => url_for("/servers/#{resource_id}/alerts"),
+        "created_at"       => Time.now.to_s,
+        "dedicated"        => !!server["dedicated"],
+        "deprovisioned_at" => nil,
+        "devices"          => block_device_map(server),
+        "enabled"          => true,
+        "environment"      => url_for("/environments/#{environment["id"]}"),
+        "flavor"           => { "id" => server["flavor"] },
+        "id"               => resource_id,
+        "location"         => environment["region"],
+        "logs"             => url_for("/servers/#{resource_id}/logs"),
+        "name"             => server["name"],
+        "private_hostname" => "#{provisioned_id}.private.example.org",
+        "provider"         => url_for("/providers/#{provider["id"]}"),
+        "provisioned_at"   => Time.now.to_s,
+        "provisioned_id"   => provisioned_id,
+        "public_hostname"  => "#{provisioned_id}.public.example.org",
+        "public_key"       => mock_ssh_key[:fingerprint],
+        "ssh_port"         => 22,
+        "state"            => "running",
+        "token"            => SecureRandom.hex(16),
+        "updated_at"       => Time.now.to_s,
+        "volumes"          => url_for("/servers/#{resource_id}/volumes"),
+        "role"             => server["role"],
+        "resource_url"     => url_for("/servers/#{resource_id}"),
+      }
+
+      request = {
+        "id"           => request_id,
+        "type"         => "provision_server",
+        "successful"   => "true",
+        "started_at"   => Time.now,
+        "finished_at"  => nil,
+        "resource_url" => url_for("/servers/#{resource_id}"),
+        "resource"     => [:servers, resource_id, resource],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body   => {"request" => response_hash},
+        :status => 201,
+      )
+    end
+
+    def block_device_map(params={})
+      [
+        {
+          "mount"                 => "/",
+          "file_system"           => "ext4",
+          "device"                => "/dev/sda",
+          "size"                  => 100,
+          "delete_on_termination" => true,
+          "volume_type"           => "gp2",
+        },
+        {
+          "mount"                 => "/mnt",
+          "file_system"           => "ext4",
+          "device"                => "/dev/sdo",
+          "delete_on_termination" => true,
+          "size"                  => params["mnt_volume_size"] || 100,
+          "volume_type"           => "gp2",
+        },
+        {
+          "mount"                 => nil,
+          "file_system"           => "swap",
+          "device"                => "/dev/sdp",
+          "delete_on_termination" => true,
+          "size"                  => 8,
+          "volume_type"           => "gp2",
+        },
+        { "device" => "/dev/sdb", "name"   => "ephemeral0", },
+      ]
+    end
+  end
+end

data/lib/ey-core/requests/create_ssl_certificate.rb

@@ -1,83 +1,83 @@
-class Ey::Core::Client
-  class Real
-    def create_ssl_certificate(params={})
-      account_id  = params["account"]
-      url         = params.delete("url")
-
-      request(
-        :method => :post,
-        :url    => url,
-        :path   => "/accounts/#{account_id}/ssl_certificates",
-        :body   => params
-      )
-    end
-  end # Real
-
-  class Mock
-    def create_ssl_certificate(params={})
-      url = params.delete("url")
-      account_id = params["account"] || url && path_params(url)["accounts"]
-
-      find(:accounts, account_id)
-
-      resource_id = self.uuid
-
-      resource = params["ssl_certificate"].dup
-
-      if resource.delete("self_sign")
-        key  = OpenSSL::PKey::RSA.new(1024)
-        name = OpenSSL::X509::Name.parse("/CN=example.org")
-
-        # NB: the order in which these attributes are set seems to be
-        # important in making it self-signed and not just a certificate
-        # with a mystery issuer. It's not clear which attributes have
-        # the ordering requirement.
-        cert = OpenSSL::X509::Certificate.new
-        cert.version    = 2
-        cert.serial     = Time.now.tv_sec            # monotonically increasing
-        cert.not_before = Time.now - (7 * 24 * 60 * 60) # allow for plenty of clock skew
-        cert.not_after  = Time.now + (10 * 356 * 24 * 60 * 60) # allow for plenty of clock skew
-        cert.subject    = name
-        cert.public_key = key.public_key
-        cert.issuer     = name
-
-        cert.sign(key, OpenSSL::Digest::SHA1.new)
-
-        resource["public_certificate"] = cert.to_pem
-        resource["private_key"]        = key.to_pem
-        resource["self_signed"]        = true
-      elsif ! resource['public_certificate'] or ! resource['private_key']
-        return response(status: 422, body: {"errors" => ["public_certificate and private_key must not be blank."]})
-      end
-
-      resource.merge!(
-        "account"      => url_for("/accounts/#{account_id}"),
-        "created_at"   => Time.now,
-        "id"           => resource_id,
-        "updated_at"   => Time.now,
-        "resource_url" => url_for("/ssl_certificates/#{resource_id}"),
-      )
-
-      request = {
-        "account"      => url_for("/accounts/#{account_id}"),
-        "created_at"   => Time.now,
-        "finished_at"  => nil,
-        "id"           => self.uuid,
-        "message"      => nil,
-        "read_channel" => nil,
-        "resource"     => [:ssl_certificates, resource_id, resource],
-        "started_at"   => Time.now,
-        "successful"   => true,
-        "type"         => "provision_ssl_certificate",
-        "updated_at"   => Time.now,
-      }
-
-      self.data[:requests][request["id"]] = request
-
-      response(
-        :body    => {"request" => request},
-        :status  => 201
-      )
-    end
-  end # Mock
-end # Ey::Core::Client
+class Ey::Core::Client
+  class Real
+    def create_ssl_certificate(params={})
+      account_id  = params["account"]
+      url         = params.delete("url")
+
+      request(
+        :method => :post,
+        :url    => url,
+        :path   => "/accounts/#{account_id}/ssl_certificates",
+        :body   => params
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_ssl_certificate(params={})
+      url = params.delete("url")
+      account_id = params["account"] || url && path_params(url)["accounts"]
+
+      find(:accounts, account_id)
+
+      resource_id = self.uuid
+
+      resource = params["ssl_certificate"].dup
+
+      if resource.delete("self_sign")
+        key  = OpenSSL::PKey::RSA.new(1024)
+        name = OpenSSL::X509::Name.parse("/CN=example.org")
+
+        # NB: the order in which these attributes are set seems to be
+        # important in making it self-signed and not just a certificate
+        # with a mystery issuer. It's not clear which attributes have
+        # the ordering requirement.
+        cert = OpenSSL::X509::Certificate.new
+        cert.version    = 2
+        cert.serial     = Time.now.tv_sec            # monotonically increasing
+        cert.not_before = Time.now - (7 * 24 * 60 * 60) # allow for plenty of clock skew
+        cert.not_after  = Time.now + (10 * 356 * 24 * 60 * 60) # allow for plenty of clock skew
+        cert.subject    = name
+        cert.public_key = key.public_key
+        cert.issuer     = name
+
+        cert.sign(key, OpenSSL::Digest::SHA1.new)
+
+        resource["public_certificate"] = cert.to_pem
+        resource["private_key"]        = key.to_pem
+        resource["self_signed"]        = true
+      elsif ! resource['public_certificate'] or ! resource['private_key']
+        return response(status: 422, body: {"errors" => ["public_certificate and private_key must not be blank."]})
+      end
+
+      resource.merge!(
+        "account"      => url_for("/accounts/#{account_id}"),
+        "created_at"   => Time.now,
+        "id"           => resource_id,
+        "updated_at"   => Time.now,
+        "resource_url" => url_for("/ssl_certificates/#{resource_id}"),
+      )
+
+      request = {
+        "account"      => url_for("/accounts/#{account_id}"),
+        "created_at"   => Time.now,
+        "finished_at"  => nil,
+        "id"           => self.uuid,
+        "message"      => nil,
+        "read_channel" => nil,
+        "resource"     => [:ssl_certificates, resource_id, resource],
+        "started_at"   => Time.now,
+        "successful"   => true,
+        "type"         => "provision_ssl_certificate",
+        "updated_at"   => Time.now,
+      }
+
+      self.data[:requests][request["id"]] = request
+
+      response(
+        :body    => {"request" => request},
+        :status  => 201
+      )
+    end
+  end # Mock
+end # Ey::Core::Client