groove-ey-core 3.6.1

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

@@ -0,0 +1,99 @@
+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, :agent, :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 agent
+    type, identity = resource_keys
+
+    (type == "agents" || nil) && self.connection.agents.get!(identity)
+  end
+
+  def database_server
+    type, identity = resource_keys
+
+    (type == "database-servers" || nil) && self.connection.database_servers.get!(identity)
+  end
+
+  def acknowledge!
+    requires :id
+    merge_attributes(self.connection.acknowledge_alert("id" => self.id).body["legacy_alert"])
+  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/ey-core/models/application.rb

@@ -0,0 +1,33 @@
+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
+  has_many :environment_variables
+
+  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/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/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/auto_scaling_alarm.rb

@@ -0,0 +1,54 @@
+class Ey::Core::Client::AutoScalingAlarm < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :deleted_at,             type: :time
+  attribute :created_at,             type: :time
+  attribute :updated_at,             type: :time
+  attribute :auto_scaling_policy_id, aliases: "auto_scaling_policy", squash: ["id"]
+  attribute :name
+  attribute :aggregation_type
+  attribute :metric_type
+  attribute :operand
+  attribute :trigger_value,          type: :float
+  attribute :number_of_periods,      type: :integer
+  attribute :period_length,          type: :integer
+  attribute :provisioned_id
+
+  has_one :auto_scaling_policy
+
+  def save!
+    requires :auto_scaling_policy_id, :trigger_value, :period_length
+    params = {
+      "auto_scaling_alarm" => {
+        "name" => name,
+        "trigger_value" => trigger_value,
+        "aggregation_type" => aggregation_type,
+        "metric_type" => metric_type,
+        "operand" => operand,
+        "period_length" => period_length,
+        "number_of_periods" => number_of_periods
+      },
+      "auto_scaling_policy_id"  => auto_scaling_policy_id
+    }
+
+    if new_record?
+      requires :name
+      request_attributes = connection.create_auto_scaling_alarm(params).body["request"]
+      connection.requests.new(request_attributes)
+    else
+      requires :identity
+      params.merge!("id" => identity)
+      connection.requests.new(connection.update_auto_scaling_alarm(params).body["request"])
+    end
+  end
+
+  def destroy!
+    requires :identity
+
+    connection.requests.new(
+      connection.destroy_auto_scaling_alarm("id" => identity).body["request"]
+    )
+  end
+end

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

@@ -0,0 +1,75 @@
+class Ey::Core::Client::AutoScalingGroup < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+  attribute :location_id
+  attribute :provisioned_id
+  attribute :minimum_size
+  attribute :maximum_size
+  attribute :desired_capacity
+  attribute :default_cooldown
+  attribute :grace_period
+
+  has_one :environment
+
+  def destroy
+    connection.requests.new(connection.destroy_auto_scaling_group("id" => self.identity).body["request"])
+  end
+
+  def save!
+    if new_record?
+      requires :maximum_size, :minimum_size, :environment
+
+      params = {
+        "url"                => self.collection.url,
+        "environment"        => self.environment_id,
+        "auto_scaling_group" => {
+          "maximum_size" => self.maximum_size,
+          "minimum_size" => self.minimum_size,
+        }
+      }
+
+      connection.requests.new(connection.create_auto_scaling_group(params).body["request"])
+    else
+      requires :identity
+
+      params = {
+        "id" => self.identity,
+        "auto_scaling_group" => {
+          "maximum_size" => self.maximum_size,
+          "minimum_size" => self.minimum_size,
+          "desired_capacity" => self.desired_capacity
+        }
+      }
+
+      connection.requests.new(connection.update_auto_scaling_group(params).body["request"])
+    end
+  end
+
+  def simple_auto_scaling_policies
+    auto_scaling_policies("simple")
+  end
+
+  def step_auto_scaling_policies
+    auto_scaling_policies("step")
+  end
+
+  def target_auto_scaling_policies
+    auto_scaling_policies("target")
+  end
+
+  private
+
+  def auto_scaling_policies(types = nil)
+    requires :identity
+    data = connection.get_auto_scaling_policies(
+      "auto_scaling_group" => identity,
+      "types" => [*types]
+    ).body["auto_scaling_policies"]
+
+    connection.auto_scaling_policies.load(data)
+  end
+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/base_auto_scaling_policy.rb

@@ -0,0 +1,61 @@
+class Ey::Core::Client::BaseAutoScalingPolicy < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :provisioned_id
+  attribute :provisioner_id
+  attribute :type
+  attribute :name
+  attribute :configuration
+  attribute :auto_scaling_group_id
+
+  has_one :auto_scaling_group
+
+  def save!
+    requires :auto_scaling_group_id, :type
+    params = {
+      "url"                 => self.collection.url,
+      "auto_scaling_policy" => {
+        "name" => self.name
+      }.merge(policy_params),
+      "auto_scaling_group_id"  => self.auto_scaling_group_id
+    }
+
+    if new_record?
+      policy_requires
+      requires :name
+      connection.requests.new(connection.create_auto_scaling_policy(params).body["request"])
+    else
+      requires :identity
+      params.merge("id" => identity)
+      connection.requests.new(connection.update_auto_scaling_policy(params).body["request"])
+    end
+  end
+
+  def destroy!
+    connection.requests.new(
+      self.connection.destroy_auto_scaling_policy("id" => self.id).body["request"]
+    )
+  end
+
+  def alarm
+    requires :identity
+
+    data = self.connection.get_auto_scaling_alarms(
+      "auto_scaling_policy_id" => identity
+    ).body["auto_scaling_alarms"]
+
+    self.connection.auto_scaling_alarms.load(data).first
+  end
+
+  private
+
+  def policy_params
+    raise NotImplementedError
+  end
+
+  def policy_requires
+    raise NotImplementedError
+  end
+end