scalingo 3.0.0.beta.1

data/lib/scalingo/config.rb

@@ -0,0 +1,38 @@
+require "active_support/core_ext/numeric/time"
+require "dry-configurable"
+require "scalingo/version"
+
+module Scalingo
+  extend Dry::Configurable
+
+  # Known regions. Each region should have a corresponding entry in the urls settings below
+  setting :regions, %i[osc_fr1 osc_secnum_fr1]
+
+  # Default region
+  setting :default_region, :osc_fr1
+
+  # Endpoints URLS
+  setting :urls do
+    setting :auth, "https://auth.scalingo.com/v1"
+    setting :osc_fr1, "https://api.osc-fr1.scalingo.com/v1"
+    setting :osc_secnum_fr1, "https://api.osc-secnum-fr1.scalingo.com/v1"
+  end
+
+  # Configure the User Agent header
+  setting :user_agent, "Scalingo Ruby Client v#{Scalingo::VERSION}"
+
+  # For how long is a bearer token considered valid (it will raise passed this delay).
+  # Set to nil to never raise.
+  setting :exchanged_token_validity, 1.hour
+
+  # Raise an exception when trying to use an authenticated connection without a bearer token set
+  # Having this setting to true prevents performing requests that would fail due to lack of authentication headers.
+  setting :raise_on_missing_authentication, true
+
+  # These headers will be added to every request. Individual methods may override them.
+  # This should be a hash or a callable object that returns a hash.
+  setting :additional_headers, {}
+
+  # Raise an exception when the bearer token in use is supposed to be invalid
+  setting :raise_on_expired_token, false
+end

data/lib/scalingo/error/expired_token.rb

@@ -0,0 +1,6 @@
+module Scalingo
+  module Error
+    class ExpiredToken < StandardError
+    end
+  end
+end

data/lib/scalingo/error/unauthenticated.rb

@@ -0,0 +1,6 @@
+module Scalingo
+  module Error
+    class Unauthenticated < StandardError
+    end
+  end
+end

data/lib/scalingo/errors.rb

@@ -0,0 +1,2 @@
+require "scalingo/error/expired_token"
+require "scalingo/error/unauthenticated"

data/lib/scalingo/regional.rb

@@ -0,0 +1,35 @@
+require "scalingo/api/client"
+
+module Scalingo
+  class Regional < API::Client
+    require "scalingo/regional/addons"
+    require "scalingo/regional/apps"
+    require "scalingo/regional/collaborators"
+    require "scalingo/regional/containers"
+    require "scalingo/regional/deployments"
+    require "scalingo/regional/domains"
+    require "scalingo/regional/environment"
+    require "scalingo/regional/events"
+    require "scalingo/regional/logs"
+    require "scalingo/regional/metrics"
+    require "scalingo/regional/notifiers"
+    require "scalingo/regional/operations"
+    require "scalingo/regional/scm_repo_links"
+
+    register_handlers!(
+      addons: Addons,
+      apps: Apps,
+      collaborators: Collaborators,
+      containers: Containers,
+      deployments: Deployments,
+      domains: Domains,
+      environment: Environment,
+      events: Events,
+      logs: Logs,
+      metrics: Metrics,
+      notifiers: Notifiers,
+      operations: Operations,
+      scm_repo_links: ScmRepoLinks,
+    )
+  end
+end

data/lib/scalingo/regional/addons.rb

@@ -0,0 +1,109 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Addons < API::Endpoint
+    def for(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/addons",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addons)
+    end
+
+    def find(app_id, addon_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/addons/#{addon_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addon)
+    end
+
+    def provision(app_id, payload = {}, headers = nil, &block)
+      data = {addon: payload}
+
+      response = connection.post(
+        "apps/#{app_id}/addons",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addon)
+    end
+
+    def update(app_id, addon_id, payload = {}, headers = nil, &block)
+      data = {addon: payload}
+
+      response = connection.patch(
+        "apps/#{app_id}/addons/#{addon_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addon)
+    end
+
+    def destroy(app_id, addon_id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "apps/#{app_id}/addons/#{addon_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def sso(app_id, addon_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/addons/#{addon_id}/sso",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addon)
+    end
+
+    def categories(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "addon_categories",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addon_categories)
+    end
+
+    def providers(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "addon_providers",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :addon_providers)
+    end
+  end
+end

data/lib/scalingo/regional/apps.rb

@@ -0,0 +1,109 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Apps < API::Endpoint
+    def all(headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :apps)
+    end
+
+    def find(id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :app)
+    end
+
+    def create(payload = {}, headers = nil, &block)
+      data = {app: payload}
+
+      dry_run = !!(payload[:dry_run] || payload["dry_run"])
+
+      request_headers = {}
+      request_headers["X-Dry-Run"] = "true" if dry_run
+      request_headers.update(headers) if headers
+
+      response = connection.post(
+        "apps",
+        data,
+        request_headers,
+        &block
+      )
+
+      unpack(response, key: :app)
+    end
+
+    def update(id, payload = {}, headers = nil, &block)
+      data = {app: payload}
+
+      response = connection.patch(
+        "apps/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :app)
+    end
+
+    def logs_url(id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{id}/logs",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :logs_url)
+    end
+
+    def destroy(id, payload = {}, headers = nil, &block)
+      response = connection.delete(
+        "apps/#{id}",
+        payload,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def rename(id, payload = {}, headers = nil, &block)
+      response = connection.post(
+        "apps/#{id}/rename",
+        payload,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :app)
+    end
+
+    def transfer(id, payload = {}, headers = nil, &block)
+      response = connection.patch(
+        "apps/#{id}",
+        payload,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :app)
+    end
+  end
+end

data/lib/scalingo/regional/collaborators.rb

@@ -0,0 +1,57 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Collaborators < API::Endpoint
+    def for(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/collaborators",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :collaborators)
+    end
+
+    def destroy(app_id, collaborator_id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "apps/#{app_id}/collaborators/#{collaborator_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def invite(app_id, payload = {}, headers = nil, &block)
+      data = {collaborator: payload}
+
+      response = connection.post(
+        "apps/#{app_id}/collaborators",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :collaborator)
+    end
+
+    def accept(token, headers = nil, &block)
+      data = {token: token}
+
+      response = connection.get(
+        "apps/collaboration",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+  end
+end

data/lib/scalingo/regional/containers.rb

@@ -0,0 +1,57 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Containers < API::Endpoint
+    def for(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/containers",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :containers)
+    end
+
+    def scale(app_id, formation, headers = nil, &block)
+      data = {containers: formation}
+
+      response = connection.post(
+        "apps/#{app_id}/scale",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :containers)
+    end
+
+    def restart(app_id, scope = [], headers = nil, &block)
+      data = {scope: scope}
+
+      response = connection.post(
+        "apps/#{app_id}/restart",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def sizes(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "features/container_sizes",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :container_sizes)
+    end
+  end
+end

data/lib/scalingo/regional/deployments.rb

@@ -0,0 +1,44 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Deployments < API::Endpoint
+    def for(app_id, payload = {}, headers = nil, &block)
+      data = payload.compact
+
+      response = connection.get(
+        "apps/#{app_id}/deployments",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :deployments)
+    end
+
+    def find(app_id, deployment_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/deployments/#{deployment_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :deployment)
+    end
+
+    def logs(app_id, deployment_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/deployments/#{deployment_id}/output",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :deployment)
+    end
+  end
+end