travis-async-listener 1.8.3

data/lib/travis/client/error.rb

@@ -0,0 +1,38 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class Error < StandardError
+    end
+
+    class SSLError < Error
+    end
+
+    class NotFound < Error
+    end
+
+    class NotLoggedIn < Error
+    end
+
+    class ValidationFailed < Error
+      attr_reader :errors
+
+      def initialize(message = nil, *args)
+        message = parse_message(message) if message
+        super(message, *args)
+      end
+
+      def parse_message(message)
+        response   = JSON.load(message)
+        message    = response['message'].to_s
+        if @errors = response['errors'] and @errors.any?
+          readable = @errors.map { |e| "#{e['field']}: #{e['code'].gsub('_', ' ')}" }
+          message += " (#{readable.join(', ')})"
+        end
+        message
+      rescue JSON::ParserError
+        message
+      end
+    end
+  end
+end

data/lib/travis/client/has_uuid.rb

@@ -0,0 +1,13 @@
+module Travis
+  module Client
+    module HasUuid
+      def id?(object)
+         object =~ /\A(?:\w+-){4}\w+\Z/ if object.is_a? String
+      end
+
+      def cast_id(object)
+        object.to_str
+      end
+    end
+  end
+end

data/lib/travis/client/job.rb

@@ -0,0 +1,61 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class Job < Entity
+      include States, Restartable
+      preloadable
+
+      # @!parse attr_reader :repository_id, :build_id, :commit_id, :log_id, :number, :config, :state, :started_at, :finished_at, :queue, :allow_failure, :tags
+      attributes :repository_id, :build_id, :commit_id, :log_id, :number, :config, :state, :started_at, :finished_at, :queue, :allow_failure, :tags, :annotation_ids
+      time :started_at, :finished_at
+
+      alias allow_failure? allow_failure
+
+      # @!parse attr_reader :commit, :repository, :build, :annotations
+      has :commit, :repository, :build, :log, :annotations
+
+      one :job
+      many :jobs
+
+      def pull_request?
+        build.pull_request?
+      end
+
+      def push?
+        build.push?
+      end
+
+      def branch_info
+        build.branch_info
+      end
+
+      def allow_failures?
+        return false unless config.include? 'matrix' and config['matrix'].include? 'allow_failures'
+        config['matrix']['allow_failures'].any? do |allow|
+          allow.all? { |key, value| config[key] == value }
+        end
+      end
+
+      def duration
+        attributes['duration'] ||= begin
+          start  = started_at  || Time.now
+          finish = finished_at || Time.now
+          (finish - start).to_i
+        end
+      end
+
+      def delete_log(reason = {})
+        log.delete_body(reason)
+      end
+
+      def pusher_channels
+        build.pusher_channels + ["job-#{id}"]
+      end
+
+      def inspect_info
+        "#{repository.slug}##{number}"
+      end
+    end
+  end
+end

data/lib/travis/client/lint_result.rb

@@ -0,0 +1,25 @@
+module Travis
+  module Client
+    class LintResult
+      Warning = Struct.new(:key, :message)
+      attr_accessor :warnings
+
+      def initialize(payload)
+        @warnings = []
+        payload   = payload['lint'] if payload['lint']
+
+        Array(payload['warnings']).each do |warning|
+          @warnings << Warning.new(warning['key'], warning['message'])
+        end
+      end
+
+      def warnings?
+        warnings.any?
+      end
+
+      def ok?
+        !warnings?
+      end
+    end
+  end
+end

data/lib/travis/client/listener.rb

@@ -0,0 +1,184 @@
+require 'travis/client'
+require 'forwardable'
+require 'json'
+
+if require 'pusher-client'
+  # it's us that has been loading pusher-client
+  # so let's assume we can mess with it - yay for global state
+  PusherClient.logger.level = 5
+end
+
+module Travis
+  module Client
+    class Listener
+      class Socket < PusherClient::Socket
+        attr_accessor :session, :signatures
+        def initialize(application_key, options = {})
+          @session    = options.fetch(:session)
+          @signatures = {}
+          super
+
+          bind('pusher:error') do |data|
+            handle_error(data)
+          end
+        end
+
+        def subscribe_all
+          # bulk auth on connect
+          fetch_auth(*channels.channels.keys)
+          super
+        end
+
+        def fetch_auth(*channels)
+          channels.select! { |c| signatures[c].nil? if c.start_with? 'private-' }
+          signatures.merge! session.post_raw('/pusher/auth', :channels => channels, :socket_id => socket_id)['channels'] if channels.any?
+        end
+
+        def get_private_auth(channel)
+          fetch_auth(channel.name)
+          signatures[channel.name]
+        end
+
+        def handle_error(data)
+          code, message = data["code"], data["message"] if data.is_a? Hash
+          message ||= data.inspect
+
+          case code
+          when 4100             then reconnect(1)
+          when 4200, 4201, 4202 then reconnect
+          else raise Travis::Client::Error, "Pusher error: %s (code: %p)" % [message, code]
+          end
+        end
+
+        def reconnect(delay = nil)
+          disconnect if connected
+          sleep delay if delay and delay > 0
+          connect
+        end
+      end
+
+      EVENTS = %w[
+        build:created build:started build:finished
+        job:created job:started job:log job:finished
+      ]
+
+      Event = Struct.new(:type, :repository, :build, :job, :payload)
+
+      class EntityListener
+        attr_reader :listener, :entities
+
+        extend Forwardable
+        def_delegators :listener, :disconnect, :on_connect, :subscribe
+
+        def initialize(listener, entities)
+          @listener, @entities = listener, Array(entities)
+        end
+
+        def on(*events)
+          listener.on(*events) { |e| yield(e) if dispatch?(e) }
+        end
+
+        private
+
+          def dispatch?(event)
+            entities.include? event.repository or
+            entities.include? event.build      or
+            entities.include? event.job
+          end
+      end
+
+      attr_reader :session, :socket
+
+      def initialize(session)
+        @session   = session
+        @socket    = Socket.new(pusher_key, pusher_options)
+        @channels  = []
+        @callbacks = []
+
+        socket.connect(true)
+      end
+
+      def subscribe(*entities)
+        entities = entities.map do |entity|
+          entity = entity.pusher_entity while entity.respond_to? :pusher_entity
+          @channels.concat(entity.pusher_channels)
+          entity
+        end
+
+        yield entities.any? ? EntityListener.new(self, entities) : self if block_given?
+      end
+
+      def on(*events, &block)
+        events = events.flat_map { |e| e.respond_to?(:to_str) ? e.to_str : EVENTS.grep(e) }.uniq
+        events.each { |e| @callbacks << [e, block] }
+      end
+
+      def on_connect
+        socket.bind('pusher:connection_established') { yield }
+      end
+
+      def listen
+        @channels = default_channels if @channels.empty?
+        @channels.map! { |c| c.start_with?('private-') ? c : "private-#{c}" } if session.private_channels?
+        @channels.uniq.each { |c| socket.subscribe(c) }
+        @callbacks.each { |e,b| socket.bind(e) { |d| dispatch(e, d, &b) } }
+      end
+
+      def disconnect
+        socket.disconnect
+      end
+
+      private
+
+        def dispatch(type, json)
+          payload  = JSON.parse(json)
+          entities = session.load format_payload(type, payload)
+          yield Event.new(type, entities['repository'], entities['build'], entities['job'], payload)
+        end
+
+        def format_payload(type, payload)
+          case type
+          when "job:log" then format_log(payload)
+          when /job:/    then format_job(payload)
+          else payload
+          end
+        end
+
+        def format_job(payload)
+          build           = { "id" => payload["build_id"],      "repository_id" => payload["repository_id"]   }
+          repo            = { "id" => payload["repository_id"], "slug"          => payload["repository_slug"] }
+          build["number"] = payload["number"][/^[^\.]+/] if payload["number"]
+          { "job" => payload, "build" => build, "repository" => repo }
+        end
+
+        def format_log(payload)
+          job = session.job(payload['id'])
+          { "job" => { "id" => job.id }, "build" => { "id" => job.build.id }, "repository" => { "id" => job.repository.id } }
+        end
+
+        def default_channels
+          return ['common'] if session.access_token.nil?
+          session.user.channels
+        end
+
+        def pusher_options
+          pusher_options       = session.config['pusher'] || {}
+          encrypted            = pusher_options['scheme'] != 'http'
+          options              = { :encrypted => encrypted, :session => session }
+          options[:ws_host]    = pusher_options['host'] if pusher_options['host']
+          options[:wss_port]   = pusher_options['port'] if encrypted  and pusher_options['port']
+          options[:ws_port]    = pusher_options['port'] if !encrypted and pusher_options['port']
+          options[:ws_path]    = pusher_options['path'] if pusher_options['path']
+          options[:ws_path]    = '/' << options[:ws_path] unless options[:ws_path].nil? or options[:ws_path].start_with? '/'
+          options[:ssl_verify] = session.ssl.fetch(:verify, true)
+          options
+        end
+
+        def pusher_key
+          session.config.fetch('pusher').fetch('key')
+        rescue IndexError
+          raise Travis::Client::Error, "#{session.api_endpoint} is missing pusher key"
+        end
+    end
+  end
+end

data/lib/travis/client/methods.rb

@@ -0,0 +1,104 @@
+require 'travis/client'
+require 'yaml'
+
+module Travis
+  module Client
+    module Methods
+      def access_token
+        session.access_token
+      end
+
+      def access_token=(token)
+        session.access_token = token
+      end
+
+      def api_endpoint
+        session.uri
+      end
+
+      def github_auth(github_token)
+        reply = session.post_raw("/auth/github", :github_token => github_token)
+        session.access_token = reply["access_token"]
+      end
+
+      def explicit_api_endpoint?
+        @explicit_api_endpoint ||= false
+      end
+
+      def api_endpoint=(uri)
+        @explicit_api_endpoint = true
+        session.uri = uri
+      end
+
+      def repos(params = {})
+        session.find_many(Repository, params)
+      end
+
+      def repo(id_or_slug)
+        session.find_one(Repository, id_or_slug)
+      end
+
+      def build(id)
+        session.find_one(Build, id)
+      end
+
+      def job(id)
+        session.find_one(Job, id)
+      end
+
+      def artifact(id)
+        session.find_one(Artifact, id)
+      end
+
+      alias log artifact
+
+      def user
+        session.find_one(User)
+      rescue NotFound
+        raise NotLoggedIn, 'currently not logged in'
+      end
+
+      def account(name)
+        session.find_one(Account, name)
+      end
+
+      def accounts
+        session.find_many(Account, :all => true)
+      end
+
+      def broadcasts
+        session.find_many(Broadcast)
+      end
+
+      def restart(entity)
+        # btw, internally we call this reset, not restart, as it resets the state machine
+        # but we thought that would be too confusing
+        raise Error, "cannot restart a #{entity.class.one}" unless entity.restartable?
+        session.post_raw('/requests', "#{entity.class.one}_id" => entity.id)
+        entity.reload
+      end
+
+      def cancel(entity)
+        raise Error, "cannot cancel a #{entity.class.one}" unless entity.cancelable?
+        session.post_raw("/#{entity.class.many}/#{entity.id}/cancel")
+        entity.reload
+      end
+
+      def listen(*entities, &block)
+        listener = Listener.new(session)
+        listener.subscribe(*entities, &block)
+        listener.listen
+      end
+
+      def lint(body)
+        body   = body.to_yaml unless body.is_a? String
+        result = session.post_raw('/lint', 'content' => body)
+        LintResult.new(result)
+      end
+
+      def hooks
+        session.get('hooks')['hooks']
+      end
+    end
+  end
+end

data/lib/travis/client/namespace.rb

@@ -0,0 +1,85 @@
+require 'travis/client'
+
+module Travis
+  module Client
+    class Namespace < Module
+      class Curry < Module
+        attr_accessor :namespace, :type
+
+        def initialize(namespace, type)
+          @namespace, @type = namespace, type
+        end
+
+        def find_one(id = nil)
+          result = session.find_one(type, id)
+          result.curry = self
+          result
+        end
+
+        def current
+          result = session.find_one_or_many(type)
+          Array(result).each { |e| e.curry = self }
+          result
+        end
+
+        def find_many(params = {})
+          session.find_many(type, params).each do |entity|
+            entity.curry = self
+          end
+        end
+
+        alias find     find_one
+        alias find_all find_many
+
+        def clear_cache
+          session.clear_cache
+        end
+
+        def clear_cache!
+          session.clear_cache!
+        end
+
+        private
+
+          def session
+            namespace.session
+          end
+      end
+
+      include Methods
+      attr_accessor :session
+
+      def initialize(session = nil)
+        session  = Travis::Client.new(session || {}) unless session.is_a? Session
+        @session = session
+
+        Entity.subclasses.each do |subclass|
+          name = subclass.name[/[^:]+$/]
+          const_set(name, Curry.new(self, subclass))
+        end
+      end
+
+      def included(klass)
+        fix_names(klass)
+        delegate_session(klass)
+      end
+
+      private
+
+        def fix_names(klass)
+          constants.each do |name|
+            const = klass.const_get(name)
+            klass.const_set(name, const) if const == const_get(name)
+          end
+        end
+
+        def delegate_session(klass)
+          return if klass == Object or klass == Kernel
+          klass.extend(Methods)
+          namespace = self
+          klass.define_singleton_method(:session)  { namespace.session }
+          klass.define_singleton_method(:session=) { |value| namespace.session = value }
+        end
+    end
+  end
+end