ey-core 3.4.2 → 3.6.3

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

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

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

@@ -0,0 +1,71 @@
+class Ey::Core::Client
+  class Real
+    def discover_container_service_deployments(params={})
+      url      = params.delete("url")
+
+      request(
+        :method => :get,
+        :url    => url,
+        :params => params,
+        :path   => "/container_service_deployments/discover",
+      )
+    end
+  end
+
+  class Mock
+    def discover_container_service_deployments(params={})
+      extract_url_params!(params)
+
+      callback_url  = params.delete("callback_url")
+      deployment_id = self.uuid
+      resource_id   = self.uuid
+
+      existing_deploymens = self.data[:container_service_deployments].values.select do |deployment|
+        deployment["container_service_id"] == container_service["id"]
+      end
+      existing_deploymens = nil if existing_deploymens.empty?
+
+      resources = existing_deploymens || [{
+        "id"                    => deployment_id,
+        "container_service_id"  => params["container_service_id"],
+        "public_ip_address"     => "123.456.789.123",
+        "private_ip_address"    => "10.0.1.2",
+        "container_instance_id" => SecureRandom.uuid,
+        "port_mappings"         => [{
+          "container_port"      => "80",
+          "host_port"           => "80",
+          "protocol"            => "tcp"
+        }],
+        "provisioned_id"        => resource_id,
+        "health_status"         => "HEALTHY",
+        "task_arn"              => SecureRandom.uuid,
+        "container_health_status" => [{
+          "container_arn"     => SecureRandom.uuid,
+          "health_status"     => SecureRandom.uuid
+        }]
+      }]
+
+      request = {
+        "id" => request_id,
+        "type" => "discover_container_service_deployments",
+        "successful" => true,
+        "started_at" => Time.now,
+        "finished_at" => nil,
+        "resource" => [:container_service_deployments, resource_id, resources, "/container_service_deployments"]
+      }
+
+      self.data[:container_service_deployments][deployment_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+class Ey::Core::Client
+  class Real
+    def discover_server(options={})
+      provider_id = options.delete("provider")
+
+      request(
+        :method => :post,
+        :path   => "/providers/#{provider_id}/servers/discover",
+        :body   => options
+      )
+    end
+  end
+
+  class Mock
+    def discover_server(options={})
+      options = Cistern::Hash.stringify_keys(options)
+
+      provider_id = options.delete("provider")
+      request_id = self.uuid
+
+      options["server"]["role"] ||= "app"
+      options["server"]["flavor"] ||= "m4.large"
+
+      server = self.data[:servers].values.detect do |s|
+        !s["deleted_at"] && s["provider"] == url_for("/providers/#{provider_id}") && s["provisioned_id"] == options["server"]["provisioned_id"]
+      end
+
+      resource = if server
+                   server
+                 else
+                   if auto_scaling_group_id = options["auto_scaling_group"]
+                     find(:auto_scaling_groups, auto_scaling_group_id)
+                   end
+
+                   s = self.requests.new(create_server(options).body["request"]).resource! # cheating
+                   self.data[:servers][s.id]
+                 end
+
+      request = {
+        "id"           => request_id,
+        "type"         => "discover_server",
+        "successful"   => true,
+        "started_at"   => Time.now,
+        "finished_at"  => nil,
+        "resource_url" => url_for("/servers/#{resource["id"]}"),
+        "resource"     => [:servers, resource["id"], resource],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body   => {"request" => response_hash},
+        :status => 201,
+      )
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ class Ey::Core::Client
     def get_applications(params={})
       extract_url_params!(params)
 
-      headers, applications_page = search_and_page(params, :applications, search_keys: %w[type repository account name environment])
+      headers, applications_page = search_and_page(params, :applications, search_keys: %w[id type repository account name environment])
 
       response(
         :body    => {"applications" => applications_page},

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

@@ -0,0 +1,27 @@
+class Ey::Core::Client
+  class Real
+    def get_auto_scaling_alarm(params = {})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :get,
+        :path   => "auto_scaling_alarms/#{id}",
+        :url    => url
+      )
+    end
+  end
+
+  class Mock
+    def get_auto_scaling_alarm(params = {})
+      response(
+        :body => {
+          "auto_scaling_alarm" => self.find(
+            :auto_scaling_alarms,
+            resource_identity(params)
+          )
+        },
+      )
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+class Ey::Core::Client
+  class Real
+    def get_auto_scaling_alarms(params = {})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :path   => "/auto_scaling_alarms",
+        :query  => params,
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def get_auto_scaling_alarms(params = {})
+      extract_url_params!(params)
+
+      headers, auto_scaling_alarms_page = search_and_page(
+        params,
+        :auto_scaling_alarms,
+        search_keys: %w{ id auto_scaling_policy },
+        resources: data[:auto_scaling_alarms]
+      )
+
+      response(
+        :body    => { "auto_scaling_alarms" => auto_scaling_alarms_page },
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+class Ey::Core::Client
+  class Real
+    def get_auto_scaling_group(params={})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :path => "auto_scaling_groups/#{id}",
+        :url  => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_auto_scaling_group(params={})
+      response(
+        :body => {"auto_scaling_group" => self.find(:auto_scaling_groups, resource_identity(params))},
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def get_auto_scaling_groups(options={})
+      query = Ey::Core.paging_parameters(options)
+      url   = options.delete("url")
+
+      request(
+        :params => options,
+        :query  => query,
+        :path   => "/auto_scaling_groups",
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def get_auto_scaling_groups(options={})
+      extract_url_params!(options)
+
+      headers, auto_scaling_groups_page = search_and_page(options, :auto_scaling_groups, search_keys: %w[environment environment_id account account_id provider provider_id provisioned_id])
+
+      response(
+        :body    => {"auto_scaling_groups" => auto_scaling_groups_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+class Ey::Core::Client
+  class Real
+    def get_auto_scaling_policies(params = {})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :path   => "/auto_scaling_policies",
+        :query  => params,
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def get_auto_scaling_policies(params = {})
+      extract_url_params!(params)
+
+      resources = data[:auto_scaling_policies].select { |_key, policy| filter_policy(params, policy) }
+      params.delete("types")
+
+      headers, auto_scaling_policies_page = search_and_page(
+        params,
+        :auto_scaling_policies,
+        search_keys: %w{ id auto_scaling_group },
+        resources: resources
+      )
+
+      response(
+        :body    => { "auto_scaling_policies" => auto_scaling_policies_page },
+        :status  => 200,
+        :headers => headers
+      )
+    end
+
+    private
+
+    def filter_policy(params, item)
+      return false if params["auto_scaling_group"] != item["auto_scaling_group"]
+
+      types = params["types"]
+      types.is_a?(::Array) && types.include?(item["type"])
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+class Ey::Core::Client
+  class Real
+    def get_auto_scaling_policy(params = {})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :get,
+        :path   => "auto_scaling_policies/#{id}",
+        :url    => url
+      )
+    end
+  end
+
+  class Mock
+    def get_auto_scaling_policy(params = {})
+      response(
+        :body => {
+          "auto_scaling_policy" => self.find(
+            :auto_scaling_policies,
+            resource_identity(params)
+          )
+        },
+      )
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ class Ey::Core::Client
       request(
         :params => params,
         :path   => "/deployments",
-        :query  => params,
+        :query  => query,
         :url    => url,
       )
     end

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

@@ -0,0 +1,19 @@
+class Ey::Core::Client
+  class Real
+    def get_environment_variable(params={})
+      id  = params.delete("id")
+      url = params.delete("url")
+
+      request(
+        :path => "environment_variables/#{id}",
+        :url  => url,
+      )
+    end
+  end
+
+  class Mock
+    def get_environment_variable(params={})
+      response(body: {"environment_variable" => find(:environment_variables, resource_identity(params))})
+    end
+  end
+end