ey-core 3.0.0

data/lib/ey-core/models/token.rb

@@ -0,0 +1,20 @@
+class Ey::Core::Client::Token < Ey::Core::Model
+
+  identity :auth_id
+
+  attribute :on_behalf_of
+
+  def save!
+    params = {
+      "on_behalf_of" => {
+        "id"   => self.on_behalf_of.id,
+        "type" => self.on_behalf_of.class.api_name,
+      }
+    }
+    if new_record?
+      merge_attributes(self.connection.create_token(params).body["token"])
+    else raise NotImplementedError # update
+    end
+  end
+
+end

data/lib/ey-core/models/untracked_address.rb

@@ -0,0 +1,24 @@
+class Ey::Core::Client::UntrackedAddress < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  attribute :provisioned_id
+  attribute :provisioner_id
+  attribute :location
+
+  has_one :provider
+  has_one :address
+
+  def save!
+    request_attributes = {
+      "provider" => self.provider_id,
+      "url"      => self.collection.url,
+      "untracked_address"  => {
+        "location" => self.location,
+        "provisioned_id" => self.provisioned_id,
+        "provisioner_id" => self.provisioner_id,
+      }
+    }
+
+    merge_attributes(connection.create_untracked_address(request_attributes).body["untracked_address"])
+  end
+end

data/lib/ey-core/models/untracked_server.rb

@@ -0,0 +1,45 @@
+class Ey::Core::Client::UntrackedServer < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :provisioned_id
+  attribute :provisioner_id
+  attribute :location
+  attribute :state
+  attribute :created_at, type: :time
+  attribute :updated_at, type: :time
+
+  has_one :provider
+
+  def save!
+    request_attributes = {
+      "provider" => self.provider_id,
+      "url"      => self.collection.url,
+    }
+
+    response = if new_record?
+                 requires :location, :provisioned_id
+
+                 request_attributes.merge!(
+                   "untracked_server" => Cistern::Hash.slice(
+                     Cistern::Hash.stringify_keys(self.attributes), "location", "provisioned_id", "provisioner_id", "state"
+                   ),
+                 )
+
+                 connection.create_untracked_server(request_attributes)
+               else
+                 requires :identity
+
+                 request_attributes.merge!(
+                   "untracked_server" => Cistern::Hash.slice(
+                     Cistern::Hash.stringify_keys(self.attributes), "location", "provisioner_id", "state"
+                   ),
+                 )
+
+                 connection.update_untracked_server(request_attributes.merge("id" => self.identity))
+               end
+
+    merge_attributes(response.body["untracked_server"])
+  end
+end

data/lib/ey-core/models/user.rb

@@ -0,0 +1,35 @@
+class Ey::Core::Client::User < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :name
+  attribute :email
+  attribute :staff
+  attribute :deleted_at
+
+  has_many :accounts
+  has_many :keypairs
+
+  attr_accessor :password
+
+  def self.api_name
+    "User"
+  end
+
+  def save!
+    requires :name, :email
+
+    params = {
+      "name"  => self.name,
+      "email" => self.email,
+      "password" => self.password,
+    }
+
+    merge_attributes(self.connection.create_user("user" => params).body["user"])
+  end
+
+  def destroy!
+    self.connection.destroy_user("id" => self.id) && true
+  end
+end

data/lib/ey-core/models/volume.rb

@@ -0,0 +1,20 @@
+class Ey::Core::Client::Volume < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :device
+  attribute :file_system
+  attribute :format
+  attribute :iops, type: :integer
+  attribute :location
+  attribute :mount
+  attribute :mount_options
+  attribute :name
+  attribute :provisioned_id, type: :integer
+  attribute :size, type: :integer
+
+  has_one :provider
+  has_one :server
+  has_one :snapshot
+end

data/lib/ey-core/request.rb

@@ -0,0 +1,21 @@
+module Ey::Core::Request
+  def method_missing(method, *args, &block)
+    if service.respond_to?(method)
+      service.send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  attr_reader :params
+
+  def _real(params)
+    @params = params.dup
+    real
+  end
+
+  def _mock(params)
+    @params = params.dup
+    mock
+  end
+end

data/lib/ey-core/request_failure.rb

@@ -0,0 +1,11 @@
+class Ey::Core::RequestFailure < StandardError
+  attr_reader :request
+
+  def initialize(request)
+    @request = request
+
+    message = "#{request.message} (#{request.type}) [#{request.id}]"
+    message = "#{message} #{request.resource.attributes.inspect}" if request.resource
+    super(message)
+  end
+end

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

@@ -0,0 +1,53 @@
+class Ey::Core::Client
+  class Real
+    def attach_address(params={})
+      id = params.delete("id")
+
+      request(
+        :method => :put,
+        :path   => "addresses/#{id}/attach",
+        :params => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def attach_address(params={})
+      resource_id = params.delete("id")
+      server_id   = params.delete("server").to_i
+      request_id  = self.uuid
+
+      server = self.find(:servers, server_id)
+      server.merge!(
+        "address_url" => "/addresses/#{resource_id}",
+      )
+
+      resource = self.data[:addresses][resource_id]
+      resource.merge!(
+        "server_url" => "/servers/#{server_id}",
+      )
+
+      request = {
+        "id"          => request_id,
+        "type"        => "attach_address",
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:addresses, resource_id, resource],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,22 @@
+class Ey::Core::Client
+  class Real
+    def authorized_channel(path)
+      request(
+        :path   => "/channels",
+        :params => {"channel" => {"path" => path}}
+      )
+    end
+  end # Real
+
+  class Mock
+    def authorized_channel(path)
+      if task = self.data[:tasks].values.find { |t| Addressable::URI.parse(t["read_channel"]).query_values["subscription"] == path }
+        response(
+          :body => {"task" => task},
+        )
+      else
+        response(status: 404, :body => {"errors" => ["Couldn't find Awsm::Task with [channel_path: #{path}]"]})
+      end
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,131 @@
+class Ey::Core::Client
+  class Real
+    def boot_environment(params={})
+      id = params.delete("id")
+
+      request(
+        :path   => "/environments/#{id}/boot",
+        :method => :post,
+        :body   => params
+      )
+    end
+  end
+
+  class Mock
+    def boot_environment(params={})
+      id            = params.delete("id")
+      configuration = params["cluster_configuration"]["configuration"]
+      request_id    = self.uuid
+      environment   = find(:environments, id)
+
+      servers = {}
+
+      case configuration["type"]
+      when "solo"
+        server = server_hash(environment: environment)
+        servers[server["id"]] = server
+      when "cluster"
+        %w(app_master app db_master).each do |role|
+          server = server_hash(role: role, environment: environment)
+          servers[server["id"]] = server
+        end
+      when "production"
+        %w(app_master app app db_master db_slave).each do |role|
+          server = server_hash(role: role, environment: environment)
+          servers[server["id"]] = server
+        end
+      when "custom"
+        raise "not implemented"
+      end
+
+      self.data[:servers].merge!(servers)
+
+      request = {
+        "id"          => request_id,
+        "type"        => "boot_environment",
+        "successful"  => true,
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:environments, id, environment],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+
+    def server_hash(options={})
+      id             = self.serial_id
+      flavor         = options.delete(:flavor)
+      role           = options.delete(:role)
+      name           = options.delete(:name)
+      environment    = options.delete(:environment)
+      provisioned_id = "i-#{SecureRandom.hex(4)}"
+      provider       = get_providers("account" => environment["account"]).body["providers"].first
+      {
+        "alerts"           => url_for("/servers/#{id}/alerts"),
+        "created_at"       => Time.now.to_s,
+        "deprovisioned_at" => Time.now.to_s,
+        "devices"          => block_device_map,
+        "enabled"          => true,
+        "environment"      => url_for("/environments/#{environment["id"]}"),
+        "flavor"           => { "id" => flavor },
+        "id"               => id,
+        "location"         => environment["region"],
+        "logs"             => url_for("/servers/#{id}/logs"),
+        "name"             => name,
+        "private_hostname" => "#{provisioned_id}.private.example.org",
+        "provider"         => provider,
+        "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/#{id}/volumes"),
+        "role"             => role,
+      }
+    end
+
+    def block_device_map
+      [
+        {
+          "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"                  => 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/bootstrap_logical_database.rb

@@ -0,0 +1,80 @@
+class Ey::Core::Client
+  class Real
+    def bootstrap_logical_database(params={})
+      request(
+        :method => :post,
+        :path   => "/logical-databases/bootstrap",
+        :url    => params.delete("url"),
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def bootstrap_logical_database(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+      provider_id = resource_identity(params["provider"])
+      find(:providers, provider_id)
+
+      logical_database_name = require_parameters(params["logical_database"], "name")
+      request_id  = self.uuid
+      resource_id = self.uuid
+
+      database_service = params["database_service"]
+
+      if database_service.is_a?(Hash)
+        require_parameters(params["database_service"], "name")
+        database_service["id"] = self.uuid
+      else
+        database_service = find(:database_services, database_service)
+        existing_database_service = true
+      end
+
+      resource = {
+        "username"     => "eyuser#{SecureRandom.hex(4)}",
+        "password"     => SecureRandom.hex(16),
+        "name"         => logical_database_name,
+        "id"           => resource_id,
+        "resource_url" => "/logical-databases/#{resource_id}",
+        "service"      => url_for("/database-services/#{database_service.fetch("id")}"),
+        "deleted_at"   => nil,
+      }
+
+      request_resource = if existing_database_service
+                           { "resource" => [:logical_databases, resource_id, resource] }
+                         else
+                           {
+                             "resource" => [
+                               :logical_databases,
+                               request_id,
+                               create_database_service_resource(
+                                 "logical_database" => resource,
+                                 "database_service" => database_service,
+                                 "database_server"  => params["database_server"].dup,
+                                 "provider_id"      => provider_id,
+                               )
+                             ],
+                           }
+                         end
+
+      request = {
+        "id"           => request_id,
+        "type"         => "bootstrap_logical_database",
+        "successful"   => "true",
+        "started_at"   => Time.now,
+        "finished_at"  => nil,
+        "resource_url" => "/logical-databases/#{resource_id}",
+      }.merge(request_resource)
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body   => {"request" => response_hash},
+        :status => 201,
+      )
+    end
+  end
+end