groove-ey-core 3.6.1

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

@@ -0,0 +1,32 @@
+class Ey::Core::Client
+  class Real
+    def reset_server_state(params={})
+      id  = params.delete("id")
+      url = params.delete("url")
+
+      request(
+        :method => :put,
+        :path   => "servers/#{id}/reset_state",
+        :body   => params,
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def reset_server_state(params={})
+      id    = params["id"]
+      state = params["state"]
+
+      if server = self.data[:servers][id]
+        server[:state] = state
+        response(
+          :body   => {"server" => server},
+          :status => 200,
+        )
+      else
+        response(status: 404)
+      end
+    end
+  end # Mock
+end

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

@@ -0,0 +1,38 @@
+class Ey::Core::Client
+  class Real
+    def restart_environment_app_servers(params={})
+      id = params.delete("id")
+      url = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :put,
+        :path   => "environments/#{id}/app_restart",
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def restart_environment_app_servers(params={})
+      find(:environments, resource_identity(params))
+      request_id = self.uuid
+
+      request = {
+        "id"           => request_id,
+        "type"         => "app_deployment_maintenance",
+        "successful"   => "true",
+        "started_at"   => Time.now,
+        "finished_at"  => nil,
+        "resource_url" => nil
+      }
+
+      self.data[:requests][request_id] = request
+
+      response(
+        :body   => {"request" => request},
+        :status => 200,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+class Ey::Core::Client
+  class Real
+    def retrieve_docker_registry_credentials(account_id, location_id)
+      request(
+        :path => "/accounts/#{account_id}/docker-registry/#{location_id}/credentials"
+      )
+    end
+  end
+
+  class Mock
+    def retrieve_docker_registry_credentials(account_id, location_id)
+      response(
+        :body => {
+          'docker_registry_credentials' => {
+            'username'          => 'foo',
+            'password'          => 'bar',
+            'registry_endpoint' => "https://012345678901.dkr.ecr.#{location_id}.amazonaws.com",
+            'expires_at'        => (Time.now + 8 * 3600).to_i
+          }
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+class Ey::Core::Client
+  class Real
+    def run_cluster_application_action(params={})
+      cluster_id     = params.delete("cluster")
+      application_id = params.delete("application")
+      action         = params.delete("action")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/clusters/#{cluster_id}/applications/#{application_id}/actions/#{action}",
+      )
+    end
+  end # Real
+
+  class Mock
+    def run_cluster_application_action(params={})
+      cluster_id     = params.delete("cluster")
+      application_id = params.delete("application")
+
+      cluster_component = self.data[:cluster_components].values.find { |cc| cc["cluster"] == url_for("/clusters/#{cluster_id}") && cc["configuration"]["application"] == application_id }
+
+      response(status: 404) unless cluster_component
+
+      return run_cluster_component_action(params.merge("cluster_component" => cluster_component["id"]))
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def run_environment_application_action(params={})
+      environment_id = params.delete("environment")
+      application_id = params.delete("application")
+      action         = params.delete("action")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/environments/#{environment_id}/applications/#{application_id}/actions/#{action}"
+      )
+    end
+  end # Real
+
+  class Mock
+    def run_environment_application_action(params={})
+      environment_id = params.delete('environment')
+      application_id = params.delete('application')
+
+      clusters = self.data[:clusters].select { |k,c| c['environment'] == url_for("/environments/#{environment_id}") }
+      cluster_urls = clusters.keys.map { |k| url_for("/clusters/#{k}") }
+      cluster_components = self.data[:cluster_components].values.select { |cc| cluster_urls.include?(cc["cluster"]) && cc["configuration"]["application"] == application_id }
+
+      response(status: 404) unless cluster_components
+      cluster_components.map { |cc| run_cluster_component_action(params.merge("cluster_component" => cc["id"])) }.first
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,56 @@
+class Ey::Core::Client
+  class Real
+    def signup(_params)
+      params = Cistern::Hash.stringify_keys(_params)
+
+      request(
+        :method => :post,
+        :path   => "/signups",
+        :body   => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def signup(_params)
+      params = Cistern::Hash.stringify_keys(_params)
+
+      user_id = self.uuid
+
+      user = params["user"].dup
+      user.merge!({
+        "id"          => user_id,
+        "accounts"    => url_for("/users/#{user_id}/accounts"),
+        "memberships" => url_for("/users/#{user_id}/memberships"),
+        "keypairs"    => url_for("/users/#{user_id}/keypairs"),
+        "token"       => SecureRandom.hex(20)
+      })
+
+      self.data[:users][user_id] = user
+
+      account_id = self.uuid
+
+      account = mock_account_setup(account_id, params["account"].dup)
+
+      self.data[:accounts][account_id] = account.merge(:account_users => [user_id], :account_owners => [user_id])
+
+      (params["features"] || []).each do |resource_id|
+        feature = self.data[:features][resource_id]
+
+        account_url = url_for("/accounts/#{account_id}")
+        feature["account"] = account_url
+      end
+
+      response(
+        :body => {
+          "signup" => {
+            "user_id"     => user_id,
+            "account_id"  => account_id,
+            "upgrade_url" => "http://login.localdev.engineyard.com:9292/session-tokens/#{self.uuid}/upgrade",
+          },
+        },
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,39 @@
+class Ey::Core::Client
+  class Real
+    def start_server(params={})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :put,
+        :path   => "servers/#{id}/start",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def start_server(params={})
+      request_id  = self.uuid
+      identity = resource_identity(params)
+
+      find(:servers, identity)
+
+      start_request = {
+        "finished_at" => Time.now,
+        "id"          => request_id,
+        "started_at"  => Time.now,
+        "successful"  => "true",
+        "server"      => url_for("/servers/#{identity}"),
+        "type"        => "start_server_request",
+      }
+
+      self.data[:requests][request_id] = start_request
+
+      response(
+        :body   => {"request" => start_request},
+        :status => 201,
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,39 @@
+class Ey::Core::Client
+  class Real
+    def stop_server(params={})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :put,
+        :path   => "servers/#{id}/stop",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def stop_server(params={})
+      request_id  = self.uuid
+      identity = resource_identity(params)
+
+      find(:servers, identity)
+
+      stop_request = {
+        "finished_at" => Time.now,
+        "id"          => request_id,
+        "started_at"  => Time.now,
+        "successful"  => "true",
+        "server"      => url_for("/servers/#{identity}"),
+        "type"        => "stop_server_request",
+      }
+
+      self.data[:requests][request_id] = stop_request
+
+      response(
+        :body   => {"request" => stop_request},
+        :status => 201,
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,27 @@
+class Ey::Core::Client
+  class Real
+    def timeout_deployment(params={})
+      id  = params.delete("id")
+      url = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :put,
+        :path   => "deployments/#{id}/timeout",
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def timeout_deployment(params={})
+      deployment = find(:deployments, resource_identity(params))
+
+      deployment["successful"] = false
+
+      self.data[:deployments][deployment["id"]] = deployment
+
+      response(body: {"deployment" => deployment})
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+class Ey::Core::Client
+  class Real
+    def unassign_environment(params={})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :put,
+        :url    => url,
+        :path   => "/environments/#{id}/unassign",
+      )
+    end
+  end # Real
+
+  class Mock
+    def unassign_environment(params={})
+      request_id = self.uuid
+      url         = params.delete("url")
+
+      environment_id = params["id"] || url && url.split('/').last
+
+      environment = self.data[:environments][environment_id]
+      environment[:assignee] = nil
+
+      response(
+        :body   => {"environment" => environment},
+        :status => 200,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,28 @@
+class Ey::Core::Client
+  class Real
+    def update_addon(params={})
+      url = params.delete("url") or raise "URL needed"
+      request(
+        :method => :put,
+        :url    => url,
+        :params => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def update_addon(params={})
+      addon = params["addon"]
+
+      extract_url_params!(params)
+
+      find(:accounts, params["account"])
+
+      resource = self.find(:addons, params["addon"])
+
+      response(
+        :body => {"addon" => resource.merge!(addon) },
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def update_address(params={})
+      id = params["id"]
+
+      request(
+        :method => :put,
+        :path   => "addresses/#{id}",
+        :body   => {"address" => params.fetch("address")}
+      )
+    end
+  end # Real
+
+  class Mock
+    def update_address(params={})
+      identity = resource_identity(params)
+      address  = find(:addresses, identity)
+
+      address_params = Cistern::Hash.slice(Cistern::Hash.stringify_keys(params["address"]), "disappeared_at")
+
+      address.merge! address_params
+
+      response(
+        :body => { "address" => address },
+        :status => 200
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,32 @@
+class Ey::Core::Client
+  class Real
+    def update_alert(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+      id = params.delete("id")
+      body = { alert: params["alert"] }
+
+      request(
+        :method => :put,
+        :path   => "/alerts/#{id}",
+        :body   => body,
+      )
+    end
+  end
+
+  class Mock
+    def update_alert(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+      identity = params["id"]
+      alert  = find(:alerts, identity)
+
+      update_params = Cistern::Hash.slice(params["alert"],
+                                          "acknowledged", "ignored", "severity", "finished_at", "external_id", "started_at", "message")
+
+      alert.merge!(update_params.merge!("updated_at" => Time.now))
+
+      response(
+        :body => { "alert" => alert },
+      )
+    end
+  end
+end