scalingo-ruby-api 1.0.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e414ecac6ae02a9b85d286fdfea4bb6c9a8f3c4d
+  data.tar.gz: b01e544df9c7ea1b4bc39f62ee68699764305d7e
+SHA512:
+  metadata.gz: c14839d474e165ebe4deaba60e98c2193aa654a2018df1b9955da73292042a8c17c8f92f8f8a9a0842093a5cf02616eff38180c7eb6cd2f6518abfb02b174aea
+  data.tar.gz: 40ac42171d6091944d4d540647d132fa4bfc061e28d6932a4ea00f5512b064ffdfea75221e18732af0a4c756eee8f04f55dd223f9e65858b98142c34f5509897

data/lib/faraday/raise_http_exception.rb

@@ -0,0 +1,47 @@
+require 'faraday'
+
+module FaradayMiddleware
+  class RaiseHttpException < Faraday::Middleware
+    def call(env)
+      @app.call(env).on_complete do |response|
+        case response[:status].to_i
+        when 400
+          raise Scalingo::BadRequest, error_message_400(response)
+        when 404
+          raise Scalingo::NotFound, error_message_400(response)
+        when 500
+          raise Scalingo::InternalServerError, error_message_500(response, "Something is technically wrong.")
+        end
+      end
+    end
+
+    def initialize(app)
+      super app
+      @parser = nil
+    end
+
+    private
+
+    def error_message_400(response)
+      "#{response[:method].to_s.upcase} #{response[:url].to_s}: #{response[:status]}#{error_body(response[:body])}"
+    end
+
+    def error_body(body)
+      # body gets passed as a string, not sure if it is passed as something else from other spots?
+      if not body.nil? and not body.empty? and body.kind_of?(String)
+        # removed multi_json thanks to wesnolte's commit
+        body = ::JSON.parse(body)
+      end
+
+      if body.nil?
+        nil
+      elsif body['meta'] and body['meta']['error_message'] and not body['meta']['error_message'].empty?
+        ": #{body['meta']['error_message']}"
+      end
+    end
+
+    def error_message_500(response, body=nil)
+      "#{response[:method].to_s.upcase} #{response[:url].to_s}: #{[response[:status].to_s + ':', body].compact.join(' ')}"
+    end
+  end
+end

data/lib/scalingo/api.rb

@@ -0,0 +1,22 @@
+require_relative 'connection'
+require_relative 'request'
+require_relative 'configuration'
+require_relative 'endpoint'
+
+module Scalingo
+  class Api
+    attr_accessor(*Configuration::VALID_OPTIONS_KEYS)
+
+    def initialize(options = {})
+      options = Scalingo.options.merge(options)
+      Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", options[key])
+      end
+    end
+
+    include Connection
+    include Request
+    include Endpoint
+  end
+end
+

data/lib/scalingo/client.rb

@@ -0,0 +1,5 @@
+module Scalingo
+  class Client < Api
+  end
+end
+

data/lib/scalingo/configuration.rb

@@ -0,0 +1,65 @@
+require 'faraday'
+require_relative 'version'
+
+module Scalingo
+  # Defines constants and methods related to configuration
+  module Configuration
+    # An array of valid keys in the options hash when configuring a {Scalingo::Api}
+    VALID_OPTIONS_KEYS = [
+      :adapter,
+      :token,
+      :endpoint,
+      :user_agent,
+      :proxy
+    ].freeze
+
+    # The adapter that will be used to connect if none is set
+    #
+    # @note The default faraday adapter is Net::HTTP.
+    DEFAULT_ADAPTER = Faraday.default_adapter
+
+    # By default, don't set an token
+    DEFAULT_TOKEN = nil
+
+    # The endpoint that will be used to connect if none is set
+    #
+    # @note There is no reason to use any other endpoint at this time
+    DEFAULT_ENDPOINT = 'https://api.scalingo.com/v1/'.freeze
+
+    # By default, don't use a proxy server
+    DEFAULT_PROXY = nil
+
+    # The user agent that will be sent to the Api endpoint if none is set
+    DEFAULT_USER_AGENT = "Scalingo Ruby Gem #{Scalingo::VERSION}".freeze
+
+    # @private
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    # When this module is extended, set all configuration options to their default values
+    def self.extended(base)
+      base.reset
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    def configure
+      yield self
+    end
+
+    # Create a hash of options and their values
+    def options
+      VALID_OPTIONS_KEYS.inject({}) do |option, key|
+        option.merge!(key => send(key))
+      end
+    end
+
+    # Reset all configuration options to defaults
+    def reset
+      self.adapter    = DEFAULT_ADAPTER
+      self.token      = DEFAULT_TOKEN
+      self.endpoint   = DEFAULT_ENDPOINT
+      self.user_agent = DEFAULT_USER_AGENT
+      self.proxy      = DEFAULT_PROXY
+    end
+  end
+end
+

data/lib/scalingo/connection.rb

@@ -0,0 +1,34 @@
+require 'faraday_middleware'
+Dir[File.expand_path('../../faraday/*.rb', __FILE__)].each{|f| require f}
+
+module Scalingo
+  module Connection
+    protected
+    def parse_json
+      true
+    end
+
+    private
+    def connection
+      options = {
+        :headers => {
+          'Accept' => 'application/json; charset=utf-8',
+          'Content-Type' => 'application/json',
+          'User-Agent' => user_agent,
+        },
+        :proxy => proxy,
+        :url => endpoint,
+      }
+
+      Faraday::Connection.new(options) do |connection|
+        connection.use Faraday::Request::Multipart
+        connection.use Faraday::Request::UrlEncoded
+        connection.use Faraday::Response::ParseJson if parse_json
+        connection.use FaradayMiddleware::RaiseHttpException
+        connection.adapter(adapter)
+        connection.basic_auth('', token) if token
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint/account_keys.rb

@@ -0,0 +1,23 @@
+module Scalingo
+  module Endpoint
+    class AccountKeys < Collection
+      def initialize(api)
+        super(api, 'account/keys')
+      end
+
+      def collection_name
+        'keys'
+      end
+
+      def create(name, content)
+        post(nil, {key: {name: name, content: content}})
+      end
+    end
+    class AccountKey < Resource
+      def destroy
+        delete
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint/addon_categories.rb

@@ -0,0 +1,7 @@
+module Scalingo
+  module Endpoint
+    class AddonCategories < Collection
+    end
+  end
+end
+

data/lib/scalingo/endpoint/addon_provider.rb

@@ -0,0 +1,7 @@
+module Scalingo
+  module Endpoint
+    class AddonProviders < Collection
+    end
+  end
+end
+

data/lib/scalingo/endpoint/addons.rb

@@ -0,0 +1,19 @@
+module Scalingo
+  module Endpoint
+    class Addons < Collection
+      def create(addon_provider_id, plan_id)
+        post(nil, {addon:{addon_provider_id: addon_provider_id, plan_id: plan_id}})
+      end
+    end
+    class Addon < Resource
+      def update(plan_id)
+        patch(nil, {addon: {plan_id: plan_id}})
+      end
+
+      def destroy
+        delete
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint/apps.rb

@@ -0,0 +1,61 @@
+module Scalingo
+  module Endpoint
+    class Apps < Collection
+      def create(name)
+        post(nil, {app: {name: name}})
+      end
+
+      def find_by
+        'name'
+      end
+    end
+    class App < Resource
+      def scale(containers)
+        post('scale', {containers: containers})
+      end
+
+      def restart(*scopes)
+        post('restart', {scope: scopes})
+      end
+
+      def destroy(current_name)
+        delete(nil, {current_name: current_name})
+      end
+
+      def destroy!
+        destroy(prefix)
+      end
+
+      def rename(new_name, current_name)
+        post('rename', {new_name: new_name, current_name: current_name})
+      end
+      def rename!(new_name)
+        rename(new_name, prefix)
+      end
+
+      def transfer(email)
+        patch(nil, {app: {owner: {email: email}}})
+      end
+
+      def logs_url
+        get('logs')['logs_url']
+      end
+
+      def logs
+        Scalingo::Logs.new(self)
+      end
+
+      def run(command, env = {})
+        post('run', {command: command, env: env})
+      end
+
+      resources :addons
+      resources :collaborators
+      resources :deployments
+      resources :domains
+      resources :variables
+      resources :events, collection_only: true
+    end
+  end
+end
+

data/lib/scalingo/endpoint/collaborators.rb

@@ -0,0 +1,15 @@
+module Scalingo
+  module Endpoint
+    class Collaborators < Collection
+      def create(email)
+        post(nil, {collaborator: {email: email}})
+      end
+    end
+    class Collaborator < Resource
+      def destroy
+        delete
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint/deployments.rb

@@ -0,0 +1,12 @@
+module Scalingo
+  module Endpoint
+    class Deployments < Collection
+    end
+    class Deployment < Resource
+      def output
+        get('output')
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint/domains.rb

@@ -0,0 +1,23 @@
+module Scalingo
+  module Endpoint
+    class Domains < Collection
+      def create(name, tlscert = nil, tlskey = nil)
+        if tlskey
+          post(nil, {domain: {name: name, tlscert: tlscert, tlskey: tlskey}})
+        else
+          post(nil, {domain: {name: name}})
+        end
+      end
+    end
+    class Domain < Resource
+      def update(tlscert, tlskey)
+        path(nil, {domain: {tlscert: tlscert, tlskey: tlskey}})
+      end
+
+      def destroy
+        delete
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint/events.rb

@@ -0,0 +1,7 @@
+module Scalingo
+  module Endpoint
+    class Events < Collection
+    end
+  end
+end
+

data/lib/scalingo/endpoint/variables.rb

@@ -0,0 +1,23 @@
+module Scalingo
+  module Endpoint
+    class Variables < Collection
+      def all(aliases = true)
+        get(nil, {aliases: aliases})[collection_name]
+      end
+
+      def create(name, value)
+        post(nil, {variable: {name: name, value: value}})
+      end
+    end
+    class Variable < Resource
+      def update(value)
+        patch(nil, {variable: {value: value}})
+      end
+
+      def destroy
+        delete
+      end
+    end
+  end
+end
+

data/lib/scalingo/endpoint.rb

@@ -0,0 +1,94 @@
+module Scalingo
+  module Endpoint
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def resources(name, opts = {})
+        name = name.to_s
+        define_method(name.pluralize.underscore) do
+          Scalingo::Endpoint.const_get(name.pluralize.camelize).new(self)
+        end
+
+        return if opts[:collection_only]
+
+        define_method(name.singularize.underscore) do |id|
+          send(name.pluralize.underscore).find(id)
+        end
+      end
+    end
+
+    extend ClassMethods
+    resources :apps
+    resources :account_keys
+    resources :addon_providers,  collection_only: true
+    resources :addon_categories, collection_only: true
+
+    module Base
+      attr_accessor :api
+      attr_accessor :prefix
+
+      def initialize(api, prefix = nil)
+        self.api = api
+        self.prefix = prefix || self.class.name.split('::').last.underscore.pluralize
+      end
+
+      Request::REQUEST_METHODS.each do |method|
+        define_method(method) do |path = nil, options = {}|
+          api.send(method, "#{prefix}/#{path}", options)
+        end
+      end
+    end
+
+    class Resource < OpenStruct
+      include Base
+      include Endpoint
+
+      def initialize(api, prefix, data = {})
+        Base.instance_method(:initialize).bind(self).call(api, prefix)
+        OpenStruct.instance_method(:initialize).bind(self).call(data)
+      end
+    end
+
+    class Collection
+      include Base
+      include Endpoint
+      include Enumerable
+
+      def all
+        get[collection_name].map{|r| resource_class.new(self, r[find_by], r)}
+      end
+      alias_method :to_a, :all
+
+      def each
+        block_given? ? all.each(&Proc.new) : all.each
+      end
+
+      def find(id)
+        detect{|r| r[find_by] == id}
+      end
+
+      def collection_name
+        @collection_name ||= self.class.name.underscore.split('/').last
+      end
+
+      def resource_class
+        @resource_class ||= begin
+                              Scalingo::Endpoint.const_get(self.class.name.singularize.split('::').last)
+                            rescue
+                              OpenStruct
+                            end
+      end
+
+      def find_by
+        'id'
+      end
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), 'endpoint', '*.rb')].each do |endpoint|
+  require endpoint
+end
+

data/lib/scalingo/error.rb

@@ -0,0 +1,13 @@
+module Scalingo
+  # Custom error class for rescuing from all Scalingo errors
+  class Error < StandardError; end
+
+  # Raised when Scalingo returns the HTTP status code 400
+  class BadRequest < Error; end
+
+  # Raised when Scalingo returns the HTTP status code 404
+  class NotFound < Error; end
+
+  # Raised when Scalingo returns the HTTP status code 500
+  class InternalServerError < Error; end
+end

data/lib/scalingo/logs.rb

@@ -0,0 +1,36 @@
+require_relative 'realtime/logs'
+
+module Scalingo
+  class Logs < Client
+    attr_reader :app
+
+    def initialize(app)
+      super({endpoint: ''})
+      @app = app
+    end
+
+    def dump(lines = 10)
+      get('', n: lines)
+    end
+
+    def realtime
+      Scalingo::Realtime::Logs.new(app)
+    end
+
+    protected
+    def log_token
+      self.endpoint, log_token = app.logs_url.split('?')
+      @log_token = log_token.split('=').last
+    end
+
+    def parse_json
+      false
+    end
+
+    def request(method, path, options)
+      options.merge!(token: log_token)
+      super(method, path, options)
+    end
+  end
+end
+

data/lib/scalingo/realtime/logs.rb

@@ -0,0 +1,50 @@
+require 'faye/websocket'
+require 'eventmachine'
+
+module Scalingo
+  module Realtime
+    class Logs
+      attr_reader :app
+
+      def initialize(app)
+        @app = app
+        @callbacks = []
+      end
+
+      def each_line(&block)
+        @callbacks << block
+      end
+
+      def start
+        each_line(&Proc.new) if block_given?
+
+        EM.run do
+          ws = Faye::WebSocket::Client.new(url)
+
+          ws.on :open do |event|
+          end
+
+          ws.on :message do |event|
+            data = JSON.parse(event.data)
+            if data['event'] == 'log'
+              @callbacks.each{|c| c.call(data['log'])}
+            end
+          end
+
+          ws.on :close do |event|
+            ws = nil
+          end
+
+          Signal.trap('INT')  { EM.stop }
+          Signal.trap('TERM') { EM.stop }
+        end
+      end
+
+      protected
+      def url
+        "#{app.logs_url}&stream=true"
+      end
+    end
+  end
+end
+

data/lib/scalingo/request.rb

@@ -0,0 +1,32 @@
+module Scalingo
+  module Request
+    REQUEST_METHODS = [
+      :get,
+      :post,
+      :patch,
+      :put,
+      :delete
+    ]
+
+    REQUEST_METHODS.each do |method|
+      define_method(method) do |path, options = {}|
+        request(method, path, options)
+      end
+    end
+
+    protected
+    def request(method, path, options)
+      response = connection.send(method) do |request|
+        case method
+        when :get, :delete
+          request.url(path, options)
+        when :post, :patch, :put
+          request.path = path
+          request.body = options if !options.empty?
+        end
+      end
+      return response.body
+    end
+  end
+end
+

data/lib/scalingo/version.rb

@@ -0,0 +1,4 @@
+module Scalingo
+  VERSION = '1.0.0.alpha1'
+end
+

data/lib/scalingo.rb

@@ -0,0 +1,26 @@
+require 'active_support/inflector'
+
+require_relative 'scalingo/error'
+require_relative 'scalingo/configuration'
+require_relative 'scalingo/api'
+require_relative 'scalingo/client'
+require_relative 'scalingo/logs'
+require_relative 'scalingo/version'
+
+module Scalingo
+  extend Configuration
+
+  def self.client(options = {})
+    Scalingo::Client.new(options)
+  end
+
+  def self.method_missing(method, *args, &block)
+    return super unless client.respond_to?(method)
+    client.send(method, *args, &block)
+  end
+
+  def self.respond_to?(method)
+    return client.respond_to?(method) || super
+  end
+end
+

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: scalingo-ruby-api
+version: !ruby/object:Gem::Version
+  version: 1.0.0.alpha1
+platform: ruby
+authors:
+- Geoffroy Planquart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.7'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Ruby wrapper around the web API of scalingo.io
+email:
+- geoffroy@planquart.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/faraday/raise_http_exception.rb
+- lib/scalingo.rb
+- lib/scalingo/api.rb
+- lib/scalingo/client.rb
+- lib/scalingo/configuration.rb
+- lib/scalingo/connection.rb
+- lib/scalingo/endpoint.rb
+- lib/scalingo/endpoint/account_keys.rb
+- lib/scalingo/endpoint/addon_categories.rb
+- lib/scalingo/endpoint/addon_provider.rb
+- lib/scalingo/endpoint/addons.rb
+- lib/scalingo/endpoint/apps.rb
+- lib/scalingo/endpoint/collaborators.rb
+- lib/scalingo/endpoint/deployments.rb
+- lib/scalingo/endpoint/domains.rb
+- lib/scalingo/endpoint/events.rb
+- lib/scalingo/endpoint/variables.rb
+- lib/scalingo/error.rb
+- lib/scalingo/logs.rb
+- lib/scalingo/realtime/logs.rb
+- lib/scalingo/request.rb
+- lib/scalingo/version.rb
+homepage: https://github.com/Aethelflaed/scalingo-ruby-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby API for the awesome scalingo project !
+test_files: []
+has_rdoc: