ey-pro-cli 0.0.3

data/lib/vendor/core/ey-core/models/metadata.rb

@@ -0,0 +1,15 @@
+class Ey::Core::Client::Metadata < Cistern::Singular
+
+  attribute :now, type: :time
+  attribute :environment
+  attribute :revision
+  attribute :version
+
+  def singular_request
+    :get_metadata
+  end
+
+  def fetch_attributes
+    connection.send(self.singular_request).body
+  end
+end

data/lib/vendor/core/ey-core/models/plan_usage.rb

@@ -0,0 +1,14 @@
+class Ey::Core::Client::PlanUsage < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  attribute :billable
+  attribute :billable_type
+  attribute :description
+  attribute :end_at,      type: :time
+  attribute :flavor_limit
+  attribute :report_time, type: :time
+  attribute :server_limit
+  attribute :start_at,    type: :time
+  attribute :support
+  attribute :type
+end

data/lib/vendor/core/ey-core/models/provider.rb

@@ -0,0 +1,59 @@
+class Ey::Core::Client::Provider < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :cancelled_at, type: :time
+  attribute :created_at,   type: :time
+  attribute :credentials
+  attribute :provisioned_id
+  attribute :shared,       type: :boolean
+  attribute :type
+  attribute :updated_at,   type: :time
+
+  has_one :account
+
+  has_many :provider_locations
+  has_many :servers
+  has_many :storages
+  has_many :untracked_servers
+
+  def possible_locations(provider_type = self.type)
+    self.connection.get_possible_provider_locations(provider_type).body["locations"].map { |l| l["id"] }
+  end
+
+  def database_server_snapshots
+    connection.database_server_snapshots.load(connection.get_database_server_snapshots("provider" => self.id).body["database_server_snapshots"])
+  end
+
+  def discover_database_server_snapshots
+    connection.requests.new(connection.discover_database_server_snapshots("provider" => self.id).body["request"])
+  end
+
+  # @return [Ey::Core::Client::Account]
+  def account
+    self.connection.accounts.new(self.connection.get_account("url" => self.account_url).body["account"])
+  end
+
+  def destroy!
+    connection.requests.new(self.connection.destroy_provider(self.id).body["request"])
+  end
+
+  def save
+    params = {
+      "url"      => self.collection.url,
+      "account"  => self.account_id,
+      "provider" => {
+        "credentials"    => self.credentials,
+        "provisioned_id" => self.provisioned_id,
+        "type"           => self.type,
+      },
+    }
+    if new_record?
+      connection.requests.new(self.connection.create_provider(params).body["request"])
+    else raise NotImplementedError # update
+    end
+  end
+
+  alias save! save
+end

data/lib/vendor/core/ey-core/models/provider_location.rb

@@ -0,0 +1,11 @@
+class Ey::Core::Client::ProviderLocation < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :location_id
+  attribute :location_name
+  attribute :limits, type: :hash
+
+  has_one :provider
+end

data/lib/vendor/core/ey-core/models/request.rb

@@ -0,0 +1,89 @@
+class Ey::Core::Client::Request < Ey::Core::Model
+  include Ey::Core::Subscribable
+
+  identity :id
+
+  attribute :callback_url
+  attribute :created_at,        type: :time
+  attribute :finished_at,       type: :time
+  attribute :message
+  attribute :progress,          type: :integer
+  attribute :resource_url,      aliases: "resource"
+  attribute :stage
+  attribute :started_at,        type: :time
+  attribute :successful,        type: :boolean
+  attribute :type
+  attribute :updated_at,        type: :time
+
+  def callback
+    merge_attributes(connection.request_callback(self.id).body["request"])
+  end
+
+  def ready!(timeout = self.service.timeout, interval = self.service.poll_interval)
+    wait_for!(timeout, interval) { ready? }
+    raise Ey::Core::RequestFailure.new(self) unless successful?
+    self
+  end
+
+  def ready?
+    !!self.finished_at
+  end
+
+  def successful?
+    self.successful
+  end
+
+  def resource!(timeout = self.service.timeout, interval = self.service.poll_interval)
+    ready!(timeout, interval); resource
+  end
+
+  def resource
+    return nil unless resource_url
+    resource_id = resource_url.split("/").last
+    case type
+    when /address/
+      self.connection.addresses.get!(resource_id)
+    when /cluster_update/
+      self.connection.cluster_updates.get!(resource_id)
+    when /database_server_snapshot/
+      collection, id = resource_url.split('/')[-3..-2]
+      if collection == "providers"
+        connection.providers.get!(id).database_server_snapshots
+      elsif collection == "database-servers"
+        connection.database_servers.get!(id).snapshots
+      end
+    when /database_server/
+      self.connection.database_servers.get!(resource_id)
+    when /database_service/
+      self.connection.database_services.get!(resource_id)
+    when /firewall(?!_rule)/
+      self.connection.firewalls.get!(resource_id)
+    when /firewall_rule/
+      self.connection.firewall_rules.get!(resource_id)
+    when /logical_database/
+      self.connection.logical_databases.get!(resource_id)
+    when /provider_location/
+      self.connection.provider_locations.get!(resource_id)
+    when /provider_storage_credential/
+      self.connection.storage_users.get!(resource_id)
+    when /provider_storage/
+      self.connection.storages.get!(resource_id)
+    when /provider/
+      self.connection.providers.get!(resource_id)
+    when /server/
+      self.connection.servers.get!(resource_id)
+    when /snapshot/
+      self.connection.snapshots.get!(resource_id)
+    when /task/
+      self.connection.tasks.get!(resource_id)
+    when /volume/
+      self.connection.volumes.get!(resource_id)
+    when /load_balancer/
+      self.connection.load_balancers.get!(resource_id)
+    when /ssl_certificate/
+      self.connection.ssl_certificates.get!(resource_id)
+    else
+      nil # has no coresponding resource
+    end
+  end
+end

data/lib/vendor/core/ey-core/models/server.rb

@@ -0,0 +1,69 @@
+class Ey::Core::Client::Server < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id, type: :integer
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+  attribute :deprovisioned_at, type: :time
+  attribute :disappeared_at, type: :time
+  attribute :devices, type: :array
+  attribute :enabled, type: :boolean
+  attribute :flavor_id, squash: ["flavor", "id"]
+  attribute :keymaster_id
+  attribute :legacy_role
+  attribute :location
+  attribute :name
+  attribute :private_hostname
+  attribute :provisioned_at, type: :time
+  attribute :provisioned_id
+  attribute :public_hostname
+  attribute :ssh_port, type: :integer
+  attribute :state
+  attribute :updated_at, type: :time
+
+  has_one :account
+  has_one :address, collection: "addresses"
+  has_one :cluster
+  has_one :environment
+  has_one :provider
+  has_one :slot
+
+  has_many :alerts
+  has_many :volumes
+  has_many :events, key: :server_events
+  has_many :firewalls
+
+  def reboot
+    requires :identity
+
+    params = {
+      "url" => self.collection.url,
+      "id"  => self.identity,
+    }
+
+    connection.requests.new(
+      self.connection.reboot_server(params).body["request"]
+    )
+  end
+
+  def save!
+    requires :identity
+
+    server_attributes = Cistern::Hash.slice(Cistern::Hash.stringify_keys(self.attributes), "provisioned_at", "deprovisioned_at", "disappeared_at")
+    server_attributes.merge!("status" => self.state) if self.state
+
+    connection.update_server(
+      "id"     => self.identity,
+      "server" => server_attributes,
+    )
+  end
+
+  def destroy!
+    requires :identity
+
+    connection.requests.new(
+      self.connection.destroy_server(self.identity).body["request"]
+    )
+  end
+end

data/lib/vendor/core/ey-core/models/server_event.rb

@@ -0,0 +1,11 @@
+class Ey::Core::Client::ServerEvent < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :type
+  attribute :created_at, type: :time
+  attribute :updated_at, type: :time
+
+  has_one :server
+end

data/lib/vendor/core/ey-core/models/server_usage.rb

@@ -0,0 +1,13 @@
+class Ey::Core::Client::ServerUsage < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  attribute :start_at,    type: :time
+  attribute :end_at,      type: :time
+  attribute :report_time, type: :time
+  attribute :flavor
+  attribute :dedicated
+  attribute :location
+
+  has_one :environment
+  has_one :provider
+end

data/lib/vendor/core/ey-core/models/slot.rb

@@ -0,0 +1,64 @@
+class Ey::Core::Client::Slot < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+  attribute :disabled_at, type: :time
+  attribute :disable_requested_at, type: :time
+  attribute :flavor
+  attribute :image
+  attribute :name
+  attribute :retired_at, type: :time
+  attribute :updated_at, type: :time
+  attribute :volumes, type: :array
+
+  has_one :cluster
+  has_one :server
+
+  has_many :slot_components, aliases: "components"
+
+  def retire
+    return false if new_record?
+    params = {
+      "id" => id,
+      "slot" => {
+        "retired" => true
+      }
+    }
+
+    merge_attributes(self.connection.update_slot(params).body["slot"])
+  end
+
+  def disable
+    return false if new_record?
+    params = {
+      "id" => id,
+      "slot" => {
+        "disabled" => true
+      }
+    }
+
+    merge_attributes(self.connection.update_slot(params).body["slot"])
+  end
+
+  def save!
+    raise NotImplementedError, "Cannot create or update a single slot"
+=begin
+    params = {
+      "cluster" => self.cluster_id,
+      "url"     => self.collection.url,
+      "slot"    => {
+        "image"   => self.image,
+        "flavor"  => self.flavor,
+      },
+    }
+
+    if new_record?
+      self.connections.slots.load(self.connection.create_slot(params).body["slot"])
+    else raise NotImplementedError # update
+    end
+=end
+  end
+end

data/lib/vendor/core/ey-core/models/slot_component.rb

@@ -0,0 +1,28 @@
+class Ey::Core::Client::SlotComponent < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :configuration
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+  attribute :name
+  attribute :updated_at, type: :time
+
+  has_one :slot
+  has_one :cluster_component
+  has_one :component
+
+  def save!
+    raise "Cannot create new slot components" if new_record?
+
+    params = {
+      "id" => id,
+      "slot_component" => {
+        "configuration" => configuration,
+      }
+    }
+
+    merge_attributes(self.connection.update_slot_component(params).body["slot_component"])
+  end
+end

data/lib/vendor/core/ey-core/models/ssl_certificate.rb

@@ -0,0 +1,44 @@
+class Ey::Core::Client::SslCertificate < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+
+  attribute :name
+  attribute :public_certificate
+  attribute :private_key
+  attribute :certificate_chain
+  attribute :self_signed
+
+  has_one :account
+
+  attr_accessor :self_sign
+
+  def save!
+    params = {
+      "url"             => self.collection.url,
+      "account"         => self.account_id,
+      "ssl_certificate" => {
+        "name"               => self.name,
+        "public_certificate" => self.public_certificate,
+        "private_key"        => self.private_key,
+        "certificate_chain"  => self.certificate_chain,
+      }
+    }
+
+    params["ssl_certificate"].merge!("self_sign" => self.self_sign.nil? ? self.self_signed : self.self_sign) if new_record?
+
+    if new_record?
+      connection.requests.new(self.connection.create_ssl_certificate(params).body["request"])
+    else
+      params["id"] = self.id
+      self.connection.update_ssl_certificate(params).body["request"]
+    end
+  end
+
+  def destroy!
+    self.connection.destroy_ssl_certificate("id" => self.id)
+  end
+end

data/lib/vendor/core/ey-core/models/storage.rb

@@ -0,0 +1,38 @@
+class Ey::Core::Client::Storage < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :name
+  attribute :location
+  attribute :provisioned_id
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+
+  has_one :provider
+
+  has_many :storage_users, aliases: "users"
+
+  def save!
+    requires :provider_id, :name, :location
+
+    params = {
+        "url" => self.collection.url,
+        "provider" => self.provider_id,
+        "storage" => {
+          "location" => self.location,
+          "name" => self.name
+        },
+    }
+
+    if new_record?
+      self.connection.requests.new(self.connection.create_storage(params).body["request"])
+    else raise NotImplementedError
+    end
+  end
+
+  def destroy!
+    connection.requests.new(connection.destroy_storage(id).body["request"])
+  end
+end