ey-pro-cli 0.0.3

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

@@ -0,0 +1,90 @@
+class Ey::Core::Client
+  class Real
+    def create_provider(params={})
+      if account_id = params["account"]
+        request(
+          :method => :post,
+          :path   => "/accounts/#{account_id}/providers",
+          :body   => params,
+        )
+      elsif url = params.delete("url")
+        request(
+          :method => :post,
+          :url    => url,
+          :body   => params,
+        )
+      else
+        raise "Need params for either Account ID (account) or URL"
+      end
+    end
+  end # Real
+
+  class Mock
+    def create_provider(params={})
+      resource_id    = self.serial_id
+      request_id     = self.uuid
+      account_id     = params["account"]
+      url            = params.delete("url")
+
+      account_id ||= url && path_params(url)["accounts"]
+
+      find(:accounts, account_id)
+
+      provider_params = params["provider"]
+
+      provider = {
+        "account"            => url_for("/accounts/#{account_id}"),
+        "id"                 => resource_id,
+        "resource_url"       => url_for("/providers/#{resource_id}"),
+        "provider_locations" => url_for("/providers/#{resource_id}/locations"),
+        "storages"           => url_for("/providers/#{resource_id}/storages"),
+        "servers"            => url_for("/providers/#{resource_id}/servers"),
+        "untracked_servers"  => url_for("/providers/#{resource_id}/untracked-servers"),
+        "provisioned_id"     => provider_params["provisioned_id"] || SecureRandom.uuid,
+        "created_at"         => Time.now,
+        "updated_at"         => Time.now,
+        "type"               => provider_params["type"].to_s,
+        "credentials"        => provider_params["credentials"],
+        "shared"             => provider_params.fetch(:shared, false),
+      }
+
+      unless ["aws", "azure"].include?(provider["type"])
+        response(status: 422, body: {"errors" => ["Unknown provider type: #{provider["type"]}"]})
+      end
+
+      self.data[:possible_provider_locations][provider["type"].to_s].each do |location|
+        provider_location_id = self.uuid
+        provider_location = {
+          "id"          => provider_location_id,
+          "location_id" => location["id"],
+          "provider"    => url_for("/providers/#{resource_id}"),
+          "name"        => location["name"],
+          "data"        => {},
+        }
+        self.data[:provider_locations][provider_location_id] = provider_location
+      end
+
+      request = provider.merge(
+        "resource"    => [:providers, resource_id, provider],
+        "type"        => "provider",
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "successful"  => "true",
+        "id"          => request_id,
+      )
+
+      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_slots.rb

@@ -0,0 +1,100 @@
+class Ey::Core::Client
+  class Real
+    def create_slots(params={})
+      url        = params.delete("url")
+      cluster_id = params.delete("cluster")
+
+      request(
+        :method => :post,
+        :path   => "/clusters/#{cluster_id}/slots",
+        :url    => url,
+        :body   => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_slots(params={})
+      extract_url_params!(params)
+
+      cluster     = find(:clusters, params["cluster"])
+      cluster_url = url_for("/clusters/#{cluster["id"]}")
+
+      slots = params["slots"]
+
+      if slots["names"] && slots["quantity"]
+        return response(
+          status: 422,
+          body: { errors: ["cannot accept both 'names' and 'quantity' params"] }
+        )
+      end
+
+      quantity = slots.delete("quantity") || 1
+      names = slots.delete("names") || quantity.times.map { self.uuid[0..6] }
+
+      unless names.kind_of?(Array)
+        return response(
+          status: 422,
+          body: { errors: ["slots[names] parameter must be an array"] }
+        )
+      end
+
+      resources = names.map do |name|
+        resource_id = self.uuid
+
+        resource = params["slots"].dup
+        resource["flavor"]  ||= "medium_64"
+        resource["volumes"] ||= []
+        resource["image"]   ||= nil
+
+        resource.merge!(
+          "id"            => resource_id,
+          "name"          => name,
+          "cluster"       => cluster_url,
+          "components"    => url_for("/slots/#{resource_id}/components"),
+          "configuration" => { "volumes" => [] },
+          "disabled"      => false,
+          "retired"       => false,
+          "deleted_at"    => nil,
+          "created_at"    => Time.now,
+          "updated_at"    => Time.now,
+        )
+
+        if volume_config = cluster["configuration"] && cluster["configuration"]["slot"] && cluster["configuration"]["slot"]["volumes"]
+          resource["configuration"]["volumes"] += volume_config
+          resource["configuration"]["volumes"].uniq!
+        end
+
+        # find all the cluster_components for this cluster
+        cluster_components = self.data[:cluster_components].select do |_,cluster_component|
+          cluster_component["cluster"] == cluster_url
+        end
+
+        # bootstrap a slot_component for each cluster_component
+        cluster_components.each do |_,cc|
+          slot_component_id = self.uuid
+          self.data[:slot_components][slot_component_id] = {
+            "id"                => slot_component_id,
+            "created_at"        => Time.now,
+            "updated_at"        => Time.now,
+            "deleted_at"        => nil,
+            "configuration"     => deep_dup(cc["configuration"]),
+            "name"              => cc["name"],
+            "slot"              => url_for("/slots/#{resource_id}"),
+            "cluster_component" => url_for("/cluster_components/#{cc['id']}"),
+            "component"         => cc["component"],
+            "_cluster"          => cluster_url,
+            "_environment"      => cluster["environment"],
+          }
+        end
+
+        self.data[:slots][resource_id] = resource
+      end
+
+      response(
+        :body    => {"slots" => resources},
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,83 @@
+class Ey::Core::Client
+  class Real
+    def create_ssl_certificate(params={})
+      account_id  = params["account"]
+      url         = params.delete("url")
+
+      request(
+        :method => :post,
+        :url    => url,
+        :path   => "/accounts/#{account_id}/ssl_certificates",
+        :body   => params
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_ssl_certificate(params={})
+      url = params.delete("url")
+      account_id = params["account"] || url && path_params(url)["accounts"]
+
+      find(:accounts, account_id)
+
+      resource_id = self.uuid
+
+      resource = params["ssl_certificate"].dup
+
+      if resource.delete("self_sign")
+        key  = OpenSSL::PKey::RSA.new(1024)
+        name = OpenSSL::X509::Name.parse("/CN=example.org")
+
+        # NB: the order in which these attributes are set seems to be
+        # important in making it self-signed and not just a certificate
+        # with a mystery issuer. It's not clear which attributes have
+        # the ordering requirement.
+        cert = OpenSSL::X509::Certificate.new
+        cert.version    = 2
+        cert.serial     = Time.now.tv_sec            # monotonically increasing
+        cert.not_before = Time.now - (7 * 24 * 60 * 60) # allow for plenty of clock skew
+        cert.not_after  = Time.now + (10 * 356 * 24 * 60 * 60) # allow for plenty of clock skew
+        cert.subject    = name
+        cert.public_key = key.public_key
+        cert.issuer     = name
+
+        cert.sign(key, OpenSSL::Digest::SHA1.new)
+
+        resource["public_certificate"] = cert.to_pem
+        resource["private_key"]        = key.to_pem
+        resource["self_signed"]        = true
+      elsif ! resource['public_certificate'] or ! resource['private_key']
+        return response(status: 422, body: {"errors" => ["public_certificate and private_key must not be blank."]})
+      end
+
+      resource.merge!(
+        "account"      => url_for("/accounts/#{account_id}"),
+        "created_at"   => Time.now,
+        "id"           => resource_id,
+        "updated_at"   => Time.now,
+        "resource_url" => url_for("/ssl_certificates/#{resource_id}"),
+      )
+
+      request = {
+        "account"      => url_for("/accounts/#{account_id}"),
+        "created_at"   => Time.now,
+        "finished_at"  => nil,
+        "id"           => self.uuid,
+        "message"      => nil,
+        "read_channel" => nil,
+        "resource"     => [:ssl_certificates, resource_id, resource],
+        "started_at"   => Time.now,
+        "successful"   => true,
+        "type"         => "provision_ssl_certificate",
+        "updated_at"   => Time.now,
+      }
+
+      self.data[:requests][request["id"]] = request
+
+      response(
+        :body    => {"request" => request},
+        :status  => 201
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,64 @@
+class Ey::Core::Client
+  class Real
+    def create_storage(params={})
+      provider_id = params.delete("provider")
+      url         = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/providers/#{provider_id}/storages",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_storage(params={})
+      extract_url_params!(params)
+
+      request_id  = self.uuid
+      resource_id = self.uuid
+
+      provider_id  = resource_identity(params["provider"])
+      provider_url = url_for("/providers/#{provider_id}")
+
+      provider = find(:providers, provider_id)
+
+      resource = params["storage"].dup
+
+      resource.merge!({
+        "id"                => resource_id,
+        "name"              => resource["name"],
+        "location"          => resource["location"],
+        "provisioned_id"    => self.uuid,
+        "provider"          => provider_url,
+        "storage_users_url" => url_for("/storages/#{resource_id}"),
+        "resource_url"      => "/storages/#{resource_id}"
+      })
+
+      request = {
+        "id"          => request_id,
+        "type"        => "provision_provider_storage",
+        "successful"  => true,
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:storages, resource_id, resource],
+      }
+
+      self.data[:requests][request_id]  = request
+      self.data[:storages][resource_id] = resource
+
+      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

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

@@ -0,0 +1,64 @@
+class Ey::Core::Client
+  class Real
+    def create_storage_user(params={})
+      storage_id = params.delete("storage")
+      url        = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/storages/#{storage_id}/users",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_storage_user(params={})
+      extract_url_params!(params)
+
+      request_id  = self.uuid
+      resource_id = self.uuid
+
+      storage_id  = resource_identity(params["storage"])
+      storage_url = url_for("/storages/#{storage_id}")
+
+      storage = find(:storages, storage_id)
+
+      resource = params["storage_user"].dup
+
+      resource.merge!({
+        "id"             => resource_id,
+        "username"       => resource["username"],
+        "provisioned_id" => self.uuid,
+        "access_id"      => SecureRandom.hex(16),
+        "secret_key"     => SecureRandom.hex(32),
+        "storage"        => storage_url,
+        "resource_url"   => "/storages/#{storage_id}/storage-users/#{resource_id}"
+      })
+
+      request = {
+        "id"          => request_id,
+        "type"        => "provision_provider_storage_credential",
+        "successful"  => true,
+        "started_at"  => Time.now,
+        "finished_at" => nil,
+        "resource"    => [:storage_users, resource_id, resource],
+      }
+
+      self.data[:requests][request_id]  = request
+      self.data[:storage_users][resource_id] = resource
+
+      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

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

@@ -0,0 +1,55 @@
+class Ey::Core::Client
+  class Real
+    def create_task(params={})
+      cluster_component_id  = params.delete("cluster_component")
+      url = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/cluster_components/#{cluster_component_id}/tasks",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_task(params={})
+      request_id = self.uuid
+      resource_id = self.uuid
+      url = params["url"]
+
+      cluster_component_id = url && path_params(url)["cluster_components"]
+      cluster_component_id ||= params.delete("cluster_component")
+
+      self.find(:cluster_components, cluster_component_id)
+
+      task = {
+        "finished_at"       => nil,
+        "id"                => request_id,
+        "started_at"        => Time.now,
+        "successful"        => true,
+        "read_channel"      => "https://messages.engineyard.com/stream?subscription=/tasks/#{request_id[0..7]}&token=#{SecureRandom.hex(6)}",
+        "cluster_component" => url_for("/cluster-components/#{cluster_component_id}"),
+      }
+
+      request = task.merge(
+        "resource"    => [:tasks, resource_id, task],
+        "type"        => "task",
+        "finished_at" => nil,
+        "successful"  => nil,
+      )
+
+      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,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client