ey-core 3.0.0

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

@@ -0,0 +1,18 @@
+class Ey::Core::Client::ApplicationDeployment < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :commit
+  attribute :created_at, type: :time
+  attribute :finished_at, type: :time
+  attribute :migrate_command
+  attribute :ref
+  attribute :serverside_version
+  attribute :started_at, type: :time
+  attribute :successful, type: :boolean
+
+  has_one :application
+  has_one :archive, resource: :application_archive, collection: :application_archives
+  has_one :task
+end

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

@@ -0,0 +1,52 @@
+class Ey::Core::Client::BackupFile < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :download_url
+  attribute :upload_url
+  attribute :filename
+  attribute :mime_type
+  attribute :metadata
+
+  has_one :backup
+
+  def save!
+    params = {
+      "url"         => self.collection.url,
+      "backup_file" => {
+        "filename"  => self.filename,
+        "mime_type" => self.mime_type,
+        "metadata"  => self.metadata,
+      },
+    }
+
+    if new_record?
+      merge_attributes(self.connection.create_backup_file(params).body["backup_file"])
+    else raise NotImplementedError # update
+    end
+  end
+
+  def upload(options)
+    requires :upload_url
+
+    params = {
+      "body"       => options[:body],
+      "file"       => options[:file],
+      "mime_type"  => options[:mime_type] || self.mime_type,
+      "upload_url" => self.upload_url,
+    }
+
+    self.connection.upload_file(params)
+  end
+
+  def download
+    requires :download_url
+
+    params = {
+      "url" => self.download_url,
+    }
+
+    self.connection.download_file(params)
+  end
+end

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

@@ -0,0 +1,27 @@
+class Ey::Core::Client::Billing < Ey::Core::Model
+  identity :id
+  attribute :state
+
+  def new(attributes = {})
+    self.class.new(attributes.merge(:connection => self.connection))
+  end
+
+  def put_state(id, state)
+    b = self.class.new(:connection => self.connection)
+    b.id = id
+    b.state = state
+    b.save!
+  end
+
+  def save!
+    params = {
+      "id"    => self.id,
+      "state" => self.state
+    }
+    merge_attributes(self.connection.update_billing(params).body["billing"])
+  end
+
+  def get(params)
+    merge_attributes(connection.get_billing(params).body["billing"])
+  end
+end

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

@@ -0,0 +1,11 @@
+class Ey::Core::Client::Component < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :created_at, type: :time
+  attribute :updated_at, type: :time
+  attribute :uri
+  attribute :name
+
+end

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

@@ -0,0 +1,14 @@
+class Ey::Core::Client::Contact < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :name
+  attribute :title
+  attribute :email
+  attribute :phone_number
+  attribute :created_at, type: :time
+  attribute :updated_at, type: :time
+  attribute :deleted_at, type: :time
+
+end

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

@@ -0,0 +1,16 @@
+class Ey::Core::Client::Cost < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  attribute :billing_month
+  attribute :data_type
+  attribute :level
+  attribute :finality
+  attribute :related_resource_type
+  attribute :category
+  attribute :units
+  attribute :description
+  attribute :value
+
+  has_one :account
+  has_one :environment
+end

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

@@ -0,0 +1,10 @@
+class Ey::Core::Client::DatabasePlanUsage < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  attribute :start_at,    type: :time
+  attribute :end_at,      type: :time
+  attribute :report_time, type: :time
+  attribute :type
+
+  has_one :database_service
+end

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

@@ -0,0 +1,56 @@
+class Ey::Core::Client::DatabaseServer < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :location
+  attribute :flavor
+  attribute :engine
+  attribute :version
+  attribute :storage, type: :integer
+  attribute :endpoint
+  attribute :provisioned_id
+  attribute :modifiers
+
+  attribute :deleted_at, type: :time
+
+  has_one :provider
+  has_one :database_service
+  has_one :replication_source, resource: :database_server
+
+  has_many :firewalls
+  has_many :messages
+  has_many :snapshots, model: :database_server_snapshots
+  has_many :revisions, model: :database_server_revisions
+  has_many :alerts
+
+  def save!
+    requires :replication_source, :provider_id
+
+    params = {
+      "url"              => self.collection.url,
+      "provider"         => self.provider_id,
+      "database_server"  => {
+        "replication_source" => self.replication_source_id,
+      },
+    }
+
+    if new_record?
+      self.connection.requests.new(self.connection.create_database_server(params).body["request"])
+    else
+      raise NotImplementedError
+    end
+  end
+
+  def destroy!
+    connection.requests.new(self.connection.destroy_database_server("id" => self.id).body["request"])
+  end
+
+  def master?
+    !replication_source
+  end
+
+  def discover
+    connection.requests.new(connection.discover_database_server("id" => self.identity).body["request"])
+  end
+end

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

@@ -0,0 +1,10 @@
+class Ey::Core::Client::DatabaseServerRevision < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :revision_time, type: :time
+  attribute :data,          type: :hash
+
+  has_one :database_server
+end

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

@@ -0,0 +1,43 @@
+class Ey::Core::Client::DatabaseServerSnapshot < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :deleted_at,     type: :time
+  attribute :engine
+  attribute :engine_version
+  attribute :location
+  attribute :provisioned_at, type: :time
+  attribute :provisioned_id
+  attribute :storage,        type: :integer
+
+  has_one :provider
+  has_one :database_server
+  has_one :database_service
+
+  attr_accessor :name
+
+  def save!
+    if new_record?
+      create_params = if collection.url
+                        { "url" => collection.url }
+                      elsif self.database_service
+                        { "database_service" => self.database_service.identity }
+                      else
+                        requires_one :database_server, :database_service
+
+                        { "database_service" => self.database_server.database_service.identity }
+                      end
+
+      connection.requests.new(
+        connection.create_database_service_snapshot(create_params.merge("name" => self.name)).body["request"]
+      )
+    end
+  end
+
+  def destroy!
+    connection.requests.new(
+      connection.destroy_database_server_snapshot("id" => self.identity).body["request"]
+    )
+  end
+end

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

@@ -0,0 +1,15 @@
+class Ey::Core::Client::DatabaseServerUsage < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  attribute :start_at,    type: :time
+  attribute :end_at,      type: :time
+  attribute :report_time, type: :time
+  attribute :flavor
+  attribute :provisioned_id
+  attribute :location
+  attribute :multi_az
+  attribute :master
+
+  has_one :database_service
+  has_one :provider
+end

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

@@ -0,0 +1,52 @@
+class Ey::Core::Client::DatabaseService < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :location
+  attribute :name
+  attribute :deleted_at, type: :time
+  attribute :service_level
+
+  has_one :provider
+
+  has_many :databases, model: :logical_databases
+  has_many :servers,   model: :database_servers
+  has_many :snapshots, model: :database_server_snapshots
+
+  # @todo remove me next major revision
+  attr_accessor :database_server
+
+  def save!
+    requires :name, :provider_id
+
+    server_info  = self.servers.map { |c| c.is_a?(Ey::Core::Client::DatabaseServer) ? c.attributes : c }
+
+    server_info += [database_server] if database_server
+
+    if server_info.size > 1
+      raise ArgumentError, "only one server can be specified"
+    elsif server_info.size < 1
+      raise ArgumentError, "you must specify at least one server dude"
+    end
+
+    params = {
+      "url"              => self.collection.url,
+      "provider"         => self.provider_id,
+      "database_server"  => server_info.first,
+      "database_service" => {
+        "name"          => self.name,
+        "service_level" => self.service_level,
+      },
+    }
+
+    if new_record?
+      self.connection.requests.new(self.connection.create_database_service(params).body["request"])
+    else raise NotImplementedError
+    end
+  end
+
+  def destroy!
+    connection.requests.new(self.connection.destroy_database_service("id" => self.id).body["request"])
+  end
+end

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

@@ -0,0 +1,143 @@
+class Ey::Core::Client::Environment < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :classic, type: :boolean
+  attribute :name
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+  attribute :monitor_url
+  attribute :region
+
+  has_one :account
+  has_one :database_service
+  has_one :firewall
+
+  has_many :costs
+  has_many :keypairs
+  has_many :servers
+  has_many :applications
+  has_many :logical_databases
+
+  attr_accessor :application_id
+
+  # @param application [Ey::Core::Client::Application]
+  # @option opts [Ey::Core::Client::ApplicationArchive] :archive
+  def deploy(application, opts={})
+    raise "Environment does not contain an app deployment for this application" unless self.applications.get(application.id)
+    raise ":ref is a required key" unless opts[:ref]
+    connection.requests.new(connection.deploy_environment_application({"deploy" => opts}.merge("id" => self.id, "application_id" => application.id)).body["request"])
+  end
+
+  # @param application [Ey::Core::Client::Application]
+  # @param action [String]
+  # @option opts [Ey::Core::Client::ApplicationArchive] :archive
+  def run_action(application, action, task={})
+    requires :id
+
+    response = self.connection.run_environment_application_action(
+      "environment" => self.id,
+      "application" => application.id,
+      "task"        => task,
+      "action"      => action,
+    )
+    connection.requests.new(response.body["request"])
+  end
+
+  def deprovision
+    connection.requests.new(self.connection.deprovision_environment("id" => self.id).body["request"])
+  end
+
+  def destroy!
+    connection.requests.new(self.connection.destroy_environment("id" => self.id).body["request"])
+  end
+
+  def application
+    if self.application_id
+      connection.applications.get(self.application_id)
+    end
+  end
+
+  def boot(options={})
+    options = Cistern::Hash.stringify_keys(options)
+    raise "configuration is a required key" unless options["configuration"]
+    raise "configuration['type'] is required" unless options["configuration"]["type"]
+
+    missing_keys = []
+
+    configuration = options["configuration"]
+    required_keys = %w(flavor volume_size mnt_volume_size)
+
+    if self.database_service
+      raise "application_id is a required key" unless options["application_id"]
+
+      configuration["logical_database"] = "#{self.name}_#{self.application.name}"
+    end
+
+    if configuration["type"] == 'custom'
+      apps      = configuration["apps"]      ||= {}
+      db_master = configuration["db_master"] ||= {}
+      db_slaves = configuration["db_slaves"] ||= []
+      utils     = configuration["utils"]     ||= []
+
+      missing_keys << "apps" unless apps.any?
+      (required_keys + ["count"]).each do |required|
+        missing_keys << "apps[#{required}]" unless apps[required]
+      end
+
+      unless configuration["database_service_id"]
+        missing_keys << "db_master" unless db_master.any?
+
+        required_keys.each do |key|
+          missing_keys << "db_master[#{key}]" unless db_master[key]
+        end
+      end
+
+      db_slaves.each_with_index do |slave, i|
+        (required_keys - ["volume_size", "mnt_volume_size"]).each do |key|
+          missing_keys << "db_slaves[#{i}][#{key}]" unless slave[key]
+        end
+      end
+
+      utils.each_with_index do |util, i|
+        required_keys.each do |key|
+          missing_keys << "utils[#{i}][#{key}]" unless util[key]
+        end
+      end
+    end
+
+    if missing_keys.any?
+      raise "Invalid configuration - The following keys are missing from the configuration:\n#{missing_keys.join(",\n")}"
+    end
+
+    params = {
+      "cluster_configuration" => {
+        "configuration" => configuration
+      }
+    }
+
+    connection.requests.new(self.connection.boot_environment(params.merge("id" => self.id)).body["request"])
+  end
+
+  def save!
+    requires :application_id, :account_id, :region
+
+    params = {
+      "url"         => self.collection.url,
+      "account"     => self.account_id,
+      "environment" => {
+        "name"                      => self.name,
+        "application_id"            => self.application_id,
+        "region"                    => self.region,
+      },
+    }
+
+    params["environment"].merge!("database_service" => self.database_service.id) if self.database_service
+
+    if new_record?
+      merge_attributes(self.connection.create_environment(params).body["environment"])
+    else raise NotImplementedError # update
+    end
+  end
+end