jobs-api 0.1.0

data/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/basic_pipeline.rb

@@ -0,0 +1,73 @@
+class BasicPipeline < PipelineDefinition
+  stage :first
+
+  def first
+    scm = {}
+    if event.data[:commit]
+      scm[:commit] = event.data[:commit]
+      scm[:branch] = event.data[:branch]
+      scm[:pull_request] = event.data[:pull_request]
+    else
+      latest = project.owner.client.latest_commit(project.repo_name)
+      scm[:commit] = latest[:sha]
+      scm[:branch] = latest[:branch]
+    end
+
+    create_job(
+        project: project,
+        scm: scm,
+        spec: basic_job_from_file,
+    )
+  end
+
+  def basic_job_from_file
+    ci_file = project.owner.client.file(project.repo_name, 'ci.yml')
+    if ci_file
+      spec = {}
+      build = HashWithIndifferentAccess.new(YAML.load(ci_file))
+
+      # services are copied directly
+      spec[:services] = build[:services]
+
+      # turns each key into a section
+      spec[:sections] = []
+
+      spec[:sections] << {
+          name: 'setup',
+          fail_on_err: true,
+          commands: build[:setup],
+          on_success: build[:on_success],
+          on_failure: build[:on_failure],
+      }
+
+      spec[:sections] << {
+          name: 'test',
+          fail_on_err: true,
+          commands: build[:test],
+          on_success: build[:on_success],
+          on_failure: build[:on_failure],
+      }
+
+      spec[:sections] << {
+          name: 'after',
+          fail_on_err: true,
+          commands: build[:after],
+      }
+
+      spec
+    else
+      {
+          sections: [
+              {
+                  name: 'test',
+                  fail_on_err: true,
+                  commands: ['exit 1'],
+              }
+          ]
+      }
+    end
+  end
+
+
+
+end

data/app/models/event.rb

@@ -0,0 +1,24 @@
+class Event
+  attr_accessor :name, :project, :data
+
+  def initialize(data)
+    @data = data
+    @name = data[:name]
+    @project = data[:project_id] ? Project.find(data[:project_id]) : nil
+  end
+
+  def execute
+    return nil unless project.enabled_pipelines
+
+    project.enabled_pipelines.each do |pipeline_definition|
+      if pipeline_definition.constantize.trigger_when?(self)
+        PipelineRunnerJob.perform_later(nil, self.data, pipeline_definition)
+      end
+    end
+  end
+
+  def as_json
+    data
+  end
+
+end

data/app/models/job.rb

@@ -0,0 +1,27 @@
+# Job Spec:
+# {
+#   sections: [
+#     { name: "name", on_success: [], on_failure: [], commands: [], fail_on_err: true }
+#   ],
+#   services: [
+#     { name: "", docker: { ... } }
+#   ],
+#   repo: {
+#     name: "repo",
+#     owner: "repo-owner",
+#     commit: "abcdefg",
+#     branch: "feature/x",
+#     provider: "github.com",
+#   }
+# }
+#
+class Job < ApplicationRecord
+  belongs_to :pipeline
+  has_one :project, through: :pipeline
+  after_save { pipeline.run if status_changed? }
+
+  def self.pop
+    Job.where(status: 'PENDING').limit(1).update(worker: worker).first
+  end
+
+end

data/app/models/pipeline.rb

@@ -0,0 +1,21 @@
+class Pipeline < ApplicationRecord
+  belongs_to :project, optional: true
+  has_many :jobs
+
+  def definition_class
+    @definition_class ||= definition.constantize
+  end
+
+  def status?(is)
+    status && status.upcase == is.to_s.upcase
+  end
+
+  def run(event=nil)
+    PipelineRunnerJob.perform_later(self, event)
+  end
+
+  def event
+    @event ||= Event.new(super)
+  end
+
+end

data/app/models/pipeline_definition.rb

@@ -0,0 +1,98 @@
+class PipelineDefinition
+  attr_reader :pipeline, :event
+
+  class PipelineConfigError
+  end
+
+  def self.start(event)
+    PipelineRunnerJob.perform_later(nil, event.data, self.name)
+  end
+
+  def self.trigger_when?(event)
+    true
+  end
+
+  def self.stages
+    @stages ||= []
+  end
+
+  def self.stage_options
+    @stage_options ||= {}
+  end
+
+  def self.ensure_stages
+    @ensure ||= []
+  end
+
+  def self.stage(name, opts={})
+    stages << name.to_sym
+    stage_options[name.to_sym] = opts
+  end
+
+  def self.ensure_stage(name)
+    ensure_stages << name.to_sym
+  end
+
+  def initialize(pipeline, event)
+    @pipeline = pipeline
+    @event = event
+    @job_creation_idx = 0
+  end
+
+  def create_job(key: nil, project: nil, scm: nil, spec: nil)
+    project = self.project unless project
+
+    scm = {} if scm.nil?
+    if project
+      scm[:owner] = project.repo_owner
+      scm[:name] = project.repo_name
+      scm[:provider] = project.repo_provider
+    end
+
+    @job_creation_idx += 1
+    key = "#{pipeline.definition.underscore}.#{pipeline.id}.#{stage}-#{@job_creation_idx}" unless key
+
+    Job.create!(
+        pipeline: pipeline,
+        pipeline_stage: stage,
+        status: 'QUEUED',
+        spec: spec.merge(repo: scm),
+        commit: scm[:commit],
+        branch: scm[:branch],
+        key: key,
+    )
+  end
+
+  def project=(project)
+    pipeline.update!(project_id: project.id)
+    @project = project
+  end
+
+  def project
+    @project ||= pipeline.project
+  end
+
+  def stage
+    pipeline.stage
+  end
+
+  def next
+    pipeline.run
+  end
+
+  def variables
+    @variables ||= OpenStruct.new(pipeline.variables)
+  end
+
+  def save
+    pipeline.update!(variables: variables.to_h)
+  end
+
+  def self.as_json
+    {
+        stages: stages.map { |stage| stage_options.merge(stage: stage) },
+        name: name,
+    }
+  end
+
+end

data/app/models/project.rb

@@ -0,0 +1,45 @@
+class Project < ApplicationRecord
+  belongs_to :team, optional: true
+  belongs_to :user, optional: true
+  has_many :pipelines
+  has_many :jobs, through: :pipelines
+
+  def self.add_project(user, name)
+    repo = user.client.repo(name)
+
+    found = Project.find_by(repo_id: repo[:id])
+    return found if found
+
+    project = {
+        name: repo[:name],
+        repo_provider: user.provider,
+        repo_owner: repo[:owner],
+        repo_name: repo[:name],
+        repo_id: repo[:id],
+    }
+
+    team = user.teams.find_by(provider_id: repo[:owner_id])
+    if team
+      project[:team] = team
+    else
+      project[:user] = user
+    end
+
+    create!(project)
+  end
+
+  def status
+    jobs.where(branch: 'master').last.try(:status)
+  end
+
+  def branches
+    jobs.group(:branch).limit(20).pluck(:branch).map do |branch|
+      jobs.where(branch: branch).first
+    end
+  end
+
+  def owner
+    user || team
+  end
+
+end

data/app/models/team.rb

@@ -0,0 +1,11 @@
+class Team < ApplicationRecord
+  has_many :user_teams
+  has_many :users, through: :user_teams
+  has_many :projects
+  has_many :pipelines, through: :projects
+
+  def client
+    users.first.client
+  end
+
+end

data/app/models/user.rb

@@ -0,0 +1,43 @@
+class User < ApplicationRecord
+  has_many :user_teams
+  has_many :teams, through: :user_teams
+  has_many :users, through: :teams
+  has_many :projects
+  has_many :pipelines, through: :projects
+  has_many :jobs, through: :pipelines
+
+  def self.from_omniauth(auth)
+    new_user = false
+    user = User.find_by(provider: auth.provider, provider_id: auth.uid)
+    unless user.present?
+      user = User.create!(provider: auth.provider, provider_id: auth.uid)
+      new_user = true
+    end
+
+    user.username = auth.info.nickname
+    user.email = auth.info.email
+    user.name = auth.info.name
+    user.token = auth.credentials.token
+    user.refresh_token = auth.credentials.refresh_token
+    user.save!
+
+    user.sync if new_user
+
+    user
+  end
+
+  def sync
+    client.teams.each do |team|
+      teams.create!(provider: provider, provider_id: team[:id], name: team[:name])
+    end
+  end
+
+  def client
+    if provider == 'github'
+      GithubClient.new(username, token)
+    else
+      nil
+    end
+  end
+
+end

data/app/models/user_team.rb

@@ -0,0 +1,4 @@
+class UserTeam < ApplicationRecord
+  belongs_to :user
+  belongs_to :team
+end

data/app/serializers/job_serializer.rb

@@ -0,0 +1,12 @@
+class JobSerializer < ActiveModel::Serializer
+  has_one :pipeline, if: :show_all?
+  has_one :project, if: :show_all?
+
+  attributes :id, :pipeline_id, :project_id, :pipeline_stage, :key, :status, :commit, :branch, :worker, :created_at, :updated_at
+  attribute :spec, if: :show_all?
+
+  def show_all?
+    instance_options[:show_all]
+  end
+
+end

data/app/serializers/pipeline_serializer.rb

@@ -0,0 +1,3 @@
+class PipelineSerializer < ActiveModel::Serializer
+  attributes Pipeline.column_names
+end

data/app/serializers/project_serializer.rb

@@ -0,0 +1,4 @@
+class ProjectSerializer < ActiveModel::Serializer
+  attributes Project.column_names
+  attributes :status
+end

data/app/serializers/team_serializer.rb

@@ -0,0 +1,3 @@
+class TeamSerializer < ActiveModel::Serializer
+  attributes Team.column_names
+end

data/app/serializers/user_serializer.rb

@@ -0,0 +1,3 @@
+class UserSerializer < ActiveModel::Serializer
+  attributes :id, :name, :provider, :provider_id, :email, :username, :created_at, :updated_at
+end

data/app/views/layouts/mailer.html.erb

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/app/views/layouts/mailer.text.erb

@@ -0,0 +1 @@
+<%= yield %>

data/config/application.rb

@@ -0,0 +1,37 @@
+require_relative 'boot'
+
+require "rails"
+# Pick the frameworks you want:
+require "active_model/railtie"
+require "active_job/railtie"
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+require "action_cable/engine"
+# require "sprockets/railtie"
+require "rails/test_unit/railtie"
+
+require "./lib/jobs_api"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module JobsApi
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Only loads a smaller set of middleware suitable for API only apps.
+    # Middleware like session, flash, cookies can be added back manually.
+    # Skip views, helpers and assets when generating a new resource.
+    config.api_only = true
+
+    # middleware required by omniauth
+    config.middleware.use Rack::Session::Cookie, secret: ENV['SECRET_KEY_BASE'] || 'secret'
+
+    config.active_job.queue_adapter = :delayed_job
+  end
+end