ey-core 3.4.0 → 3.6.1

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

@@ -7,6 +7,7 @@ class Ey::Core::Client::Address < Ey::Core::Model
   attribute :ip_address
   attribute :provisioned_id
   attribute :location
+  attribute :scope
   attribute :disappeared_at, type: :time
 
   has_one :provider
@@ -37,6 +38,7 @@ class Ey::Core::Client::Address < Ey::Core::Model
         "provider" => self.provider_id,
         "address"  => {
           "location"       => self.location,
+          "scope"          => self.scope,
         },
       }
 

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

@@ -12,6 +12,7 @@ class Ey::Core::Client::Application < Ey::Core::Model
 
   has_many :archives, key: :application_archives
   has_many :keypairs
+  has_many :environment_variables
 
   def save!
     params = {

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/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

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

@@ -0,0 +1,17 @@
+class Ey::Core::Client::ContainerServiceDeployment < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :container_service_id
+  attribute :public_ip_address
+  attribute :private_ip_address
+  attribute :port_mappings
+  attribute :health_status
+  attribute :container_health_status
+  attribute :container_instance_id
+  attribute :task_arn
+  attribute :created_at, type: :time
+  attribute :updated_at, type: :time
+  attribute :deleted_at, type: :time
+end

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

@@ -17,10 +17,14 @@ class Ey::Core::Client::Environment < Ey::Core::Model
   attribute :release_label
   attribute :stack_name
   attribute :username
+  attribute :service_level
+  attribute :database_backup_limit
+  attribute :encrypted_ebs_for_everything
 
   has_one :account
   has_one :database_service
   has_one :firewall
+  has_one :auto_scaling_group
   has_one :assignee, assoc_name: :user, resource: :user
 
   has_many :costs
@@ -29,6 +33,7 @@ class Ey::Core::Client::Environment < Ey::Core::Model
   has_many :applications
   has_many :logical_databases
   has_many :deployments
+  has_many :environment_variables
 
   attr_accessor :application_id
 
@@ -125,21 +130,70 @@ class Ey::Core::Client::Environment < Ey::Core::Model
 
   def boot(options={})
     options = Cistern::Hash.stringify_keys(options)
+    connection.requests.new(self.connection.boot_environment(boot_params(options)).body["request"])
+  end
+
+  def unassign!
+    requires :id
+    merge_attributes(self.connection.unassign_environment("id" => self.id).body["environment"])
+  end
+
+  def save!
+    if new_record?
+      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,
+          "stack_name"                   => self.stack_name,
+          "database_stack"               => self.database_stack,
+          "release_label"                => self.release_label,
+          "language"                     => self.language,
+          "database_backup_limit"        => self.database_backup_limit,
+          "encrypted_ebs_for_everything" => self.encrypted_ebs_for_everything,
+        },
+      }
+
+      params["environment"].merge!("database_service" => self.database_service.id) if self.database_service
+
+      merge_attributes(self.connection.create_environment(params).body["environment"])
+    else
+      requires :identity
+      attributes = Cistern::Hash.slice(Cistern::Hash.stringify_keys(self.attributes), "nane", "release_label")
+      connection.update_environment(
+        "id"     => self.identity,
+        "environment" => attributes,
+      )
+    end
+  end
+
+  private
+
+  def boot_params(options)
+    params = {
+      "cluster_configuration" => {}
+    }
+    
     if options["blueprint_id"]
       params = {
         "cluster_configuration" => {
-          "blueprint_id" => options["blueprint_id"]
+          "blueprint_id" => options["blueprint_id"],
+          "configuration" => {}
         }
       }
       if ip_id = options["ip_id"]
-        params["cluster_configuration"]["ip_id"] = ip_id
+        params["cluster_configuration"]["configuration"]["ip_id"] = ip_id
       end
-
-      self.connection.requests.new(self.connection.boot_environment(params.merge("id" => self.id)).body["request"])
     else
       raise "configuration is a required key" unless options["configuration"]
       raise "configuration['type'] is required" unless options["configuration"]["type"]
+    end
 
+    if options['configuration']
       missing_keys = []
 
       configuration = options["configuration"]
@@ -187,49 +241,8 @@ class Ey::Core::Client::Environment < Ey::Core::Model
         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
-  end
-
-  def unassign!
-    requires :id
-    merge_attributes(self.connection.unassign_environment("id" => self.id).body["environment"])
-  end
-
-  def save!
-    if new_record?
-      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,
-          "stack_name"                => self.stack_name,
-          "database_stack"            => self.database_stack,
-          "release_label"             => self.release_label,
-          "language"                  => self.language,
-        },
-      }
-
-      params["environment"].merge!("database_service" => self.database_service.id) if self.database_service
-
-      merge_attributes(self.connection.create_environment(params).body["environment"])
-    else
-      requires :identity
-      attributes = Cistern::Hash.slice(Cistern::Hash.stringify_keys(self.attributes), "nane", "release_label")
-      connection.update_environment(
-        "id"     => self.identity,
-        "environment" => attributes,
-      )
+      params["cluster_configuration"]["configuration"] = configuration
     end
+    params.merge("id" => self.id)
   end
 end

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client::EnvironmentVariable < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :application_id
+  attribute :application_name
+  attribute :environment_id
+  attribute :environment_name
+  attribute :name
+  attribute :value
+  attribute :sensitive
+
+  has_one :environment
+  has_one :application
+
+  def save!
+    requires :name, :value
+    params = Cistern::Hash.slice(Cistern::Hash.stringify_keys(attributes), "id", "name", "value")
+
+    if new_record?
+      requires :application_id, :environment_id
+      params.merge!("application_id" => application_id, "environment_id" => environment_id)
+      merge_attributes(self.connection.create_environment_variable(params).body["environment_variable"])
+    else
+      merge_attributes(self.connection.update_environment_variable(params).body["environment_variable"])
+    end
+  end
+end

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

@@ -53,6 +53,12 @@ class Ey::Core::Client::Request < Ey::Core::Model
     case type
     when /address/
       self.connection.addresses.get!(resource_id)
+    when /auto_scaling_group/
+      self.connection.auto_scaling_groups.get!(resource_id)
+    when /auto_scaling_policy/
+      self.connection.auto_scaling_policies.get(resource_id)
+    when /auto_scaling_alarm/
+      self.connection.auto_scaling_alarms.get(resource_id)
     when /cluster_update/
       self.connection.cluster_updates.get!(resource_id)
     when /database_server_snapshot/

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

@@ -26,6 +26,7 @@ class Ey::Core::Client::Server < Ey::Core::Model
   attribute :updated_at,       type: :time
   attribute :wait_for_chef,    type: :boolean
   attribute :release_label
+  attribute :ip_id
 
   has_one :account
   has_one :address, collection: "addresses"
@@ -117,6 +118,7 @@ class Ey::Core::Client::Server < Ey::Core::Model
           "release_label"   => self.release_label,
           "role"            => self.role,
           "volume_size"     => self.volume_size,
+          "ip_id"           => self.ip_id
         }
       }
       connection.requests.new(connection.create_server(server_attributes).body["request"])

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

@@ -0,0 +1,24 @@
+class Ey::Core::Client::SimpleAutoScalingPolicy < Ey::Core::Client::BaseAutoScalingPolicy
+  identity :id
+  attribute :auto_scaling_group_id, aliases: "auto_scaling_group", squash: ["id"]
+  attribute :cooldown, type: :integer
+  attribute :action_unit
+  attribute :action_type
+  attribute :action_value
+
+  has_many :auto_scaling_alarms
+
+  def policy_params
+    {
+      "cooldown"     => cooldown,
+      "action_unit"  => action_unit,
+      "action_type"  => action_type,
+      "action_value" => action_value,
+      "type"         => type
+    }
+  end
+
+  def policy_requires
+    requires :action_value, :action_type, :action_unit
+  end
+end