ey-pro-cli 0.0.3

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

@@ -0,0 +1,36 @@
+class Ey::Core::Client::AddonAttachment < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :string
+
+  attribute :key
+  attribute :app_id
+  attribute :environment_id
+  attribute :suggested_name
+
+  def resource_url
+    "#{collection.url}/#{id}"
+  end
+
+  def attach!(key)
+    self.key = key
+    self.save!
+  end
+
+  def detach!
+    self.key = nil
+    self.save!
+  end
+
+  def save!
+    # always update
+    params = {
+      "attachment" => {
+        "key" => self.key,
+      },
+      "url" => self.resource_url,
+    }
+    merge_attributes(self.connection.update_addon_attachment(params).body["addon_attachment"])
+  end
+
+end

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

@@ -0,0 +1,46 @@
+class Ey::Core::Client::Address < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :name
+  attribute :ip_address
+  attribute :provisioned_id
+  attribute :location
+
+  has_one :provider
+  has_one :server
+
+  def detach
+    params = {
+      "id" => self.identity,
+    }
+
+    self.connection.requests.new(self.connection.detach_address(params).body["request"])
+  end
+
+  def attach(server)
+    params = {
+      "id"     => self.identity,
+      "server" => server.identity,
+    }
+
+    self.connection.requests.new(self.connection.attach_address(params).body["request"])
+  end
+
+  def save!
+    if new_record?
+      requires :provider_id, :location
+
+      params = {
+        "provider" => self.provider_id,
+        "address"  => {
+          "location" => self.location,
+        },
+      }
+
+      self.connection.requests.new(self.connection.create_address(params).body["request"])
+    else raise NotImplementedError
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+class Ey::Core::Client::Alert < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :acknowledged, type: :boolean
+  attribute :created_at, type: :time
+  attribute :description
+  attribute :external_id
+  attribute :finished_at, type: :time
+  attribute :ignored, type: :boolean
+  attribute :message
+  attribute :name
+  attribute :resource_url, aliases: "resource"
+  attribute :severity
+  attribute :started_at, type: :time
+  attribute :updated_at, type: :time
+
+  attr_writer :database_server, :server, :resource
+
+  def resource
+    type, identity = resource_keys
+
+    self.connection.public_send(type.gsub("-", "_")).get!(identity)
+  end
+
+  def resource_keys
+    requires :resource_url
+
+    resource_url.split("/")[-2..-1]
+  end
+
+  def server
+    type, identity = resource_keys
+
+    (type == "servers" || nil) && self.connection.servers.get!(identity)
+  end
+
+  def database_server
+    type, identity = resource_keys
+
+    (type == "database-servers" || nil) && self.connection.database_servers.get!(identity)
+  end
+
+  def save!
+    response = if new_record?
+                 params = {
+                   "url"   => self.collection.url,
+                   "alert" => {
+                     "description" => description,
+                     "external_id" => external_id,
+                     "finished_at" => finished_at,
+                     "message"     => message,
+                     "name"        => name,
+                     "severity"    => severity,
+                     "started_at"  => started_at,
+                   }
+                 }
+
+                 if @database_server
+                   params.merge!(database_server_id: @database_server.identity)
+                 elsif @server
+                   params.merge!(server_id: @server.identity)
+                 end
+
+                 self.connection.create_alert(params)
+               else
+                 requires :identity
+
+                 params = {
+                   :id    => self.id,
+                   :alert => {
+                     :acknowledged => acknowledged,
+                     :external_id  => external_id,
+                     :finished_at  => finished_at,
+                     :ignored      => ignored,
+                     :message      => message,
+                     :severity     => severity,
+                     :started_at   => started_at
+                   }
+                 }
+
+                 self.connection.update_alert(params)
+               end
+
+    merge_attributes(response.body["alert"])
+  end
+end

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

@@ -0,0 +1,32 @@
+class Ey::Core::Client::Application < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :language
+  attribute :name
+  attribute :repository
+  attribute :type
+
+  has_one :account
+
+  has_many :archives, key: :application_archives
+  has_many :keypairs
+
+  def save!
+    params = {
+      "url"         => self.collection.url,
+      "account"     => self.account_id,
+      "application" => {
+        "name"       => self.name,
+        "type"       => self.type,
+        "repository" => self.repository,
+      },
+    }
+
+    if new_record?
+      merge_attributes(self.connection.create_application(params).body["application"])
+    else raise NotImplementedError # update
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+class Ey::Core::Client::ApplicationArchive < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :sha256
+  attribute :filename
+  attribute :upload_successful
+  attribute :upload_url
+  attribute :url
+
+  has_one :application
+
+  # FIXME: hard coded in core, not exposed via api
+  def mime_type
+    "text/plain"
+  end
+
+  def save!
+    if new_record?
+      requires :filename
+      params = {
+        "url" => self.collection.url,
+        "application" => self.application_id,
+        "application_archive" => {
+          "filename" => filename,
+          "sha256"   => sha256,
+        },
+      }
+      merge_attributes(self.connection.create_application_archive(params).body["application_archive"])
+    else
+      params = {
+        "id" => id,
+        "application" => self.application_id,
+        "application_archive" => {
+          "upload_successful" => upload_successful,
+        }
+      }
+      merge_attributes(self.connection.update_application_archive(params).body["application_archive"])
+    end
+  end
+
+  def upload(options)
+    requires :upload_url
+
+    params = {
+      "body"       => options[:body] || File.read(options[:file]),
+      "mime_type"  => self.mime_type,
+      "upload_url" => self.upload_url,
+    }
+
+    self.connection.upload_file(params)
+
+    self.upload_successful = true
+    self.save
+  end
+
+  def download
+    requires :url
+
+    params = {
+      "url" => self.url,
+    }
+
+    self.connection.download_file(params)
+  end
+end

data/lib/vendor/core/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/vendor/core/ey-core/models/backup.rb

@@ -0,0 +1,36 @@
+class Ey::Core::Client::Backup < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :metadata
+  attribute :created_at, type: :time
+  attribute :updated_at, type: :time
+  attribute :finished_at, type: :time
+
+  has_one :cluster
+
+  has_many :files, key: :backup_files
+
+  def save!
+    requires :collection
+
+    params = {
+      "url"    => self.collection.url,
+      "backup" => {
+        "metadata" => self.metadata,
+      },
+    }
+
+    if new_record?
+      merge_attributes(self.connection.create_backup(params).body["backup"])
+    else raise NotImplementedError # update
+    end
+  end
+
+  def finish!
+    requires :id
+
+    merge_attributes(self.connection.finish_backup("id" => self.identity).body["backup"])
+  end
+end

data/lib/vendor/core/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/vendor/core/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/vendor/core/ey-core/models/cluster.rb

@@ -0,0 +1,80 @@
+class Ey::Core::Client::Cluster < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :location
+  attribute :name
+  attribute :configuration
+  attribute :deleted_at, type: :time
+
+  attribute :release_label
+
+  has_one :environment
+  has_one :provider
+
+  has_many :backups
+  has_many :cluster_components, aliases: "components"
+  has_many :firewalls
+  has_many :servers
+  has_many :slots
+  has_many :cluster_updates, aliases: "updates"
+
+  # @param application [Ey::Core::Client::Application]
+  # @option opts [Ey::Core::Client::ApplicationArchive] :archive
+  def deploy(application, opts={})
+    task = opts.dup
+
+    if archive = task.delete(:archive)
+      task["archive_id"] = archive.id
+    end
+
+    run_action(application, "deploy", task)
+  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_cluster_application_action(
+      "cluster"     => self.id,
+      "application" => application.id,
+      "task"        => task,
+      "action"      => action,
+    )
+    connection.requests.new(response.body["request"])
+  end
+
+  def save!
+    if new_record?
+      requires :name, :location, :provider_id
+      params = {
+        "cluster" => {
+          "location"      => self.location,
+          "name"          => self.name,
+          "provider"      => self.provider_id,
+          "release_label" => self.release_label,
+          "configuration" => self.configuration,
+        },
+        "environment" => self.environment_id,
+        "url"         => self.collection.url,
+      }
+      merge_attributes(self.connection.create_cluster(params).body["cluster"])
+    else
+      params = {
+        "id" => id,
+        "cluster" => {
+          "release_label" => self.release_label,
+          "configuration" => self.configuration,
+        }
+      }
+      merge_attributes(self.connection.update_cluster(params).body["cluster"])
+    end
+  end
+
+  def destroy!
+    connection.requests.new(connection.destroy_cluster(id).body["request"])
+  end
+end