travis-akerl 1.8.9

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
+      time :started_at, :finished_at
+
+      alias allow_failure? allow_failure
+
+      # @!parse attr_reader :commit, :repository, :build
+      has :commit, :repository, :build, :log
+
+      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,183 @@
+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 = []
+      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) } }
+        socket.connect
+      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

data/lib/travis/client/not_loadable.rb

@@ -0,0 +1,13 @@
+module Travis
+  module Client
+    module NotLoadable
+      def missing?(attribute)
+        false
+      end
+
+      def complete?
+        true
+      end
+    end
+  end
+end

data/lib/travis/client/repository.rb

@@ -0,0 +1,224 @@
+require 'travis/client'
+require 'travis/tools/ssl_key'
+
+module Travis
+  module Client
+    class Repository < Entity
+      class Key
+        attr_reader :to_s, :fingerprint
+
+        def initialize(data, fingerprint)
+          @to_s = data
+          @fingerprint = fingerprint
+        end
+
+        def encrypt(value)
+          encrypted = to_rsa.public_encrypt(value)
+          Base64.encode64(encrypted).gsub(/\s+/, "")
+        end
+
+        def to_rsa
+          Tools::SSLKey.public_rsa_key(to_s)
+        end
+
+        def to_ssh
+          Tools::SSLKey.rsa_ssh(to_rsa)
+        end
+
+        def ==(other)
+          other.to_s == self
+        end
+      end
+
+      include States
+      preloadable
+
+      # @!parse attr_reader :slug, :description
+      attributes :slug, :active, :private, :admin, :description, :last_build_id, :last_build_number, :last_build_state, :last_build_duration, :last_build_started_at, :last_build_finished_at, :github_language
+      inspect_info :slug
+
+      time :last_build_finished_at, :last_build_started_at
+
+      one  :repo
+      many :repos
+      aka  :repository, :permissions, :admin, :pull, :push, :hooks
+
+      has_singleton :ssh_key
+
+      def initialize(*)
+        super
+        attributes['active'] = attributes['private'] = attributes['admin'] = nil
+      end
+
+      def public_key
+        attributes["public_key"] ||= begin
+          payload = session.get_raw("/repos/#{id}/key")
+          Key.new(payload.fetch('key'), payload['fingerprint'])
+        end
+      end
+
+      def name
+        slug[/[^\/]+$/]
+      end
+
+      def public_key=(key)
+        # ignored
+      end
+
+      alias key  public_key
+      alias key= public_key=
+
+      def encrypt(value)
+        key.encrypt(value)
+      end
+
+      # @!parse attr_reader :last_build
+      def last_build
+        return unless last_build_id
+        attributes['last_build'] ||= begin
+          last_build               = session.find_one(Build, last_build_id)
+          last_build.number        = last_build_number
+          last_build.state         = last_build_state
+          last_build.duration      = last_build_duration
+          last_build.started_at    = last_build_started_at
+          last_build.finished_at   = last_build_finished_at
+          last_build.repository_id = id
+          last_build
+        end
+      end
+
+      def builds(params = nil)
+        return each_build unless params
+        session.find_many(Build, params.merge(:repository_id => id))
+      end
+
+      def build(number)
+        builds(:number => number.to_s).first
+      end
+
+      def recent_builds
+        builds({})
+      end
+
+      def last_on_branch(name = nil)
+        return branch(name) if name
+        attributes['last_on_branch'] ||= session.get('branches', :repository_id => id)['branches']
+      end
+
+      def branches
+        last_on_branch.map { |b| { b.commit.branch => b } }.inject(:merge)
+      end
+
+      def branch(name)
+        attributes['branches']       ||= {}
+        attributes['branches'][name] ||= begin
+          build = attributes['last_on_branch'].detect { |b| b.commit.branch == name.to_s } if attributes['last_on_branch']
+          build || session.get("/repos/#{id}/branches/#{name}")['branch']
+        end
+      end
+
+      def each_build(params = nil, &block)
+        return enum_for(__method__, params) unless block_given?
+        params ||= {}
+        chunk = builds(params)
+        until chunk.empty?
+          chunk.each(&block)
+          number = chunk.last.number
+          chunk  = number == '1' ? [] : builds(params.merge(:after_number => number))
+        end
+        self
+      end
+
+      def job(number)
+        build_number = number.to_s[/^\d+/] or return nil
+        build        = build(build_number) or return nil
+        job          = build.jobs.detect { |j| j.number == number } if number != build_number
+        job        ||= build.jobs.first if build and build.jobs.size == 1
+        job
+      end
+
+      def set_hook(flag)
+        result = session.put_raw('/hooks/', :hook => { :id => id, :active => flag })
+        result['result']
+      end
+
+      def disable
+        set_hook(false)
+      end
+
+      def enable
+        set_hook(true)
+      end
+
+      def pusher_channels
+        attributes['pusher_channels'] ||= if session.private_channels?
+          ["user-#{session.user.id}", "repo-#{id}"]
+        else
+          ["common"]
+        end
+      end
+
+      def member?
+        session.user.repositories.include? self
+      end
+
+      def owner_name
+        slug[/^[^\/]+/]
+      end
+
+      def owner
+        session.account(owner_name)
+      end
+
+      def requests
+        attributes['requests'] ||= session.find_many(Request, :repository_id => id)
+      end
+
+      def settings
+        attributes['settings'] ||= begin
+          settings = session.get("/repos/#{id}/settings")['settings']
+          settings.repository = self
+          settings
+        end
+      rescue Travis::Client::NotFound
+        raise Travis::Client::Error, "not allowed to access settings"
+      end
+
+      def caches(params = {})
+        session.get("/repos/#{id}/caches", params)['caches']
+      end
+
+      def delete_caches(params = {})
+        session.delete("/repos/#{id}/caches", params)['caches']
+      end
+
+      def active?
+        # TODO remove once active is properly synced and exposed by api
+        return active unless active.nil?
+        last_build_id?
+      end
+
+      def admin?(user = session.user)
+        user.admin_access? self
+      end
+
+      def push?(user = session.user)
+        user.push_access? self
+      end
+
+      def pull?(user = session.user)
+        user.pull_access? self
+      end
+
+      def env_vars
+        attributes['env_vars'] ||= EnvVar::List.new(self)
+      end
+
+      private
+
+        def state
+          last_build_state
+        end
+    end
+  end
+end