ey-core 3.0.0

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def get_keypair_deployments(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/keypair-deployments",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_keypair_deployments(params={})
+      extract_url_params!(params)
+
+      headers, keypair_deployments_page = search_and_page(params, :keypair_deployments, search_keys: %w[keypair name fingerprint target])
+
+      response(
+        :body    => {"keypair_deployments" => keypair_deployments_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,34 @@
+class Ey::Core::Client
+  class Real
+    def get_keypairs(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/keypairs",
+        :url    => url,
+      )
+    end
+  end  #  Real
+
+  class Mock
+    def get_keypairs(params={})
+      extract_url_params!(params)
+
+      if environment = params.delete("environment")
+        deployments = get_keypair_deployments("target" => environment).body["keypair_deployments"]
+        params["id"] = deployments.map {|d| resource_identity(d["keypair"]) }
+      end
+
+      headers, keypairs_page = search_and_page(params, :keypairs, search_keys: %w[application user name fingerprint id])
+
+      response(
+        :body    => {"keypairs" => keypairs_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end  #  Mock
+end

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

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

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def get_legacy_alerts(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/legacy-alerts",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_legacy_alerts(params={})
+      extract_url_params!(params)
+
+      headers, alerts_page = search_and_page(params, :legacy_alerts, search_keys: %w[environment server severity assigned acknowledged])
+
+      response(
+        :body    => {"legacy_alerts" => alerts_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end

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

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

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

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

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

@@ -0,0 +1,30 @@
+class Ey::Core::Client
+  class Real
+    def get_load_balancer_nodes(params={})
+      query                    = Ey::Core.paging_parameters(params)
+      load_balancer_service_id = params.delete("load_balancer_service")
+      url                      = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/load-balancer-service/#{load_balancer_service_id}/nodes",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_load_balancer_nodes(params={})
+      extract_url_params!(params)
+
+      headers, load_balancers_nodes_page = search_and_page(params, :load_balancer_nodes, search_keys: %w[load_balancer_service name server])
+
+      response(
+        :body    => {"load_balancer_nodes" => load_balancer_servicess_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end

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

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

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

@@ -0,0 +1,30 @@
+class Ey::Core::Client
+  class Real
+    def get_load_balancer_services(params={})
+      query            = Ey::Core.paging_parameters(params)
+      load_balancer_id = params.delete("load_balancer_id")
+      url              = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/load-balancers/#{load_balancer_id}/services",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_load_balancer_services(params={})
+      extract_url_params!(params)
+
+      headers, page = search_and_page(params, :load_balancer_services, search_keys: %w[load_balancer provider_ssl_certificate protocol external_port internal_port])
+
+      response(
+        :body    => {"load_balancer_services" => page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def get_load_balancers(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/load-balancers",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_load_balancers(params={})
+      extract_url_params!(params)
+
+      headers, load_balancers_page = search_and_page(params, :load_balancers, search_keys: %w[name])
+
+      response(
+        :body    => {"load_balancers" => load_balancers_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end

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

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

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

@@ -0,0 +1,23 @@
+class Ey::Core::Client
+  class Real
+    def get_logical_database(params={})
+      params["url"] || (id = require_parameters(params, "id"))
+
+      request(
+        :path => "/logical-databases/#{id}",
+        :url  => params["url"],
+      )
+    end
+  end
+
+  class Mock
+    def get_logical_database(params={})
+      logical_database = self.find(:logical_databases, resource_identity(params))
+
+      response(
+        :body   => {"logical_database" => logical_database},
+        :status => 200,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+class Ey::Core::Client
+  class Real
+    def get_logical_databases(params={})
+      query = Ey::Core.paging_parameters(params)
+      url = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/logical-databases",
+        :url    => url,
+      )
+    end
+  end
+
+  class Mock
+    def get_logical_databases(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+
+      extract_url_params!(params)
+
+      params["service"] = params.delete("database_service") if params["database_service"]
+      if environment_id = resource_identity(params.delete("environment") || params.delete("environment_id"))
+        params["service"] = url_for("/database-services/#{find(:environments, environment_id)["database_service"]}")
+      end
+
+      headers, logical_databases_page = search_and_page(params, :logical_databases, search_keys: %w[name username service ])
+
+      response(
+        :body    => {"logical_databases" => logical_databases_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+class Ey::Core::Client
+  class Real
+    def get_logs(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :query  => query,
+        :path   => "/logs",
+        :url    => url
+      )
+    end
+  end
+
+  class Mock
+    def get_logs(params={})
+      extract_url_params!(params)
+
+      if cluster = params.delete("cluster")
+        params["_cluster"] = cluster
+      end
+
+      if cluster_update = params.delete("cluster_update")
+        params["_cluster_update"] = cluster_update
+      end
+
+      headers, logs_page = search_and_page(params, :logs, search_keys: %w[component_action _cluster _cluster_update])
+
+      response(
+        :body    => {"logs" => logs_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end
+end

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

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

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def get_memberships(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :url    => params.delete("url"),
+        :path   => "/memberships",
+        :params => params,
+        :query  => query,
+      )
+    end
+  end # Real
+
+  class Mock
+    def get_memberships(params={})
+      extract_url_params!(params)
+
+      headers, memberships_page = page(params, :memberships)
+
+      response(
+        :body    => {"memberships" => memberships_page},
+        :status  => 200,
+        :headers => headers
+      )
+    end
+  end # Mock
+end