jobs-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: faf9a8ab0e8465b9b83f9f5bb3244afd9727a86f
+  data.tar.gz: 1a88b1bf4cc7990fb42b33e22b36d2b13b742f47
+SHA512:
+  metadata.gz: ff226b858ccdb44baf0c63fe6966eb14e13acb6075c95c2ff200c443e99b47171a4c769fa264c18e6a7fb4aa00ab87b56d816be706276d354c6656d73e3cfa55
+  data.tar.gz: 8e6350809e1d974eb47e6f25508518d2722dcf114ab72550bebbf596fed24636cba7a5dd9f8471ac32ab717fe44adebce5f4ee0059f04c4c27fa5e8804ad74a6

data/README.md

@@ -0,0 +1,55 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+Endpoints
+
+Jobs:
+
+GET  `/current_user`    => current user
+GET  `/users`           => list all users
+GET  `/teams`           => list all teams
+GET  `/teams/:id/users` => all users that can access a team
+
+POST `/jobs`            => create an untracked job
+GET  `/jobs/pop`        => pop a job from the queue
+PUT  `/jobs/:id/status` => update a job's status
+
+POST `/events`          => enqueue an event for processing
+
+GET  `projects`        => retrieve a list of all projects. by team, by user or all
+GET  `projects/:id`    => get a single project
+DEL  `projects/:id`    => delete a project
+PUT  `projects/:id`    => update a project
+POST `projects`        => create a freestyle project
+GET  `projects/:id/branches` => retrieve a list of branches with a build status for a project, show all branches option
+GET  `projects/:id/jobs`     => retrieve a list of the latest jobs for a project
+
+GET  `/pipelines`                       => list all pipeline definitions by registry with latest status.
+GET  `/pipelines/:name/instances`       => list all pipeline instances for this definition
+GET  `/pipelines/:name/instances/:id`   => get a specific pipeline, more information, status and jobs
+
+GET  `/libraries`       => list all installed libraries known
+POST `/libraries`       => install a library
+DEL  `/libraries/:name` => uninstall a library

data/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/app/channels/application_cable/connection.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/app/clients/bitbucket_client.rb

@@ -0,0 +1,31 @@
+class BitbucketClient
+
+  def initialize(token)
+    @token = token
+  end
+
+  def teams
+    req(:get, '2.0/user/orgs').map do |org|
+      {id: org['id'], name: org['name']}
+    end
+  end
+
+  def req(method, url, params={})
+    res = conn.send(method, url, params)
+    JSON.parse(res.body)
+  end
+
+  def refresh
+
+  end
+
+  def conn
+    @github ||= Faraday.new(url: 'https://api.bitbucket.org/') do |faraday|
+      faraday.request  :url_encoded             # form-encode POST params
+      faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+      faraday.response :logger                  # log requests to STDOUT
+      faraday.headers['Authorization'] = "Bearer #{@token}"
+    end
+  end
+
+end

data/app/clients/github_client.rb

@@ -0,0 +1,100 @@
+class GithubClient
+
+  def initialize(username, token)
+    @token = token
+    @username = username
+  end
+
+  def teams
+    req(:get, 'user/orgs').map do |org|
+      {id: org['id'], name: org['login']}
+    end
+  end
+
+  def repo(repo)
+    res = req(:get, "/repos/#{@username}/#{repo}")
+
+    if res['source']
+      {
+          id: res['source']['id'],
+          name: res['source']['name'],
+          owner: res['source']['owner']['login'],
+          owner_id: res['source']['owner']['id'],
+      }
+    else
+      {
+          id: res['id'],
+          name: res['name'],
+          owner: res['owner']['login'],
+          owner_id: res['owner']['id'],
+      }
+    end
+  end
+
+  def latest_commit(repo)
+    res = req(:get, "/repos/#{@username}/#{repo}/git/refs")
+    return nil if res.length == 0
+
+    res.each do |ref|
+      if ref['ref'].split('/')[1] == 'heads'
+        return {
+            sha: ref['object']['sha'],
+            branch: ref['ref'].split('refs/heads/')[-1],
+        }
+      end
+    end
+
+    nil
+  end
+
+  def branches(repo)
+    req_cached(:get, "/repos/#{@username}/#{repo}/branches").map do |branch|
+      {name: branch['name'], commit: branch['commit']['sha']}
+    end
+  end
+
+  def file(repo, path)
+    res = req(:get, "/repos/#{@username}/#{repo}/contents/#{path}")
+    Base64.decode64(res['content']) if res['content']
+  end
+
+  def register_webhook(repo)
+    post_json("/repos/#{@username}/#{repo}/hooks", {
+        name: 'web',
+        active: true,
+        events: %w(push pull_request),
+        config: {
+            url: "#{Config.api_root_url}/hooks/github",
+            content_type: 'json'
+        }
+    })
+  end
+
+  def req(method, url, params={})
+    puts "#{method}  https://api.github.com/#{url}"
+    res = conn.send(method, url, params)
+    JSON.parse(res.body)
+  end
+
+  def post_json(url, payload)
+    res = conn.post do |req|
+      req.url url
+      req.headers['Content-Type'] = 'application/json'
+      req.body = JSON.generate(payload)
+    end
+    JSON.parse(res.body)
+  end
+
+  def req_cached(method, url, params={})
+    Rails.cache.fetch("github-api:#{method}.#{url}", expires_in: 1.day) { req(method, url, params) }
+  end
+
+  def conn
+    @github ||= Faraday.new(url: 'https://api.github.com/') do |faraday|
+      faraday.request  :url_encoded             # form-encode POST params
+      faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+      faraday.headers['Authorization'] = "token #{@token}"
+    end
+  end
+
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,23 @@
+class ApplicationController < ActionController::API
+  serialization_scope :view_context
+
+  protected
+
+  def current_user
+    # @current_user ||= User.find_by(id: session[:user_id])
+    @current_user ||= User.first
+  end
+
+  def current_entity
+    @current_entity ||= begin
+      if params[:team_id]
+        current_user.teams.find(params[:team_id])
+      elsif params[:user_id]
+        current_user.users.find(params[:user_id])
+      else
+        current_user
+      end
+    end
+  end
+
+end

data/app/controllers/events_controller.rb

@@ -0,0 +1,12 @@
+class EventsController < ApplicationController
+
+  def create
+    event = Event.new(
+        project_id: params[:project_id],
+        name: params[:name],
+    )
+    event.execute
+    render json: event
+  end
+
+end

data/app/controllers/hooks_controller.rb

@@ -0,0 +1,32 @@
+class HooksController < ApplicationController
+
+  def github
+
+    event = {}
+    if params[:ref]
+
+      event[:name] = 'git:push'
+      if params[:ref].split('/')[1] == 'heads'
+        event[:branch] = params[:ref].split('refs/heads/')[-1]
+      end
+
+      event[:commit] = params[:after]
+      event[:project_id] = Project.find_by(repo_id: params[:repository][:id], repo_provider: 'github').try(:id)
+
+    elsif params[:pull_request]
+
+      event[:name] = 'git:pull_request'
+      event[:commit] = params[:pull_request][:head][:sha]
+      event[:branch] = params[:pull_request][:head][:ref]
+      event[:project_id] = Project.find_by(repo_id: params[:pull_request][:head][:repo][:id], repo_provider: 'github').try(:id)
+      event[:pull_request] = true
+
+    end
+
+    evt = Event.new(event)
+    evt.execute
+
+    render plain: 'OK'
+  end
+
+end

data/app/controllers/jobs_controller.rb

@@ -0,0 +1,20 @@
+class JobsController < ApplicationController
+
+  def pop
+    render json: Job.pop
+  end
+
+  def index
+    render json: current_entity.jobs
+  end
+
+  def show
+    render json: current_entity.jobs.find(params[:id]), show_all: true
+  end
+
+  def update_status
+    Job.find_by!(key: params[:id]).update!(status: params[:status])
+    render plain: 'OK'
+  end
+
+end

data/app/controllers/pipelines_controller.rb

@@ -0,0 +1,11 @@
+class PipelinesController < ApplicationController
+
+  def index
+    render json: current_entity.pipelines
+  end
+
+  def show
+    render json: current_entity.pipelines.find(params[:id])
+  end
+
+end

data/app/controllers/projects_controller.rb

@@ -0,0 +1,39 @@
+class ProjectsController < ApplicationController
+
+  def index
+    render json: current_user.projects
+  end
+
+  def create
+    render json: Project.add_project(current_user, params[:name])
+  end
+
+  def show
+    render json: current_user.projects.find(params[:id])
+  end
+
+  def update
+    project = current_user.projects.find(params[:id])
+    project.update!(safe_params)
+    render json: project
+  end
+
+  def destroy
+    render json: current_user.projects.find(params[:id]).destroy!
+  end
+
+  def jobs
+    render json: current_user.projects.find(params[:project_id]).jobs
+  end
+
+  def branches
+    render json: current_user.projects.find(params[:project_id]).branches, root: :jobs
+  end
+
+  protected
+
+  def safe_params
+    params.require(:project).permit!
+  end
+
+end

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,17 @@
+class SessionsController < ApplicationController
+
+  def create
+    user = User.from_omniauth(request.env['omniauth.auth'])
+    session[:user_id] = user.id
+    redirect_to Config.ui_root_url
+  end
+
+  def destroy
+    session[:user_id] = nil
+  end
+
+  def failure
+    redirect_to Config.ui_root_url, failed: true
+  end
+
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,15 @@
+class UsersController < ApplicationController
+
+  def current
+    render json: current_user
+  end
+
+  def index
+    render json: current_entity.users
+  end
+
+  def teams
+    render json: current_user.teams
+  end
+
+end

data/app/jobs/application_job.rb

@@ -0,0 +1,2 @@
+class ApplicationJob < ActiveJob::Base
+end

data/app/jobs/pipeline_runner_job.rb

@@ -0,0 +1,106 @@
+class PipelineRunnerJob < ApplicationJob
+  attr_accessor :event, :pipeline, :definition
+
+  queue_as :default
+
+  # receives a pipeline as it's argument
+  def perform(pipeline_object, event=nil, definition_name=nil)
+
+    if event
+      event = Event.new(event)
+      # this is the starting point for the pipeline if the event is present
+      raise Exception.new('Wrong code path') if pipeline_object.present? || definition_name.nil?
+
+      unless definition_name.constantize.trigger_when?(event)
+        return
+      end
+
+      pipeline_object = Pipeline.create!(
+          project: event.project,
+          status: 'STARTING',
+          event: event.data,
+          definition: definition_name,
+      )
+    end
+
+    self.pipeline = pipeline_object
+    self.definition = pipeline.definition_class.new(pipeline, event)
+    self.event = event || pipeline.event
+
+    if pipeline.status?(:failed) || pipeline.status?(:complete)
+      # pipeline has already been marked as failing or complete
+      return
+    end
+
+    if last_stage_failed?
+      # fail the pipeline if it's failing
+      update_status :failed
+      return
+    end
+
+    if last_stage_pending?
+      # nothing to do here, still waiting on some methods to come through
+      return
+    end
+
+    # if we've gotten here all the checks are passing and we can move onto the next stage
+
+    unless next_stage.present?
+      # no next stage, pipeline is complete
+      complete_pipeline
+      return
+    end
+
+    # run the next stage
+    pipeline.update!(stage: next_stage, status: 'PENDING')
+    execute(next_stage)
+
+    unless last_stage_pending?
+      # no jobs were created during the last stage, therefore everything is done!
+      complete_pipeline
+    end
+  end
+
+  def execute(this_stage)
+    begin
+      definition.send(this_stage)
+    rescue Exception => e
+      pipeline.update!(status: 'ERROR', error: e.message)
+      raise e
+    ensure
+      pipeline.save
+    end
+  end
+
+  def complete_pipeline
+    definition.class.ensure_stages.each do |ensured_stage|
+      # will fail the job if an error is raised
+      execute(ensured_stage)
+    end
+    update_status :complete
+  end
+
+  def next_stage
+    @next_stage ||= begin
+      if pipeline.stage
+        cur_idx = definition.class.stages.find_index { |st| st == pipeline.stage.downcase.to_sym }
+        definition.class.stages[cur_idx + 1]
+      else
+        definition.class.stages[0]
+      end
+    end
+  end
+
+  def update_status(status)
+    pipeline.update!(status: status.to_s.upcase)
+  end
+
+  def last_stage_failed?
+    Job.where('pipeline_id = ? AND pipeline_stage = ? AND (status = "FAILED" OR status = "CANCELLED")', pipeline.id, pipeline.stage).exists?
+  end
+
+  def last_stage_pending?
+    Job.where('pipeline_id = ? AND pipeline_stage = ? AND (status = "QUEUED" OR status = "PENDING")', pipeline.id, pipeline.stage).exists?
+  end
+
+end