ey-pro-cli 0.0.3

data/lib/vendor/core/ey-core/models/storage_user.rb

@@ -0,0 +1,44 @@
+class Ey::Core::Client::StorageUser < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :username
+  attribute :access_id
+  attribute :secret_key
+  attribute :provisioned_id
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+
+  has_one :storage
+
+  attr_accessor :permissions
+
+  def save!
+    requires :storage_id, :username
+
+    params = {
+        "url"          => self.collection.url,
+        "storage"      => self.storage_id,
+        "storage_user" => {
+          "username"    => self.username,
+          "permissions" => self.permissions
+        },
+    }
+
+    if new_record?
+      self.connection.requests.new(self.connection.create_storage_user(params).body["request"])
+    else raise NotImplementedError
+    end
+  end
+
+  def destroy!
+    requires :identity
+
+    params = {
+      "id" => self.identity,
+    }
+    connection.requests.new(connection.destroy_storage_user(params).body["request"])
+  end
+end

data/lib/vendor/core/ey-core/models/task.rb

@@ -0,0 +1,35 @@
+class Ey::Core::Client::Task < Ey::Core::Model
+  extend Ey::Core::Associations
+  include Ey::Core::Subscribable
+
+  identity :id
+
+  attribute :action
+  attribute :configuration
+  attribute :created_at, type: :time
+  attribute :finished_at, type: :time
+  attribute :message
+  attribute :started_at, type: :time
+  attribute :successful, type: :boolean
+  attribute :updated_at, type: :time
+
+  has_one :application_deployment
+  has_one :schedule
+
+  has_many :component_actions
+
+  def ready?
+    !!finished_at
+  end
+
+  def save!
+    params = {
+      "url" => self.collection.url,
+    }
+
+    if new_record?
+      connection.requests.new(self.connection.create_task(params).body["request"])
+    else raise NotImplementedError # update
+    end
+  end
+end

data/lib/vendor/core/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/vendor/core/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/vendor/core/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/vendor/core/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/vendor/core/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/vendor/core/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/vendor/core/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/vendor/core/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.serial_id
+      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

data/lib/vendor/core/ey-core/requests/cancel_account.rb

@@ -0,0 +1,33 @@
+class Ey::Core::Client
+  class Real
+    def cancel_account(resource_id, requested_by_id)
+      request(
+        :method => :post,
+        :path   => "account_cancellations",
+        :params => {"requested_by_id" => requested_by_id, "account_id" => resource_id},
+      )
+    end
+  end # Real
+
+  class Mock
+    def cancel_account(resource_id, requested_by_id)
+      self.data[:accounts][resource_id]['cancelled_at'] = Time.now
+      account_cancellation_id = self.uuid
+      self.data[:accounts][resource_id]['cancellation'] = url_for("/account_cancellations/#{account_cancellation_id}")
+      cancellation = {
+        "id" => account_cancellation_id,
+        "created_at" => Time.now,
+        "kind" => "self",
+      }
+      self.data[:account_cancellations]||= {}
+      self.data[:account_cancellations][account_cancellation_id] = cancellation
+      response(
+        :body    => {"cancellation" => cancellation},
+        :status  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

data/lib/vendor/core/ey-core/requests/create_account.rb

@@ -0,0 +1,33 @@
+class Ey::Core::Client
+  class Real
+    def create_account(params={})
+      request(
+        :method => :post,
+        :path   => "/accounts",
+        :params => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_account(params={})
+      resource_id = self.uuid
+      owner_id    = params["owner"] || @current_user && @current_user["id"]
+
+      find(:users, owner_id)
+
+      if name_prefix = params["account"].delete("name_prefix")
+        params["account"]["name"] = "#{name_prefix}-#{resource_id[0,4]}"
+      end
+
+      resource = mock_account_setup(resource_id, params["account"].dup)
+
+      self.data[:accounts][resource_id] = resource.merge(:account_users => [owner_id], :account_owners => [owner_id])
+
+      response(
+        :body    => {"account" => resource},
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client