ey-pro-cli 0.0.3

data/lib/vendor/core/ey-core/requests/get_untracked_servers.rb

@@ -0,0 +1,24 @@
+class Ey::Core::Client
+  class Real
+    def get_untracked_servers(params={})
+      request(
+        :params => params,
+        :query  => Ey::Core.paging_parameters(params),
+        :path   => "/untracked-servers",
+        :url    => params.delete("url"),
+      )
+    end
+  end # Real
+  class Mock
+    def get_untracked_servers(params={})
+      extract_url_params!(params)
+
+      headers, servers_page = search_and_page(params, :untracked_servers, search_keys: %w[provider provisioned_id provisioner_id location])
+
+      response(
+        :body    => {"untracked_servers" => servers_page},
+        :headers => headers
+      )
+    end
+  end # Mock
+end

data/lib/vendor/core/ey-core/requests/get_user.rb

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

data/lib/vendor/core/ey-core/requests/get_users.rb

@@ -0,0 +1,42 @@
+class Ey::Core::Client
+  class Real
+    def get_users(params={})
+      query = Ey::Core.paging_parameters(params)
+      url   = params.delete("url")
+
+      request(
+        :params => params,
+        :path   => "/users",
+        :query  => query,
+        :url    => url,
+      )
+    end
+  end # Real
+  class Mock
+    def get_users(params={})
+      resources = if url = params.delete("url")
+                    if account_id = path_params(url)["accounts"]
+                      account = self.find(:accounts, account_id)
+
+                      if url.index("/owners")
+                        account[:account_owners].inject({}){|r,id| r.merge(id => self.data[:users][id])}
+                      elsif url.index("/users")
+                        account[:account_users].inject({}){|r,id| r.merge(id => self.data[:users][id])}
+                      else
+                        raise "Mock doesn't know how to handle url: #{url}"
+                      end
+                    else []
+                    end
+                  else
+                    self.data[:users]
+                  end
+
+      headers, users_page = search_and_page(params, :users, search_keys: %w[name email first_name last_name], resources: resources)
+
+      response(
+        :body    => {"users" => users_page},
+        :headers => headers
+      )
+    end
+  end # Mock
+end

data/lib/vendor/core/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/vendor/core/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/vendor/core/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/vendor/core/ey-core/requests/request_callback.rb

@@ -0,0 +1,24 @@
+class Ey::Core::Client
+  class Real
+    def request_callback(id)
+      request(
+        :path   => "/requests/#{id}/callback",
+        :method => :post
+      )
+    end
+  end
+
+  class Mock
+    def request_callback(id)
+      request_id = self.uuid
+
+      request = find(:requests, id).dup
+      request.delete("resource")
+
+      response(
+        :body   => {"request" => request},
+        :status => 200,
+      )
+    end
+  end
+end

data/lib/vendor/core/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/vendor/core/ey-core/requests/run_cluster_component_action.rb

@@ -0,0 +1,181 @@
+class Ey::Core::Client
+  class Real
+    def run_cluster_component_action(params={})
+      cluster_component_id = params.delete("cluster_component")
+      action               = params.delete("action")
+      url                  = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/cluster-components/#{cluster_component_id}/actions/#{action}",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def run_cluster_component_action(params={})
+      cluster_component_id = params.delete("cluster_component")
+      action               = params.delete("action")
+
+      request_id = self.uuid
+
+      cluster_component = find(:cluster_components, cluster_component_id)
+
+      task = {
+        "action"                 => action,
+        "application_deployment" => nil,
+        "cluster_component"      => url_for("/cluster-components/#{cluster_component_id}"),
+        "configuration"          => normalize_hash(params["task"] || {}),
+        "created_at"             => Time.now,
+        "finished_at"            => nil,
+        "id"                     => request_id,
+        "resource_url"           => url_for("/tasks/#{request_id}"),
+        "started_at"             => Time.now,
+        "successful"             => true,
+        "updated_at"             => Time.now,
+        "component_actions"      => url_for("/tasks/#{request_id}/component-actions")
+      }
+
+      if action == "backup"
+        create_backup(
+          "backup" => {},
+          "url"    => cluster_component["cluster"],
+        )
+      end
+
+      # application component
+      default_deployer = self.data[:components].values.find {|c| c["name"] == "default_deployer" }
+      if cluster_component["component"] == url_for("/components/#{default_deployer["id"]}")
+        application_id            = cluster_component["configuration"]["application"]
+        application_deployment_id = self.uuid
+        archive_id                = task["configuration"]["archive_id"]
+
+        find(:applications, application_id)
+
+        if action == "deploy"
+          unless cluster_component["configuration"].has_key?("enabled")
+            cluster_component["configuration"]["enabled"] = true
+          end
+
+          application_deployment = {
+            "application"        => url_for("/applications/#{application_id}"),
+            "archive"            => archive_id && url_for("/applications/#{application_id}/archives/#{archive_id}"),
+            "commit"             => task["configuration"]["commit"] || "123456789abcdefghijklmnopqrstuvwxyz12345",
+            "created_at"         => Time.now,
+            "finished_at"        => nil,
+            "id"                 => application_deployment_id,
+            "migrate"            => !! task["configuration"]["migrate"] || true,
+            "migrate_command"    => task["configuration"]["migrate_command"] || "bundle exec rake db:migrate",
+            "ref"                => task["configuration"]["ref"] || "HEAD",
+            "serverside_version" => "2.2.0",
+            "started_at"         => Time.now,
+            "successful"         => task["successful"],
+            "task"               => url_for("/tasks/#{request_id}"),
+          }
+          task.merge!("application_deployment" => url_for("/application_deployments/#{application_deployment_id}"))
+
+          self.data[:application_deployments][application_deployment_id] = application_deployment
+        end
+
+        if action == "enable"
+          cluster_component["configuration"]["enabled"] = true
+        end
+
+        if action == "disable"
+          cluster_component["configuration"]["enabled"] = false
+        end
+
+        serverside_command = case action
+                             when "deploy"
+                               "echo 'I am a fake engineyard-serverside deploy command'"
+                             when "enable"
+                               "echo 'I am a fake engineyard-serverside disable_maintenance command'"
+                             when "disable"
+                               "echo 'I am a fake engineyard-serverside enable_maintenance command'"
+                             when "restart"
+                               "echo 'I am a fake engineyard-serverside restart command'"
+                             else
+                               raise "Application components do not respond to action '#{action}'"
+                             end
+
+        create_component_action(task, serverside_command)
+        create_component_action(task, "echo 'I am a fake engineyard-serverside maintenance_status command'")
+      end
+
+      task.merge!("read_channel" => "https://messages.engineyard.com/stream?subscription=/tasks/#{request_id[0..7]}&token=#{SecureRandom.hex(6)}")
+
+      request = task.merge(
+        "type"        => "task",
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "successful"  => true,
+        "id"          => request_id,
+        "resource"    => [:tasks, request_id, lambda do |r|
+          application_deployment["finished_at"] = Time.now if application_deployment
+
+          r.delete("resource_url")
+        end],
+      )
+
+
+      self.data[:requests][request_id] = request
+      self.data[:tasks][request_id]    = task
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 201,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+
+    protected
+
+    def create_component_action(task, serverside_command)
+      # emit a component action for the serverside call
+      cluster_component = find(:cluster_components, task["cluster_component"])
+      cluster     = find(:clusters, cluster_component["cluster"])
+      environment = find(:environments, cluster["environment"])
+
+      component_action_id = self.uuid
+      component_action = {
+        "id"                     => component_action_id,
+        "created_at"             => Time.now,
+        "finished_at"            => Time.now,
+        "started_at"             => Time.now,
+        "updated_at"             => Time.now,
+        "successful"             => true,
+      }
+
+      self.data[:requests][component_action_id] = component_action.merge("resource_url" => url_for("/component-actions/#{component_action_id}"))
+
+      component_action.merge!({
+        "account"   => environment["account"],
+        "logs"      => url_for("/component-actions/#{component_action_id}/logs"),
+        "command"   => serverside_command,
+        "exit_code" => 0,
+        "task"      => task["resource_url"],
+      })
+
+      self.data[:component_actions][component_action_id] = component_action
+
+      log_id = self.uuid
+      log = {
+        "id"               => log_id,
+        "filename"         => "command.txt",
+        "upload_url"       => "https://a-fake-log-url/",
+        "download_url"     => "https://a-fake-log-url/",
+        "mime_type"        => "text/plain",
+        "component_action" => url_for("/component-actions/#{component_action_id}"),
+      }
+
+      self.data[:logs][log_id] = log
+    end
+  end # Mock
+end # Ey::Core::Client

data/lib/vendor/core/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