ey-pro-cli 0.0.3

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

@@ -0,0 +1,35 @@
+class Ey::Core::Client
+  class Real
+    def create_addon(params={})
+      url = params.delete("url") or raise "URL needed"
+      request(
+        :method => :post,
+        :url    => url,
+        :params => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_addon(params={})
+      url        = params.delete("url") or raise "URL needed"
+      account_id = path_params(url)["accounts"] or raise "Need account id, not parsed from #{url}"
+
+      resource_id = self.serial_id
+
+      resource = params["addon"].merge(
+        "id"                 => resource_id,
+        "addon_attachments"  => url_for("/accounts/#{account_id}/addons/#{resource_id}/attachments"),
+        "account"            => url_for("/accounts/#{account_id}"),
+        "vars"               => normalize_hash(params["addon"]["vars"] || {}),
+      )
+
+      self.data[:addons][resource_id] = resource
+
+      response(
+        :body    => {"addon" => resource},
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,53 @@
+class Ey::Core::Client
+  class Real
+    def create_address(params={})
+      request(
+        :method => :post,
+        :path   => "/addresses",
+        :params => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_address(params={})
+      request_id  = self.uuid
+      resource_id = self.serial_id
+      provider_id = params["provider"]
+
+      self.find(:providers, provider_id)
+
+      resource = params["address"].dup
+      ip_address = self.ip_address
+      resource.merge!(
+        "id"             => resource_id,
+        "provisioned_id" => ip_address,
+        "ip_address"     => ip_address,
+        "resource_url"   => "/addresses/#{resource_id}",
+        "provider"       => url_for("/providers/#{provider_id}")
+      )
+
+      request = {
+        "id"          => request_id,
+        "type"        => "provision_address",
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:addresses, resource_id, resource],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 201,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,60 @@
+class Ey::Core::Client
+  class Real
+    def create_alert(params={})
+      url = params.delete("url")
+
+      request(
+        :method => :post,
+        :path   => "/alerts",
+        :body   => params,
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_alert(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+      extract_url_params!(params)
+
+      database_server_id = resource_identity(params["database_server"] || params["database_server_id"])
+      server_id          = resource_identity(params["server"]          || params["server_id"])
+
+      alert_params = require_parameters(params, "alert")
+      name, external_id, message, severity = require_parameters(alert_params, *%w[name external_id message severity])
+      resource_id = self.uuid
+
+      alert = {
+        "id"           => resource_id,
+        "created_at"   => Time.now,
+        "updated_at"   => Time.now,
+        "deleted_at"   => nil,
+        "severity"     => severity,
+        "acknowledged" => alert_params.fetch("acknowledged", false),
+        "ignored"      => alert_params.fetch("ignored", false),
+        "message"      => message,
+        "description"  => alert_params["description"],
+        "external_id"  => external_id,
+        "name"         => name,
+        "finished_at"  => alert_params["finished_at"],
+        "started_at"   => alert_params["started_at"],
+      }
+
+      alert.merge!("resource" =>
+                   if database_server_id
+                     url_for("/database-servers/#{database_server_id}")
+                   elsif server_id
+                     url_for("/servers/#{server_id}")
+                   else
+                     raise response(status: 422, body: "Requires either server or database_server")
+                   end
+                  )
+
+      self.data[:alerts][resource_id] = alert
+      response(
+        :body   => {"alert" => alert},
+        :status => 201,
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,55 @@
+class Ey::Core::Client
+  class Real
+    def create_application(params={})
+      url = params.delete("url")
+
+      request(
+        :method => :post,
+        :path   => "/applications",
+        :params => params,
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_application(params={})
+      resource_id  = self.serial_id
+      url          = params.delete("url")
+
+      account_id = params["account"] || url && path_params(url)["accounts"]
+
+      find(:accounts, account_id)
+
+      resource = params["application"].dup
+
+      resource.merge!(
+        "account"    => url_for("/accounts/#{account_id}"),
+        "archives"   => url_for("/applications/#{resource_id}/archives"),
+        "keypairs"   => url_for("/applications/#{resource_id}/keypairs"),
+        "created_at" => Time.now,
+        "updated_at" => Time.now,
+        "id"         => resource_id,
+      )
+
+      key = mock_ssh_key
+
+      keypair = {
+        "id"          => self.serial_id,
+        "application" => url_for("/applications/#{resource_id}"),
+        "user"        => nil,
+        "fingerprint" => key[:fingerprint],
+        "public_key"  => key[:public_key],
+        "private_key" => key[:private_key],
+      }
+
+      self.data[:keypairs][keypair['id']] = keypair
+      self.data[:applications][resource_id] = resource
+
+      response(
+        :body   => {"application" => resource},
+        :status => 201,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+class Ey::Core::Client
+  class Real
+    def create_application_archive(params={})
+      application_id = params["application"]
+      url            = params.delete("url")
+
+      request(
+        :method => :post,
+        :path   => "/applications/#{application_id}/archives",
+        :params => params,
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_application_archive(params={})
+      resource_id    = self.uuid
+      url            = params.delete("url")
+      application_id = Integer(params["application"] || (url && path_params(url)["applications"]))
+
+      find(:applications, application_id)
+
+      resource = params["application_archive"].dup
+
+      resource.merge!(
+        "id"                => resource_id,
+        "application"       => url_for("/applications/#{application_id}"),
+        "created_at"        => Time.now,
+        "updated_at"        => Time.now,
+        "upload_successful" => false,
+        "upload_url"        => "http://example.org/#{resource_id}",
+        "url"               => "http://example.org/#{resource_id}",
+      )
+
+      self.data[:application_archives][resource_id] = resource
+
+      response(
+        :body   => {"application_archive" => resource},
+        :status => 201,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+class Ey::Core::Client
+  class Real
+    def create_backup(params={})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :post,
+        :path   => "backups/#{id}",
+        :url    => url,
+        :body   => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_backup(params={})
+      resource_id = self.uuid
+
+      cluster_id = if params["url"] # provided scope
+                     path_params(params["url"])["clusters"]
+                   elsif current_server
+                     path_params(current_server["cluster"])["clusters"]
+                   end
+      find(:clusters, cluster_id)
+
+
+      resource = params["backup"].dup
+
+      resource.merge!(
+        "id"         => resource_id,
+        "files"      => url_for("/backups/#{resource_id}/files"),
+        "cluster"    => url_for("/clusters/#{cluster_id}"),
+        "created_at" => Time.now,
+        "updated_at" => Time.now,
+      )
+
+      self.data[:backups][resource_id] = resource
+
+      response(
+        :body   => {"backup" => resource},
+        :status => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,52 @@
+class Ey::Core::Client
+  class Real
+    def create_backup_file(params={})
+      id  = params["id"]
+      url = params["url"]
+
+      request(
+        :method => :post,
+        :path   => "backup_files/#{id}",
+        :url    => url,
+        :body   => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_backup_file(params={})
+      resource_id = self.uuid
+
+      unless resource = params["backup_file"].dup
+        response(status: 422)
+      end
+
+      unless filename = resource["filename"]
+        response(status: 422, body: {"error" => ["Missing required attribute: filename"]})
+      end
+
+      backup_id = params["url"].split("/")[-2]
+
+      uuid = self.uuid
+
+      resource.merge!(
+        "id"           => resource_id,
+        "files"        => url_for("/backup_files/#{resource_id}/files"),
+        "mime_type"    => resource["mime_type"] || MIME::Types.type_for(filename).first.to_s,
+        # these need to be the same for mocking purposes
+        "download_url" => "http://example.org/#{uuid}",
+        "upload_url"   => "http://example.org/#{uuid}",
+        "backup"       => url_for("/backups/#{backup_id}"),
+        "created_at"   => Time.now,
+        "updated_at"   => Time.now,
+      )
+
+      self.data[:backup_files][resource_id] = resource
+
+      response(
+        :body   => {"backup_file" => resource},
+        :status => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,98 @@
+class Ey::Core::Client
+  class Real
+    def create_cluster(params={})
+      environment_id = params["environment"]
+      url            = params.delete("url")
+
+      request(
+        :method => :post,
+        :path   => "/environments/#{environment_id}/clusters",
+        :body   => params,
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_cluster(params={})
+      extract_url_params!(params)
+
+      environment = find(:environments, params["environment"])
+
+      resource_id = self.uuid
+      resource    = params["cluster"].dup
+      provider_id = resource["provider"]
+      location    = resource.delete("location")
+
+      provider = find(:providers, provider_id)
+
+      provider_location = self.data[:provider_locations].values.find do |pl|
+        pl["provider"] == url_for("/providers/#{provider_id}") && pl["location_id"] == location
+      end
+
+      unless provider_location
+        return response(
+          :status => 422,
+          :body   => {"errors" => ["Don't have access to #{location}"]},
+        )
+      end
+
+      resource.merge!(
+        "backups"     => url_for("/clusters/#{resource_id}/backups"),
+        "components"  => url_for("/clusters/#{resource_id}/components"),
+        "created_at"  => Time.now,
+        "environment" => url_for("/environments/#{environment["id"]}"),
+        "firewalls"   => url_for("/clusters/#{resource_id}/firewalls"),
+        "id"          => resource_id,
+        "location"    => {"id" => provider_location["location_id"], "name" => provider_location["name"]},
+        "provider"    => url_for("/providers/#{provider_id}"),
+        "servers"     => url_for("/clusters/#{resource_id}/servers"),
+        "slots"       => url_for("/clusters/#{resource_id}/slots"),
+        "updated_at"  => Time.now,
+        "updates"     => url_for("/clusters/#{resource_id}/updates"),
+      )
+
+      resource["configuration"] = normalize_hash(resource["configuration"] || {})
+      resource["configuration"]["version"] ||= 0
+      resource["configuration"]["ha_strategy"] ||= "noop"
+
+      case provider["type"]
+      when "azure"
+        resource["configuration"]["hosted_services"] ||= []
+
+        unless resource["configuration"]["hosted_services"].first
+          resource["configuration"]["hosted_services"] << {
+            "name"  => "#{resource_id[0..6]}-hosted-service",
+            "endpoints" => []
+          }
+        end
+      else
+        resource["configuration"]["firewalls"] ||= []
+
+        if default_firewall = resource["configuration"]["firewalls"].first
+          ssh_rule = { "source" => "0.0.0.0/0", "port_range" => 22 }
+          unless (default_firewall["rules"] || []).include? ssh_rule
+            default_firewall["rules"] << ssh_rule
+          end
+        else
+          resource["configuration"]["firewalls"] << {
+            "name"  => "#{resource_id[0..6]}-firewall",
+            "rules" => [
+              {
+                "source"     => "0.0.0.0/0",
+                "port_range" => "22",
+              }
+            ]
+          }
+        end
+      end
+
+      self.data[:clusters][resource_id] = resource
+
+      response(
+        :body   => {"cluster" => resource},
+        :status => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client