ey-pro-cli 0.0.3

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

@@ -0,0 +1,34 @@
+class Ey::Core::Client
+  class Real
+    def destroy_provider(id)
+      request(
+        :method => :delete,
+        :path   => "/providers/#{id}",
+      )
+    end
+  end
+
+  class Mock
+    def destroy_provider(id)
+      provider   = self.data[:providers][id].dup
+      request_id = self.uuid
+
+      provider["cancelled_at"] = Time.now
+      provider["resource_url"] = url_for("/providers/#{id}")
+
+      self.data[:requests][request_id] = {
+        "id"          => request_id,
+        "finished_at" => nil,
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "resource"    => [:providers, id, provider],
+        "type"        => "cancel_provider",
+      }
+
+      response(
+        :body   => {"request" => {id: request_id}},
+        :status => 201,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+class Ey::Core::Client
+  class Real
+    def destroy_server(id)
+      request(
+        :method => :delete,
+        :path => "/servers/#{id}"
+      )
+    end
+  end
+
+  class Mock
+    def destroy_server(id)
+      deprovision_procedure = lambda do |_|
+        server = self.data[:servers][id]
+
+        server.merge!("deleted_at" => Time.now, "deprovisioned_at" => Time.now)
+
+        if slot_id = resource_identity(server["slot"])
+          self.data[:slots][slot_id]["server"] = nil
+        end
+
+        self.data[:volumes].values.select {|v| v["server"] == url_for("/servers/#{id}") }.each do |volume|
+          volume.merge!("deleted_at" => Time.now)
+        end
+
+        nil
+      end
+
+      request_id = self.uuid
+
+      self.data[:requests][request_id] = {
+        "id"          => request_id,
+        "finished_at" => nil,
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "resource"    => [:servers, id, deprovision_procedure],
+        "type"        => "deprovision_server",
+      }
+
+      response(
+        :body   => {"request" => {id: request_id}},
+        :status => 201,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+class Ey::Core::Client
+  class Real
+    def destroy_ssl_certificate(params={})
+      id  = params["id"]
+      url = params.delete("url")
+
+      request(
+        :method => :delete,
+        :path => "ssl_certificates/#{id}",
+        :url  => url,
+      )
+    end
+  end
+
+  class Mock
+    def destroy_ssl_certificate(params={})
+      url = params.delete("url")
+
+      ssl_certificate_id = params["id"] || url_params(url)["ssl_certificates"]
+      self.data[:ssl_certificates][ssl_certificate_id]["deleted_at"] = Time.now
+
+      response(
+        :body   => nil,
+        :status => 204,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+class Ey::Core::Client
+  class Real
+    def destroy_storage(id)
+      request(
+        :method => :delete,
+        :path   => "/storages/#{id}",
+      )
+    end
+  end # Real
+
+  class Mock
+    def destroy_storage(id)
+      request_id  = self.uuid
+
+      self.data[:requests][request_id] = {
+        "id"          => request_id,
+        "type"        => "deprovision_provider_storage",
+        "successful"  => true,
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:storages, id, self.data[:storages][id].merge("deleted_at" => Time.now)],
+      }
+
+      response(
+        :body    => {"request" => {id: request_id}},
+        :status  => 201,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8",
+        }
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,38 @@
+class Ey::Core::Client
+  class Real
+    def destroy_storage_user(params={})
+      id         = params.delete("id")
+
+      request(
+        :method => :delete,
+        :path   => "/storage-users/#{id}",
+      )
+    end
+  end # Real
+
+  class Mock
+    def destroy_storage_user(params={})
+      storage_id = params.delete("storage")
+      id         = params.delete("id")
+
+      request_id  = self.uuid
+
+      self.data[:requests][request_id] = {
+        "id"          => request_id,
+        "type"        => "deprovision_provider_storage_user",
+        "successful"  => true,
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:storage_users, id, self.data[:storage_users][id].merge("deleted_at" => Time.now)],
+      }
+
+      response(
+        :body    => {"request" => {id: request_id}},
+        :status  => 201,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8",
+        }
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,29 @@
+class Ey::Core::Client
+  class Real
+    def destroy_user(params={})
+      id  = params["id"]
+      url = params.delete("url")
+
+      request(
+        :path   => "/users/#{id}",
+        :url    => url,
+        :method => :delete
+      )
+    end
+  end
+
+  class Mock
+    def destroy_user(params={})
+      url = params.delete("url")
+
+      user_id = params["id"] || url && url.split('/').last
+
+      self.data[:users][user_id]["deleted_at"] = Time.now
+
+      response(
+        :body   => nil,
+        :status => 204,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+class Ey::Core::Client
+  class Real
+    def detach_address(params={})
+      id = params["id"]
+
+      request(
+        :method => :put,
+        :path   => "addresses/#{id}/detach",
+      )
+    end
+  end # Real
+
+  class Mock
+    def detach_address(params={})
+      resource_id = params.delete("id")
+      request_id  = self.uuid
+
+      resource = self.data[:addresses][resource_id]
+      server_id = resource["server_url"].split("/").last.to_i
+      server = self.data[:servers][server_id]
+
+      server["address_url"] = nil
+      resource["server_url"] = nil
+
+      request = {
+        "id"          => request_id,
+        "type"        => "detach_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  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,30 @@
+class Ey::Core::Client
+  class Real
+    def disable_feature(params={})
+      feature_id = params["feature"]["id"]
+      account_id = params["account"]
+
+      request(
+        :method => :delete,
+        :path   => "accounts/#{account_id}/features/#{feature_id}",
+      )
+    end
+  end # Real
+
+  class Mock
+    def disable_feature(params={})
+      account_id = params["account"]
+      feature_id = params["feature"]["id"]
+
+      account = find(:accounts, account_id)
+      feature = find(:features, feature_id)
+
+      feature["account"] = nil
+
+      response(
+        :body   => nil,
+        :status => 200
+      )
+    end
+  end # Mock
+end

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

@@ -0,0 +1,66 @@
+class Ey::Core::Client
+  class Real
+    def discover_database_server(params={})
+      id = params.delete("id")
+
+      request(
+        :method => :post,
+        :path   => "/database-servers/#{id}/discover",
+      )
+    end
+  end
+
+  class Mock
+    def discover_database_server(params={})
+      request_id  = self.uuid
+      resource_id = self.uuid
+      id          = params["id"]
+
+      database_server = self.data[:database_servers][id]
+      old_flavor      = database_server["flavor"]
+      new_flavor      = %w(db.m3.medium db.m3.large db.m3.xlarge db.m3.2xlarge) - [old_flavor]
+      revisions       = self.data[:database_server_revisions][id]
+
+      unless revisions
+        database_server["flavor"]        = new_flavor
+        self.data[:database_servers][id] = database_server
+
+        revision = {
+          "id"              => resource_id,
+          "database_server" => url_for("/database-servers/#{id}"),
+          "revision_time"   => Time.now,
+          "data"            => {
+            "flavor" => {
+              "old" => old_flavor,
+              "new" => new_flavor,
+            },
+          },
+        }
+
+        self.data[:database_server_revisions][id] = revision
+      end
+
+      request = {
+        "id"          => request_id,
+        "type"        => "discover_database_server",
+        "successful"  => true,
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:database_servers, id, database_server],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body => {"request" => response_hash},
+        :status => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+class Ey::Core::Client
+  class Real
+    def discover_database_server_snapshots(params={})
+      url      = params.delete("url")
+      provider = params.delete("provider")
+
+      request(
+        :method => :post,
+        :url    => url,
+        :params => params,
+        :path   => "/providers/#{provider}/database-server-snapshots/discover",
+      )
+    end
+  end
+
+  class Mock
+    def discover_database_server_snapshots(params={})
+      extract_url_params!(params)
+
+      provider     = params.delete('provider')
+      resource_id  = self.uuid
+      request_id   = self.uuid
+      provider_url = url_for("/providers/#{provider}")
+
+      existing_snapshots = self.data[:database_server_snapshots].values.select { |dss| dss["provider"] == provider_url }
+      database_server    = self.data[:database_servers].values.detect { |ds| ds["provider"] == provider_url }
+
+      resources = if existing_snapshots.empty?
+                    if database_server
+                      [{
+                        "id"              => resource_id,
+                        "location"        => database_server["location"],
+                        "engine"          => database_server["engine"],
+                        "engine_version"  => database_server["version"],
+                        "storage"         => database_server["storage"],
+                        "provisioned_id"  => resource_id,
+                        "provisioned_at"  => Time.now - 3600,
+                        "provider"        => provider_url,
+                        "database_server" => url_for("/database-servers/#{database_server["id"]}")
+                      }]
+                    else []
+                    end
+                  else existing_snapshots
+                  end
+
+      request = {
+        "id" => request_id,
+        "type" => "discover_database_server_snapshots",
+        "successful" => true,
+        "started_at" => Time.now,
+        "finished_at" => nil,
+        "resource" => [:database_server_snapshots, resource_id, resources, "providers/#{provider}/database-server-snapshots"]
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+class Ey::Core::Client
+  class Real
+    def discover_provider_location(url, location_id)
+      id          = url.split("/")[-2]
+      location_id = URI.escape(location_id)
+
+      request(
+        :method => :put,
+        :path   => "/providers/#{id}/locations/#{location_id}/discover",
+      )
+    end
+  end
+
+  class Mock
+    def discover_provider_location(url, location_id)
+      resource_id = self.uuid
+      request_id  = self.uuid
+      provider_id = url.split("/")[-2]
+      provider    = self.data[:providers][provider_id.to_i]
+      type        = provider["type"]
+
+      possible_location = self.data[:possible_provider_locations][type].detect { |l| l["id"] == location_id }
+
+      resource = {
+        "id"            => resource_id,
+        "provider"      => url_for("/providers/#{provider_id}"),
+        "location_id"   => location_id,
+        "location_name" => possible_location["name"],
+        "resource_url"  => "/provider_locations/#{resource_id}"
+      }
+
+      self.data[:provider_locations][resource_id] = resource
+
+      request = {
+        "id"          => request_id,
+        "type"        => "discover_provider_location",
+        "successful"  => "true",
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:provider_locations, resource_id, resource],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 200,
+        :headers => {
+          "Content-Type" => "application/json; charset=utf8"
+        }
+      )
+    end
+  end
+end