ey-core 3.4.4 → 3.6.4

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

@@ -33,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
 
@@ -129,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" => {
@@ -139,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"]
@@ -192,51 +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,
-          "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,
-      )
+      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

@@ -55,6 +55,10 @@ class Ey::Core::Client::Request < Ey::Core::Model
       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/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_policy.rb

@@ -0,0 +1,68 @@
+class Ey::Core::Client
+  class Real
+    def create_auto_scaling_policy(options = {})
+      params = Cistern::Hash.stringify_keys(options)
+      url = params.delete("url")
+      auto_scaling_group_id = params.delete("auto_scaling_group_id")
+      body = {
+        auto_scaling_policy: params,
+        auto_scaling_group_id: auto_scaling_group_id
+      }
+
+      request(
+        :method => :post,
+        :url    => url,
+        :path   => "/auto_scaling_policies",
+        :body   => body
+      )
+    end
+  end
+
+  class Mock
+    def create_auto_scaling_policy(options = {})
+      params = Cistern::Hash.stringify_keys(options)
+
+      request_id  = self.serial_id
+      resource_id = self.uuid
+
+      auto_scaling_group_id = params.delete("auto_scaling_group_id")
+      auto_scaling_group = find(:auto_scaling_groups, auto_scaling_group_id)
+
+      resource = params["auto_scaling_policy"].dup
+      arn = "scalingPolicy:00000000-0000-0000-0000-000000000000:autoScalingGroupName/#{auto_scaling_group["name"]}:policyName/#{resource["name"]}"
+
+      now = Time.now
+
+      resource.merge!(
+        "id"                  => resource_id,
+        "created_at"          => now,
+        "auto_scaling_group"  => auto_scaling_group["id"],
+        "arn"                 => arn,
+        "resource_url"        => url_for("/auto_scaling_policies/#{resource_id}"),
+        "auto_scaling_alarms" => url_for("/auto_scaling_alarms?auto_scaling_policy=#{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_policies, resource_id, resource],
+        "resource_url" => url_for("/auto_scaling_policies/#{resource_id}"),
+        "type"         => "provision_auto_scaling_policy",
+        "successful"   => true,
+      }
+
+      self.data[:auto_scaling_policies][resource_id] = resource
+      self.data[:requests][request_id] = request
+
+      response(
+        :body   => { "request" => request },
+        :status => 200
+      )
+    end
+  end
+end

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

@@ -48,7 +48,8 @@ class Ey::Core::Client
         "stack_name"            => "nginx_passenger4",
         "updated_at"            => Time.now,
         "username"              => "deploy",
-        "service_level"         => "default"
+        "service_level"         => "default",
+        "environment_variables" => url_for("/environments/#{resource_id}/environment_variables")
       )
 
       self.data[:environments][resource_id] = resource

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

@@ -0,0 +1,39 @@
+class Ey::Core::Client
+  class Real
+    def create_environment_variable(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+      environment_id = params.delete("environment_id")
+      application_id = params.delete("application_id")
+      body = { environment_variable: params, environment_id: environment_id, application_id: application_id }
+
+      request(
+        :method => :post,
+        :path   => "/environment_variables",
+        :body   => body
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_environment_variable(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+
+      resource_id = serial_id
+      environment = find(:environments, params["environment_id"])
+      application = find(:applications, params["application_id"])
+
+      params["id"] = resource_id
+      params["environment_name"] = environment["name"]
+      params["environment"] = url_for("/environments/#{environment['id']}")
+      params["application_name"] = application["name"]
+      params["application"] = url_for("/applications/#{application['id']}")
+
+      self.data[:environment_variables][resource_id] = params
+
+      response(
+        :body    => {"environment_variable" => params},
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -27,12 +27,14 @@ class Ey::Core::Client
       resource = params["user"].dup
 
       resource.merge!({
-        "id"          => resource_id,
-        "accounts"    => url_for("/users/#{resource_id}/accounts"),
-        "memberships" => url_for("/users/#{resource_id}/memberships"),
-        "keypairs"    => url_for("/users/#{resource_id}/keypairs"),
-        "tokens"      => url_for("/users/#{resource_id}/tokens"),
-        "api_token"   => SecureRandom.hex(16),
+        "id"            => resource_id,
+        "accounts"      => url_for("/users/#{resource_id}/accounts"),
+        "memberships"   => url_for("/users/#{resource_id}/memberships"),
+        "keypairs"      => url_for("/users/#{resource_id}/keypairs"),
+        "tokens"        => url_for("/users/#{resource_id}/tokens"),
+        "environments"  => url_for("/accounts/#{resource_id}/environments"),
+        "applications"  => url_for("/accounts/#{resource_id}/applications"),
+        "api_token"     => SecureRandom.hex(16),
       })
 
       self.data[:tokens][token_id] = {

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

@@ -30,6 +30,7 @@ class Ey::Core::Client
         "migrate_command" => options["deploy"]["migrate"] ? (options["deploy"]["migrate_command"] || "rake db:migrate") : nil,
         "migrate"         => options["deploy"]["migrate"] || false,
         "resolved_ref"    => options["deploy"]["ref"],
+        "serverside_version"    => options["deploy"]["serverside_version"],
         "started_at"      => Time.now,
         "successful"      => true
       }

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

@@ -0,0 +1,49 @@
+class Ey::Core::Client
+  class Real
+    def destroy_auto_scaling_alarm(params = {})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :delete,
+        :url    => url,
+        :path   => "/auto_scaling_alarms/#{id}",
+      )
+    end
+  end
+
+  class Mock
+    def destroy_auto_scaling_alarm(params = {})
+      request_id = self.uuid
+      url        = params.delete("url")
+
+      auto_scaling_alarm_id = params["id"] || url && url.split('/').last
+
+      auto_scaling_alarm = self.data[:auto_scaling_alarms][auto_scaling_alarm_id]
+      auto_scaling_alarm.merge!(
+        "deleted_at" => Time.now,
+        "resource_url" => url_for("/auto_scaling_alarms/#{auto_scaling_alarm_id}")
+      )
+
+      auto_scaling_policy = find(
+        :auto_scaling_policies,
+        resource_identity(auto_scaling_alarm["auto_scaling_policy"])
+      )
+      auto_scaling_policy.delete("auto_scaling_alarm")
+
+      self.data[:requests][request_id] = {
+        "id"          => request_id,
+        "finished_at" => nil,
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "resource"    => [:auto_scaling_alarms, auto_scaling_alarm_id, auto_scaling_alarm],
+        "type"        => "deprovision_auto_scaling_alarm",
+      }
+
+      response(
+        body:   { "request" => self.data[:requests][request_id] },
+        status: 201
+      )
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+class Ey::Core::Client
+  class Real
+    def destroy_auto_scaling_policy(params = {})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :delete,
+        :url    => url,
+        :path   => "/auto_scaling_policies/#{id}",
+      )
+    end
+  end
+
+  class Mock
+    def destroy_auto_scaling_policy(params = {})
+      request_id = self.uuid
+      url        = params.delete("url")
+
+      auto_scaling_policy_id = params["id"] || url && url.split('/').last
+
+      auto_scaling_policy = self.data[:auto_scaling_policies][auto_scaling_policy_id]
+      auto_scaling_policy.merge!(
+        "deleted_at" => Time.now,
+        "resource_url" => url_for("/auto_scaling_policies/#{auto_scaling_policy_id}")
+      )
+
+      auto_scaling_group = find(
+        :auto_scaling_groups,
+        resource_identity(auto_scaling_policy["auto_scaling_group"])
+      )
+      auto_scaling_group.delete("auto_scaling_policy")
+
+      self.data[:requests][request_id] = {
+        "id"          => request_id,
+        "finished_at" => nil,
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "resource"    => [:auto_scaling_policies, auto_scaling_policy_id, auto_scaling_policy],
+        "type"        => "deprovision_auto_scaling_policy",
+      }
+
+      response(
+        body:   { "request" => self.data[:requests][request_id] },
+        status: 201
+      )
+    end
+  end
+end