ey-core 3.0.0

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

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

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

@@ -0,0 +1,28 @@
+class Ey::Core::Client
+  class Real
+    def get_volumes(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params["url"]
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/volumes",
+        :url    => url,
+      )
+    end
+  end # Real
+  class Mock
+    def get_volumes(params={})
+      extract_url_params!(params)
+
+      headers, volumes_page = search_and_page(params, :volumes, search_keys: %w[server name size iops mount device])
+
+      response(
+        :body    => {"volumes" => volumes_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end

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

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

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

@@ -0,0 +1,26 @@
+class Ey::Core::Client
+  class Real
+    def request_callback(options={})
+      (url = options["url"]) || (id = options.fetch("id"))
+
+      request(
+        :path   => "/requests/#{id}/callback",
+        :method => :post,
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def request_callback(options={})
+      request_id = resource_identity(options)
+
+      request = find(:requests, request_id).dup
+      request.delete("resource")
+
+      response(
+        :body => {"request" => request},
+      )
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+class Ey::Core::Client
+  class Real
+    def reset_password(_params)
+      params = Cistern::Hash.stringify_keys(_params)
+
+      request(
+        :method => :put,
+        :path   => "/password-resets/#{params["reset_token"]}",
+        :body   => {
+          :password_reset => {
+            :password => params["password"]
+          }
+        },
+      )
+    end
+  end # Real
+
+  class Mock
+    def reset_password(*)
+      response(
+        :body => {
+          "password_reset" => {
+            "accepted" => true
+          },
+        },
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client
+

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

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

@@ -0,0 +1,23 @@
+class Ey::Core::Client
+  class Real
+    def update_application_archive(params={})
+      id             = params.delete("id")
+      application_id = params["application"]
+      request(
+        :method => :put,
+        :path   => "/applications/#{application_id}/archives/#{id}",
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def update_application_archive(params={})
+      archive = self.find(:application_archives, resource_identity(params))
+
+      response(
+        :body => {"application_archive" => archive.merge(params["application_archive"])},
+      )
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+class Ey::Core::Client
+  class Real
+    def update_billing(params={})
+      id = params.delete("id") or raise "ID needed"
+      request(
+        :method => :put,
+        :path   => "/accounts/#{id}/billing",
+        :params => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def update_billing(params={})
+      id = params["id"]
+      state = params["state"]
+      self.find(:accounts, id)
+
+      self.data[:billing][id] = state
+
+      response(
+        :body => {"billing" => {"id" => id, "state" => state}},
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,32 @@
+class Ey::Core::Client
+  class Real
+    def update_connector(params={})
+      request(
+        :method => :put,
+        :path   => "/connectors/#{params["id"]}",
+        :body   => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def update_connector(params={})
+      identity = resource_identity(params)
+      connector  = find(:connectors, identity)
+
+      update_params = Cistern::Hash.slice(params["connector"], "configuration")
+
+      # core api doesn't actually do this yet
+      if config = update_params.delete("configuration")
+        update_params["configuration"] = normalize_hash(config)
+      end
+
+      connector.merge!(update_params)
+
+      response(
+        :body => { "connector" => connector },
+        :status => 200
+      )
+    end
+  end # Mock
+end # Ey::Core::Client