scalingo 3.0.0.beta.1

data/lib/scalingo/regional/domains.rb

@@ -0,0 +1,70 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Domains < API::Endpoint
+    def for(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/domains",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :domains)
+    end
+
+    def find(app_id, domain_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/domains/#{domain_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :domain)
+    end
+
+    def create(app_id, payload = {}, headers = nil, &block)
+      data = {domain: payload}
+
+      response = connection.post(
+        "apps/#{app_id}/domains",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :domain)
+    end
+
+    def update(app_id, domain_id, payload = {}, headers = nil, &block)
+      data = {domain: payload}
+
+      response = connection.patch(
+        "apps/#{app_id}/domains/#{domain_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :domain)
+    end
+
+    def destroy(app_id, domain_id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "apps/#{app_id}/domains/#{domain_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+  end
+end

data/lib/scalingo/regional/environment.rb

@@ -0,0 +1,83 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Environment < API::Endpoint
+    def for(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/variables",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :variables)
+    end
+
+    def create(app_id, payload = {}, headers = nil, &block)
+      data = {variable: payload}
+
+      response = connection.post(
+        "apps/#{app_id}/variables",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :variable)
+    end
+
+    def update(app_id, variable_id, value, headers = nil, &block)
+      data = {variable: {value: value}}
+
+      response = connection.patch(
+        "apps/#{app_id}/variables/#{variable_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :variable)
+    end
+
+    def destroy(app_id, variable_id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "apps/#{app_id}/variables/#{variable_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def bulk_update(app_id, variables, headers = nil, &block)
+      data = {variables: variables}
+
+      response = connection.put(
+        "apps/#{app_id}/variables",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :variables)
+    end
+
+    def bulk_destroy(app_id, variable_ids, headers = nil, &block)
+      data = {variable_ids: variable_ids}
+
+      response = connection.delete(
+        "apps/#{app_id}/variables",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+  end
+end

data/lib/scalingo/regional/events.rb

@@ -0,0 +1,55 @@
+module Scalingo
+  class Regional::Events < API::Endpoint
+    def all(payload = {}, headers = nil, &block)
+      data = payload.compact
+
+      response = connection.get(
+        "events",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :events)
+    end
+
+    def for(app_id, payload = {}, headers = nil, &block)
+      data = payload.compact
+
+      response = connection.get(
+        "apps/#{app_id}/events",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :events)
+    end
+
+    def types(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "event_types",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :event_types)
+    end
+
+    def categories(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "event_categories",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :event_categories)
+    end
+  end
+end

data/lib/scalingo/regional/logs.rb

@@ -0,0 +1,38 @@
+module Scalingo
+  class Regional::Logs < API::Endpoint
+    def get(url, payload = {}, headers = nil, &block)
+      data = payload.compact
+
+      response = connection(allow_guest: true).get(
+        url,
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def archives(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/logs_archives",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :archives)
+    end
+
+    ## Helper method to avoid having to manually chain two operations
+    def for(app_id, payload = {}, headers = nil, &block)
+      logs_response = scalingo.apps.logs_url(app_id)
+
+      return logs_response unless logs_response.successful?
+
+      get(logs_response.data, payload, headers, &block)
+    end
+  end
+end

data/lib/scalingo/regional/metrics.rb

@@ -0,0 +1,41 @@
+require "scalingo/api/endpoint"
+require "active_support/core_ext/hash/indifferent_access"
+
+module Scalingo
+  class Regional::Metrics < API::Endpoint
+    def for(app_id, payload = {}, headers = nil, &block)
+      payload = payload.with_indifferent_access
+      data = payload.except(:metric, :container_type, :container_index).compact
+
+      metric = payload[:metric]
+      url = "apps/#{app_id}/stats/#{metric}"
+
+      if payload[:container_type]
+        url = "#{url}/#{payload[:container_type]}"
+        url = "#{url}/#{payload[:container_index]}" if payload[:container_index]
+      end
+
+      response = connection.get(
+        url,
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def types(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "features/metrics",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :metrics)
+    end
+  end
+end

data/lib/scalingo/regional/notifiers.rb

@@ -0,0 +1,96 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Notifiers < API::Endpoint
+    def for(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/notifiers",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :notifiers)
+    end
+
+    def find(app_id, notifier_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/notifiers/#{notifier_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :notifier)
+    end
+
+    def create(app_id, payload = {}, headers = nil, &block)
+      data = {notifier: payload}
+
+      response = connection.post(
+        "apps/#{app_id}/notifiers",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :notifier)
+    end
+
+    def update(app_id, notifier_id, payload = {}, headers = nil, &block)
+      data = {notifier: payload}
+
+      response = connection.patch(
+        "apps/#{app_id}/notifiers/#{notifier_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :notifier)
+    end
+
+    def destroy(app_id, notifier_id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "apps/#{app_id}/notifiers/#{notifier_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def test(app_id, notifier_id, headers = nil, &block)
+      data = nil
+
+      response = connection.post(
+        "apps/#{app_id}/notifiers/#{notifier_id}/test",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+
+    def platforms(headers = nil, &block)
+      data = nil
+
+      response = connection(allow_guest: true).get(
+        "notification_platforms",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :notification_platforms)
+    end
+  end
+end

data/lib/scalingo/regional/operations.rb

@@ -0,0 +1,18 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::Operations < API::Endpoint
+    def find(app_id, operation_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/operations/#{operation_id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :operation)
+    end
+  end
+end

data/lib/scalingo/regional/scm_repo_links.rb

@@ -0,0 +1,109 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Regional::ScmRepoLinks < API::Endpoint
+    def show(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/scm_repo_link",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :scm_repo_link)
+    end
+
+    def create(app_id, payload = {}, headers = nil, &block)
+      data = {scm_repo_link: payload}
+
+      response = connection.post(
+        "apps/#{app_id}/scm_repo_link",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :scm_repo_link)
+    end
+
+    def update(app_id, payload = {}, headers = nil, &block)
+      data = {scm_repo_link: payload}
+
+      response = connection.patch(
+        "apps/#{app_id}/scm_repo_link",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :scm_repo_link)
+    end
+
+    def destroy(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "apps/#{app_id}/scm_repo_link",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :scm_repo_link)
+    end
+
+    def deploy(app_id, branch, headers = nil, &block)
+      data = {branch: branch}
+
+      response = connection.post(
+        "apps/#{app_id}/scm_repo_link/manual_deploy",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :deployment)
+    end
+
+    def review_app(review_app, pull_request_id, headers = nil, &block)
+      data = {pull_request_id: pull_request_id}
+
+      response = connection.post(
+        "apps/#{app_id}/scm_repo_link/manual_review_app",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :review_app)
+    end
+
+    def branches(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/scm_repo_link/branches",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :branches)
+    end
+
+    def pulls(app_id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "apps/#{app_id}/scm_repo_link/pulls",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :pulls)
+    end
+  end
+end