ey-core 3.4.0 → 3.6.1

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

@@ -36,7 +36,7 @@ class Ey::Core::Client
             role_to_use = (type == 'app_instances' && index == 0) ? "app_master" : role
             server = server_hash(role: role_to_use, environment: environment, flavor: server_data["flavor"]["id"], name: server_data["name"])
             if role_to_use == "app_master"
-              if ip_id = params["cluster_configuration"]["ip_id"]
+              if ip_id = params["cluster_configuration"]["configuration"]["ip_id"]
                 if find(:addresses, ip_id)
                   server[:address] = url_for("/addresses/#{ip_id}")
                 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

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,6 +48,8 @@ class Ey::Core::Client
         "stack_name"            => "nginx_passenger4",
         "updated_at"            => Time.now,
         "username"              => "deploy",
+        "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/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_group.rb

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