ey-core 3.4.2 → 3.6.3

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/deployment.rb

@@ -9,6 +9,7 @@ class Ey::Core::Client::Deployment < Ey::Core::Model
   attribute :migrate_command
   attribute :ref
   attribute :resolved_ref
+  attribute :serverside_version
   attribute :started_at,     type: :time
   attribute :successful,     type: :boolean
   attribute :verbose

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,6 +130,54 @@ 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" => {
@@ -135,12 +188,12 @@ class Ey::Core::Client::Environment < Ey::Core::Model
       if ip_id = options["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"]
@@ -188,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

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

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

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

@@ -0,0 +1,24 @@
+class Ey::Core::Client::TargetAutoScalingPolicy < Ey::Core::Client::BaseAutoScalingPolicy
+  identity :id
+  attribute :auto_scaling_group_id, aliases: "auto_scaling_group", squash: ["id"]
+  attribute :estimated_warmup, type: :integer
+  attribute :target_value,     type: :float
+  attribute :disable_scale_in, type: :boolean
+  attribute :metric_type
+
+  has_many :auto_scaling_alarms
+
+  def policy_params
+    {
+      "estimated_warmup" => estimated_warmup,
+      "target_value"     => target_value,
+      "disable_scale_in" => disable_scale_in,
+      "metric_type"      => metric_type,
+      "type"             => type
+    }
+  end
+
+  def policy_requires
+    requires :target_value, :metric_type, :estimated_warmup
+  end
+end

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

@@ -24,6 +24,11 @@ class Ey::Core::Client
 
       self.data[:accounts][resource_id] = resource.merge(:account_users => [owner_id], :account_owners => [owner_id])
 
+      resource.merge!(
+        :environments_url => url_for("/accounts/#{resource_id}/environments"),
+        :applications_url => url_for("/accounts/#{resource_id}/applications")
+      )
+
       response(
         :body    => {"account" => resource},
         :status  => 201,

data/lib/ey-core/requests/create_address.rb

@@ -14,6 +14,7 @@ class Ey::Core::Client
       request_id  = self.uuid
       resource_id = self.serial_id
       provider_id = params["provider"]
+      scope       = params["scope"] || "standard"
 
       self.find(:providers, provider_id)
 

data/lib/ey-core/requests/create_application.rb

@@ -40,13 +40,14 @@ class Ey::Core::Client
       end
 
       resource.merge!(
-        "account"    => url_for("/accounts/#{account_id}"),
-        "archives"   => url_for("/applications/#{resource_id}/archives"),
-        "keypairs"   => url_for("/applications/#{resource_id}/keypairs"),
-        "language"   => language,
-        "created_at" => Time.now,
-        "updated_at" => Time.now,
-        "id"         => resource_id,
+        "account"               => url_for("/accounts/#{account_id}"),
+        "archives"              => url_for("/applications/#{resource_id}/archives"),
+        "keypairs"              => url_for("/applications/#{resource_id}/keypairs"),
+        "language"              => language,
+        "created_at"            => Time.now,
+        "updated_at"            => Time.now,
+        "id"                    => resource_id,
+        "environment_variables" => url_for("/applications/#{resource_id}/environment_variables")
       )
 
       key = mock_ssh_key

data/lib/ey-core/requests/create_auto_scaling_alarm.rb

@@ -0,0 +1,69 @@
+class Ey::Core::Client
+  class Real
+    def create_auto_scaling_alarm(options = {})
+      params = Cistern::Hash.stringify_keys(options)
+
+      url = params.delete("url")
+      auto_scaling_policy_id = params["auto_scaling_policy_id"]
+
+      body = {
+        auto_scaling_alarm: params,
+        auto_scaling_policy_id: auto_scaling_policy_id
+      }
+
+      request(
+        :method => :post,
+        :url    => url,
+        :path   => "/auto_scaling_policies/auto_scaling_alarms",
+        :body   => body
+      )
+    end
+  end
+
+  class Mock
+    def create_auto_scaling_alarm(options = {})
+      params = Cistern::Hash.stringify_keys(options)
+
+      request_id  = self.serial_id
+      resource_id = self.uuid
+
+      auto_scaling_policy_id = params.delete("auto_scaling_policy_id")
+      auto_scaling_policy = find(:auto_scaling_policies, auto_scaling_policy_id)
+
+      resource = params["auto_scaling_alarm"].dup
+      arn = "arn:aws:cloudwatch:eu-west-1:000000000000:metricAlarm:00000000-0000-0000-0000-000000000000:alarmName/#{resource["name"]}"
+
+      now = Time.now
+
+      resource.merge!(
+        "id"                  => resource_id,
+        "created_at"          => now,
+        "auto_scaling_policy" => auto_scaling_policy["id"],
+        "provisioned_id"      => arn,
+        "resource_url"        => url_for("/auto_scaling_alarms/#{resource_id}")
+      )
+
+      request = {
+        "id"           => request_id,
+        "created_at"   => now - 2,
+        "updated_at"   => now,
+        "started_at"   => now - 1,
+        "finished_at"  => now,
+        "message"      => nil,
+        "read_channel" => nil,
+        "resource"     => [:auto_scaling_alarms, resource_id, resource],
+        "resource_url" => url_for("/auto_scaling_alarms/#{resource_id}"),
+        "type"         => "provision_auto_scaling_alarm",
+        "successful"   => true,
+      }
+
+      self.data[:auto_scaling_alarms][resource_id] = resource
+      self.data[:requests][request_id] = request
+
+      response(
+        :body   => { "request" => request },
+        :status => 200
+      )
+    end
+  end
+end

data/lib/ey-core/requests/create_auto_scaling_group.rb

@@ -0,0 +1,62 @@
+class Ey::Core::Client
+  class Real
+    def create_auto_scaling_group(options={})
+      url = options.delete("url")
+
+      request(
+        :method => :post,
+        :url    => url,
+        :path   => "/auto_scaling_groups",
+        :body   => options
+      )
+    end
+  end
+
+  class Mock
+    def create_auto_scaling_group(options={})
+      url = options.delete("url")
+
+      environment_id = options.delete("environment")
+      environment = find(:environments, environment_id)
+      resource_id = self.uuid
+      resource = options["auto_scaling_group"].dup
+
+      now = Time.now
+
+      resource.merge!(
+        "created_at"       => now,
+        "environment"      => url_for("/environments/#{environment_id}"),
+        "id"               => resource_id,
+        "location_id"      => environment["region"],
+        "provisioned_id"   => "#{environment["name"]}#{SecureRandom.uuid}",
+        "desired_capacity" => 1,
+        "resource_url"     => url_for("/auto_scaling_groups/#{resource_id}"),
+      )
+
+      self.data[:auto_scaling_groups][resource_id] = resource
+
+      environment.merge!("auto_scaling_group" => url_for("/auto_scaling_groups/#{resource_id}"))
+
+      request = {
+        "created_at"   => now - 2,
+        "finished_at"  => now,
+        "id"           => self.uuid,
+        "message"      => nil,
+        "read_channel" => nil,
+        "resource"     => [:auto_scaling_groups, resource_id, resource],
+        "resource_url" => url_for("/auto_scaling_groups/#{resource_id}"),
+        "started_at"   => now - 1,
+        "successful"   => true,
+        "type"         => "provision_auto_scaling_group",
+        "updated_at"   => now,
+      }
+
+      self.data[:requests][request["id"]] = request
+
+      response(
+        :body   => {"request" => request},
+        :status => 200
+      )
+    end
+  end
+end