ey-core 3.0.0

data/lib/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/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/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/ey-core/models/request.rb

@@ -0,0 +1,93 @@
+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
+    requires :callback_url
+
+    merge_attributes(connection.request_callback("url" => self.callback_url).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
+      else
+        connection.database_server_snapshots.get!(resource_id)
+      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/ey-core/models/server.rb

@@ -0,0 +1,76 @@
+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 :devices,          type: :array
+  attribute :disappeared_at,   type: :time
+  attribute :enabled,          type: :boolean
+  attribute :flavor_id,        squash: ["flavor", "id"]
+  attribute :keymaster_id
+  attribute :location
+  attribute :name
+  attribute :private_hostname
+  attribute :provisioned_at,   type: :time
+  attribute :provisioned_id
+  attribute :public_hostname
+  attribute :role
+  attribute :ssh_port,         type: :integer
+  attribute :state
+  attribute :updated_at,       type: :time
+
+  has_one :account
+  has_one :address, collection: "addresses"
+  has_one :environment
+  has_one :provider
+
+  has_many :alerts
+  has_many :volumes
+  has_many :events, key: :server_events
+  has_many :firewalls
+
+  def reboot
+    requires :identity
+
+    connection.requests.new(
+      self.connection.reboot_server("id" => self.identity).body["request"]
+    )
+  end
+
+  def save!
+    if new_record?
+      raise "adding servers is not yet implemented"
+      requires :flavor_id, :role, :environment
+
+      server_attributes = {
+        "flavor" => self.flavor_id,
+        "role"   => self.role,
+      }
+      server_attributes.merge!("location" => self.location)
+      connection.create_server(server_attributes)
+    else
+      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
+  end
+
+  def destroy!
+    if environment.servers.count == 1
+      raise Ey::Core::Client::NotPermitted, "Terminating the last server in an environment is not allowed.  You must deprovision or destroy the environment instead."
+    end
+
+    requires :identity
+
+    connection.requests.new(
+      self.connection.destroy_server(self.identity).body["request"]
+    )
+  end
+end

data/lib/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/ey-core/models/server_usage.rb

@@ -0,0 +1,15 @@
+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
+  attribute :deis
+  attribute :provisioned_id
+
+  has_one :environment
+  has_one :provider
+end

data/lib/ey-core/models/service.rb

@@ -0,0 +1,10 @@
+class Ey::Core::Client::Service < Cistern::Model
+
+  identity :name
+
+  attribute :now, type: :time
+  attribute :environment
+  attribute :revision
+  attribute :version
+
+end

data/lib/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/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

data/lib/ey-core/models/storage_user.rb

@@ -0,0 +1,44 @@
+class Ey::Core::Client::StorageUser < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :username
+  attribute :access_id
+  attribute :secret_key
+  attribute :provisioned_id
+
+  attribute :created_at, type: :time
+  attribute :deleted_at, type: :time
+
+  has_one :storage
+
+  attr_accessor :permissions
+
+  def save!
+    requires :storage_id, :username
+
+    params = {
+        "url"          => self.collection.url,
+        "storage"      => self.storage_id,
+        "storage_user" => {
+          "username"    => self.username,
+          "permissions" => self.permissions
+        },
+    }
+
+    if new_record?
+      self.connection.requests.new(self.connection.create_storage_user(params).body["request"])
+    else raise NotImplementedError
+    end
+  end
+
+  def destroy!
+    requires :identity
+
+    params = {
+      "id" => self.identity,
+    }
+    connection.requests.new(connection.destroy_storage_user(params).body["request"])
+  end
+end

data/lib/ey-core/models/support_trial.rb

@@ -0,0 +1,10 @@
+class Ey::Core::Client::SupportTrial < Ey::Core::Model
+  extend Ey::Core::Associations
+
+  identity :id
+
+  attribute :started_at, type: :time
+  attribute :expires_at, type: :time
+
+  has_one :account
+end

data/lib/ey-core/models/task.rb

@@ -0,0 +1,35 @@
+class Ey::Core::Client::Task < Ey::Core::Model
+  extend Ey::Core::Associations
+  include Ey::Core::Subscribable
+
+  identity :id
+
+  attribute :action
+  attribute :configuration
+  attribute :created_at, type: :time
+  attribute :finished_at, type: :time
+  attribute :message
+  attribute :started_at, type: :time
+  attribute :successful, type: :boolean
+  attribute :updated_at, type: :time
+
+  has_one :application_deployment
+  has_one :schedule
+
+  has_many :component_actions
+
+  def ready?
+    !!finished_at
+  end
+
+  def save!
+    params = {
+      "url" => self.collection.url,
+    }
+
+    if new_record?
+      connection.requests.new(self.connection.create_task(params).body["request"])
+    else raise NotImplementedError # update
+    end
+  end
+end