ey-pro-cli 0.0.3

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

@@ -0,0 +1,57 @@
+class Ey::Core::Client
+  class Real
+    def create_cluster_component(params={})
+      cluster_id   = params["cluster"]
+      component_id = params["component"]
+      url          = params.delete("url")
+
+      request(
+        :method => :post,
+        :path   => "/clusters/#{cluster_id}/components/#{component_id}",
+        :url    => url,
+        :body   => params,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_cluster_component(params={})
+      url_params = params["url"] && path_params(params.delete("url"))
+
+      cluster_id = url_params && url_params["clusters"]
+      cluster_id ||= params.delete("cluster")
+      find(:clusters, cluster_id)
+
+      component_id = url_params && url_params["components"]
+      component_id ||= params.delete("component")
+      find(:components, component_id)
+
+      resource_id = self.uuid
+
+      resource = params["cluster_component"]
+
+      configuration = resource["configuration"] = normalize_hash(resource["configuration"] || {})
+
+      if application_id = configuration["application"]
+        find(:applications, application_id)
+        resource.merge!("application" => url_for("/applications/#{application_id}"))
+      end
+
+      resource.merge!(
+        "id"         => resource_id,
+        "component"  => url_for("/components/#{component_id}"),
+        "cluster"    => url_for("/clusters/#{cluster_id}"),
+        "connectors" => url_for("/cluster-components/#{resource_id}/connectors"),
+        "tasks"      => url_for("/cluster-components/#{resource_id}/tasks"),
+        "keypairs"   => url_for("/cluster-components/#{resource_id}/keypairs"),
+      )
+
+      self.data[:cluster_components][resource_id] = resource
+
+      response(
+        :body    => {"cluster_component" => resource},
+        :status  => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,208 @@
+class Ey::Core::Client
+  class Real
+    def create_cluster_update(params={})
+      cluster_id = params.delete("cluster")
+      url        = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/clusters/#{cluster_id}/updates",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_cluster_update(params={})
+      extract_url_params!(params)
+
+      request_id = self.uuid
+
+      cluster_id  = resource_identity(params["cluster"])
+      cluster_url = url_for("/clusters/#{cluster_id}")
+
+      cluster           = find(:clusters, cluster_id)
+      provider_url      = cluster["provider"]
+      provider          = find(:providers, provider_url)
+      location          = cluster["location"]["id"]
+
+      block_device_map  =       [
+        {
+          "mount"                 => "/",
+          "file_system"           => "ext4",
+          "device"                => "/dev/sda",
+          "size"                  => 100,
+          "delete_on_termination" => true,
+          "volume_type"           => "gp2",
+        },
+        {
+          "mount"                 => "/mnt",
+          "file_system"           => "ext4",
+          "device"                => "/dev/sdo",
+          "delete_on_termination" => true,
+          "size"                  => 100,
+          "volume_type"           => "gp2",
+        },
+        {
+          "mount"                 => nil,
+          "file_system"           => "swap",
+          "device"                => "/dev/sdp",
+          "delete_on_termination" => true,
+          "size"                  => 8,
+          "volume_type"           => "gp2",
+        },
+        { "device" => "/dev/sdb", "name"   => "ephemeral0", },
+      ]
+
+      procedure = lambda do |_|
+        # TODO: dependencies?
+
+        unless provider["type"] == "azure"
+          firewalls = cluster["configuration"]["firewalls"] rescue []
+
+          # create new firewalls
+          existing_firewalls = self.data[:cluster_firewalls].inject([]) { |r, (c_id, f_id)| c_id == cluster_id ? r << self.data[:firewalls][f_id] : r }
+          new_firewalls      = firewalls.reject { |f| existing_firewalls.find {|ef| ef["name"] == f["name"] } }
+
+          new_firewalls.each do |firewall|
+            request = create_firewall({
+              "provider" => provider_url,
+              "cluster" => cluster,
+              "firewall" => {
+                "name" => firewall["name"],
+              },
+            })
+            get_request("id" => request.body["request"]["id"])
+          end
+
+          # create new firewall rules
+          firewalls.each do |firewall|
+            firewall_id = search(self.data[:firewalls], "name" => firewall["name"]).keys.first
+
+            existing_rules = search(self.data[:firewalls], "firewall" => url_for("/firewalls/#{firewall_id}")).values
+            new_rules      = firewall["rules"].reject {|r| existing_rules.detect {|er| er.port_range == r["port_range"] && er.source == r["source"] } }
+
+            new_rules.each do |rule|
+              request = create_firewall_rule({
+                "firewall" => firewall_id,
+                "firewall_rule" => rule,
+              })
+              get_request("id" => request.body["request"]["id"])
+            end
+          end
+        end
+
+        # deprovision servers for retired slots
+        slots = self.data[:slots].values.select{|s|
+          next unless s["cluster"] == cluster_url
+          if s["retired_at"]
+            s["deleted_at"] = Time.now.to_s
+
+            if server_id = resource_identity(s["server"])
+              self.data[:servers][server_id]["deleted_at"] = Time.now.to_s
+            end
+          end
+          s["deleted_at"].nil?
+        }
+
+        # provision new servers for empty slots
+        slots.select{|s| s["server"].nil?}.each do |slot|
+          server_id = self.serial_id
+          provisioned_id = self.uuid[0..6]
+
+          # create server
+          self.data[:servers][server_id] = {
+            "alerts"           => url_for("/servers/#{server_id}/alerts"),
+            "cluster"          => url_for("/clusters/#{cluster["id"]}"),
+            "created_at"       => Time.now.to_s,
+            "deprovisioned_at" => Time.now.to_s,
+            "devices"          => block_device_map,
+            "enabled"          => true,
+            "environment"      => cluster["environment"],
+            "events"           => url_for("/servers/#{server_id}/events"),
+            "firewalls"        => url_for("/servers/#{server_id}/firewalls"),
+            "flavor"           => { "id" => slot["flavor"] },
+            "id"               => server_id,
+            "location"         => location,
+            "logs"             => url_for("/servers/#{server_id}/logs"),
+            "name"             => slot["name"],
+            "private_hostname" => "#{provisioned_id}.private.example.org",
+            "provider"         => provider_url,
+            "provisioned_at"   => Time.now.to_s,
+            "provisioned_id"   => provisioned_id,
+            "public_hostname"  => "#{provisioned_id}.public.example.org",
+            "public_key"       => mock_ssh_key[:fingerprint],
+            "slot"             => url_for("/slots/#{slot["id"]}"),
+            "ssh_port"         => 22,
+            "state"            => "running",
+            "token"            => SecureRandom.hex(16),
+            "updated_at"       => Time.now.to_s,
+            "volumes"          => url_for("/servers/#{server_id}/volumes"),
+          }
+
+          slot["server"] = url_for("/slots/#{slot["id"]}/server")
+
+          # create volumes
+          if volumes = slot["configuration"] && slot["configuration"]["volumes"]
+            volumes.each do |volume|
+              volume_id = self.serial_id
+              self.data[:volumes][volume_id] = volume.merge({
+                "id"             => volume_id,
+                "location"       => location,
+                "provider"       => provider_url,
+                "provisioned_id" => "vol-#{SecureRandom.hex(4)}",
+                "server"         => url_for("/servers/#{server_id}"),
+              })
+            end
+          end
+        end
+
+        # chef log for every server
+        slots.each do |slot|
+          log = create_log("log" => {
+            "filename"            => "command.txt",
+            "server"              => slot["server"],
+          }).body["log"]
+
+          # hax to support searching cluster & cluster update logs
+          self.data[:logs][log["id"]].merge!({
+            "_cluster"        => slot["cluster"],
+            "_cluster_update" => url_for("/cluster-updates/#{request_id}"),
+          })
+        end
+
+        url_for("/cluster-updates/#{request_id}")
+      end
+
+      cluster_update = {
+        "finished_at" => nil,
+        "id"          => request_id,
+        "started_at"  => Time.now.to_s,
+        "successful"  => "true",
+        "cluster"     => cluster_url,
+        "logs"        => url_for("/cluster-updates/#{request_id}/logs"),
+        "stage"       => "activate",
+      }
+
+      request = cluster_update.merge(
+        "resource" => [:cluster_updates, request_id, procedure],
+        "type"     => "cluster_update",
+      )
+
+      self.data[:requests][request_id] = request
+      self.data[:cluster_updates][request_id] = cluster_update
+
+      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_connector.rb

@@ -0,0 +1,46 @@
+class Ey::Core::Client
+  class Real
+    def create_connector(params={})
+      url = params.delete("url")
+
+      request(
+        :method => :post,
+        :path   => "/connectors",
+        :body   => params,
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_connector(params={})
+      resource_id = self.uuid
+
+      resource       = params["connector"].dup
+      destination_id = resource.delete("destination")
+      source_id      = resource.delete("source")
+
+      resource["configuration"] = normalize_hash(resource["configuration"] || {})
+
+      key, source = find([:cluster_components, :logical_databases], source_id)
+      dest = find(:cluster_components, destination_id)
+
+      environment_url = find(:clusters, dest["cluster"])["environment"] if dest.has_key?("cluster")
+      environment_url = find(:clusters, source["cluster"])["environment"] unless environment_url
+
+      resource.merge!(
+        "source"       => url_for("/#{key}/#{source_id}"),
+        "destination"  => url_for("/cluster-components/#{destination_id}"),
+        "id"           => resource_id,
+        "_environment" => environment_url,
+      )
+
+      self.data[:connectors][resource_id] = resource
+
+      response(
+        :body   => {"connector" => resource},
+        :status => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client

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

@@ -0,0 +1,72 @@
+class Ey::Core::Client
+  class Real
+    def create_database_server(params={})
+      request(
+        :method => :post,
+        :path   => "/database-servers",
+        :url    => params.delete("url"),
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def create_database_server(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+
+      require_parameters(params, "provider")
+      require_parameters(params["database_server"], "replication_source")
+
+      request_id  = self.uuid
+      resource_id = self.uuid
+
+      provider_id = resource_identity(params["provider"])
+      find(:providers, provider_id)
+
+      replication_source_id = resource_identity(params["database_server"]["replication_source"])
+      replication_source    = find(:database_servers, replication_source_id)
+
+      resource = {
+        "id"                 => resource_id,
+        "resource_url"       => url_for("/database-servers/#{resource_id}"),
+        "provisioned_id"     => "replica-#{SecureRandom.hex(3)}",
+        "engine"             => replication_source["engine"],
+        "version"            => replication_source["version"],
+        "storage"            => replication_source["storage"],
+        "modifiers"          => replication_source["modifiers"],
+        "endpoint"           => replication_source["endpoint"],
+        "flavor"             => replication_source["flavor"],
+        "location"           => replication_source["location"],
+        "deleted_at"         => nil,
+        "database_service"   => replication_source["database_service"],
+        "replication_source" => url_for("/database-servers/#{replication_source_id}"),
+        "alerts"             => url_for("/database-servers/#{resource_id}/alerts"),
+        "firewalls"          => url_for("/database-servers/#{resource_id}/firewalls"),
+        "provider"           => url_for("/providers/#{provider_id}"),
+        "messages"           => url_for("/database-servers/#{resource_id}/messages"),
+        "snapshots"          => url_for("/database-servers/#{resource_id}/snapshots"),
+        "revisions"          => url_for("/database-servers/#{resource_id}/revisions"),
+      }
+
+      request = {
+        "id"           => request_id,
+        "type"         => "provision_database_server",
+        "successful"   => "true",
+        "started_at"   => Time.now,
+        "finished_at"  => nil,
+        "resource_url" => url_for("/database-servers/#{resource_id}"),
+        "resource"     => [:database_servers, resource_id, resource],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 201,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+class Ey::Core::Client
+  class Real
+    def create_database_service(params={})
+      request(
+        :method => :post,
+        :path   => "/database-services",
+        :url    => params.delete("url"),
+        :body   => params,
+      )
+    end
+  end
+
+  class Mock
+    def create_database_service(_params={})
+      params = Cistern::Hash.stringify_keys(_params)
+
+      require_parameters(params, "provider")
+      provider_id = resource_identity(params["provider"])
+      find(:providers, provider_id)
+
+      require_parameters(params["database_service"], "name")
+      request_id  = self.uuid
+      resource_id = self.serial_id
+
+      database_service = params["database_service"].dup
+      database_service["id"] = resource_id
+      database_server = params["database_server"].dup
+      database_server["storage"] ||= 50
+
+      request_block = create_database_service_resource(
+        "database_service" => database_service,
+        "database_server"  => database_server,
+        "provider_id"      => provider_id,
+      )
+
+      request = {
+        "id"           => request_id,
+        "type"         => "provision_database_service",
+        "successful"   => "true",
+        "started_at"   => Time.now,
+        "finished_at"  => nil,
+        "resource_url" => database_service["resource_url"],
+        "resource"     => [:database_services, request_id, request_block],
+      }
+
+      self.data[:requests][request_id] = request
+
+      response_hash = request.dup
+      response_hash.delete("resource")
+
+      response(
+        :body    => {"request" => response_hash},
+        :status  => 201,
+      )
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+class Ey::Core::Client
+  class Real
+    def create_environment(params={})
+      account_id  = params["account"]
+      url         = params.delete("url")
+
+      request(
+        :body   => params,
+        :method => :post,
+        :path   => "/accounts/#{account_id}/environments",
+        :url    => url,
+      )
+    end
+  end # Real
+
+  class Mock
+    def create_environment(params={})
+      resource_id = self.serial_id
+      url         = params.delete("url")
+
+      if project_id = params["project"] || url && path_params(url)["projects"]
+        account_id = resource_identity(find(:projects, project_id)["account"])
+      end
+      account_id ||= params["account"] || url && path_params(url)["accounts"]
+
+      find(:accounts, account_id)
+
+      resource = params["environment"].dup
+
+      internal_key = mock_ssh_key
+
+      resource.merge!(
+        "account"               => url_for("/accounts/#{account_id}"),
+        "applications"          => url_for("/environments/#{resource_id}/applications"),
+        "classic"               => false,
+        "clusters"              => url_for("/environments/#{resource_id}/clusters"),
+        "created_at"            => Time.now,
+        "database_services_url" => url_for("/environments/#{resource_id}/database-services"),
+        "id"                    => resource_id,
+        "internal_private_key"  => internal_key[:private_key],
+        "internal_public_key"   => internal_key[:public_key],
+        "keypairs"              => url_for("/environments/#{resource_id}/keypairs"),
+        "logical_databases_url" => url_for("/environments/#{resource_id}/logical-databases"),
+        "project"               => project_id && url_for("/projects/#{project_id}"),
+        "servers"               => url_for("/environments/#{resource_id}/servers"),
+        "updated_at"            => Time.now,
+      )
+
+      self.data[:environments][resource_id] = resource
+
+      response(
+        :body   => {"environment" => resource},
+        :status => 201,
+      )
+    end
+  end # Mock
+end # Ey::Core::Client