octolab 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca57dcf29c979b7163dfbafb2d0c52bff63094d3
+  data.tar.gz: 06037f1b1de72dfa6684c56b895cfcfa2b11d436
+SHA512:
+  metadata.gz: 0e67e12c7b58011040acba8588e1c8e0ddd191520cd0f488862fd98ae36252d4c6b8d635fd9ec4936e7dc74c3fafbd16bfee739ffc36bf2ebe9d9e5f56ffd8f6
+  data.tar.gz: 6d9a5aaa6f974ed4c30822edb7f365e5658abeca8084cfef59b4747b19326fa325328be16fd12f59d1fbde9763e213466cb0c92cf0f21a57439d6ed9652fcfae

data/bin/octolab

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+def check_env
+  ret = true
+  env_vars = ['GITHUB_SECRET',
+              'GITHUB_TOKEN',
+              'GITLAB_TOKEN',
+              'GITLAB_CI_URL',
+              'GIT_DATA_PATH',
+              'PROCESS_UID',
+              'PROCESS_GID',
+              'LOG_DIR_PATH',
+              'LOG_WEB_AGE',
+              'LOG_WEB_SIZE',
+              'LOG_GIT_AGE',
+              'LOG_GIT_SIZE']
+  
+  puts "-" * 20
+  puts "\e[1;97mCHECKING ENVIRONMENT\e[0m"
+  puts "-" * 20 + "\n\n"
+
+  env_vars.each { |i|
+    if ENV[i].to_s !~ /^$/
+      puts sprintf("\e[1;97m%-15s\e[0m= \e[1;92m" + (i =~ /(secret|token)$/i ? "[ *** SET *** ]" : ENV[i].to_s) + "\e[0m", i)
+    else
+      puts sprintf("\e[1;97m%-15s\e[0m= \e[1;91mmissing\e[0m", i)
+      ret = false
+    end
+  }
+  
+  ret
+end
+
+case ARGV[0]
+when 'check'
+  exit 1 if !check_env
+  exit 0
+when 'start'
+  puts 'Starting OctoLab...'
+  Dir.mkdir(ENV['LOG_DIR_PATH']) unless File.exist?(ENV['LOG_DIR_PATH'])
+
+  #if ENV['RACK_ENV'] == 'production'
+  #  require 'octolab'
+  #else
+    load 'lib/octolab.rb'
+  #end
+
+  server  = 'thin'
+  host    = ENV['OCTOLAB_LISTEN'] || '0.0.0.0'
+  port    = ENV['OCTOLAB_PORT']   || '4567'
+  web_app = OctoLab.new
+
+  begin
+    Process.egid = ENV['PROCESS_GID'] if ENV['PROCESS_GID'] and Process.egid == 0
+    Process.euid = ENV['PROCESS_UID'] if ENV['PROCESS_UID'] and Process.euid == 0
+  rescue
+    STDERR.puts 'WARNING! Unable to change UID/GID: ' + $!.message
+    #exit 1
+  end
+
+  if ENV['RACK_ENV'] == 'production'
+    pid = Process.fork
+    if pid.nil? then
+      Dir.mkdir(ENV['LOG_DIR_PATH']) unless File.exist?(ENV['LOG_DIR_PATH'])
+      
+      $stdout.reopen(ENV['LOG_DIR_PATH'] + '/web.log', 'a')
+      $stdout.sync = true
+      $stderr.reopen(ENV['LOG_DIR_PATH'] + '/web.log', 'a')
+      $stderr.sync = true
+      
+      dispatch = Rack::Builder.app do
+        map '/' do
+          run web_app
+        end
+      end
+      
+      Rack::Server.start({
+      app:    dispatch,
+      server: server,
+      Host:   host,
+      Port:   port
+    })
+    else
+      if File.exists?(ENV['PID_FILE_PATH'])
+        old_pid = File.read(ENV['PID_FILE_PATH'])
+        proc_file = '/proc/' + old_pid + '/cmdline'
+        if File.exists?(proc_file)
+          cmdline = File.read(proc_file).split("\u0000").join(' ')
+          if cmdline =~ /^ruby \S+\/bin\/octolab start$/
+            puts "OctoLab is running with PID " + old_pid + '.'
+            exit 1
+          end
+        end
+      end
+  
+      File.open(ENV['PID_FILE_PATH'], 'w') { |f| f.write(pid) }
+      Process.detach(pid)
+    end
+  else
+    dispatch = Rack::Builder.app do
+      map '/' do
+        run web_app
+      end
+    end
+    
+    Rack::Server.start({
+      app:    dispatch,
+      server: server,
+      Host:   host,
+      Port:   port
+    })
+  end
+when 'stop'
+  Process.kill(15, File.read(ENV['PID_FILE_PATH']).to_i)
+  File.delete(ENV['PID_FILE_PATH'])
+  puts 'OctoLab has been stopped.'
+when 'status'
+  if File.exists?(ENV['PID_FILE_PATH'])
+    pid = File.read(ENV['PID_FILE_PATH'])
+    proc_file = '/proc/' + pid + '/cmdline'
+    if File.exists?(proc_file)
+      cmdline = File.read(proc_file).split("\u0000").join(' ')
+      if cmdline =~ /^ruby \S+\/bin\/octolab start$/
+        puts "OctoLab is running with PID " + pid + '.'
+      else
+        puts 'OctoLab is stopped, but PID file exists.'
+      end
+    else
+      puts 'OctoLab is stopped, but PID file exists.'
+    end
+  else
+    puts 'OctoLab is stopped.'
+  end
+end

data/helpers/ssh

@@ -0,0 +1,2 @@
+#!/bin/bash
+exec /usr/bin/ssh -o StrictHostKeyChecking=no -i $GIT_SSH_PATH "$@"

data/lib/octolab.rb

@@ -0,0 +1,311 @@
+require 'rubygems'
+require 'bundler'
+require 'net/http'
+require 'json'
+require 'logger'
+
+Bundler.require
+
+module WEBrick
+  class HTTPResponse
+    def create_error_page
+      @body = { :error => HTMLUtils::escape(@reason_phrase) }.to_json
+    end
+  end
+end
+
+class Logger
+  def internal(error)
+    error '[!] INTERNAL SERVER ERROR - backtrace:'
+    error error.inspect
+    error error.backtrace
+    error '[!] INTERNAL SERVER ERROR - end of backtrace.'
+  end
+end
+
+module Git
+  class Lib
+    def remote_add(name, url, opts = {})
+      arr_opts = ['add']
+      arr_opts << '-f' if opts[:with_fetch] || opts[:fetch]
+      arr_opts << '-t' << opts[:track] if opts[:track]
+      arr_opts << '--mirror=fetch'if opts[:mirror]
+      arr_opts << '--'
+      arr_opts << name
+      arr_opts << url
+
+      command('remote', arr_opts)
+    end
+  end
+end
+
+class OctoLab < Sinatra::Base
+
+  GITHUB_SECRET = ENV['GITHUB_SECRET'].to_s
+  GITHUB_TOKEN  = ENV['GITHUB_TOKEN'].to_s
+  GITLAB_TOKEN  = ENV['GITLAB_TOKEN'].to_s
+  GITLAB_CI_URL = ENV['GITLAB_CI_URL'].to_s
+  GIT_DATA_PATH = ENV['GIT_DATA_PATH'].to_s
+  PROCESS_UID   = ENV['PROCESS_UID'].to_s
+  PROCESS_GID   = ENV['PROCESS_GID'].to_s
+  LOG_DIR_PATH  = ENV['LOG_DIR_PATH'].to_s
+  LOG_WEB_AGE   = ENV['LOG_WEB_AGE'].to_s
+  LOG_WEB_SIZE  = ENV['LOG_WEB_SIZE'].to_s
+  LOG_GIT_AGE   = ENV['LOG_GIT_AGE'].to_s
+  LOG_GIT_SIZE  = ENV['LOG_GIT_SIZE'].to_s
+  ROOT_DIR      = File.realpath(__FILE__.split('/')[0..-3].join('/'))
+
+  class HTTPError < StandardError
+  end
+
+  class TriggerError < StandardError
+  end
+  
+  configure do
+    set :root, __FILE__.split('/')[0..-3].join('/')
+    set :server, 'thin'
+    set :run, true
+    set :haml, { :ugly => true }
+    set :clean_trace, true
+    enable :logging
+    
+    
+    if settings.production?
+      $log_app = Logger.new(LOG_DIR_PATH + '/app.log', LOG_WEB_AGE, LOG_WEB_SIZE)
+      $log_git = Logger.new(LOG_DIR_PATH + '/git.log', LOG_GIT_AGE, LOG_GIT_SIZE)
+      $log_app.level = Logger::DEBUG
+      $log_git.level = Logger::DEBUG
+    else
+      $log_app = Logger.new(STDOUT)
+      $log_git = Logger.new(STDOUT)
+      $log_app.level = Logger::DEBUG
+      $log_git.level = Logger::DEBUG
+    end
+  end
+
+  before do
+    @client ||= Octokit::Client.new(:access_token => GITHUB_TOKEN)
+  end
+
+  post '/events' do
+    begin
+      verify_signature(request.body.read)
+      request.body.rewind
+      payload = JSON.parse(request.body.read)
+      $log_app.debug JSON.pretty_generate(payload) if settings.development?
+      $log_app.info '[*] Received event: ' + request.env['HTTP_X_GITHUB_EVENT'] if request.env['HTTP_X_GITHUB_EVENT']
+      
+      case request.env['HTTP_X_GITHUB_EVENT']
+      when 'pull_request'
+        git_fetch_github(payload['pull_request']['base']['repo']['full_name'])
+        if payload['action'] =~ /(re)*opened/
+          ENV['OCTOLAB_COMMITS'] = (ENV['OCTOLAB_COMMITS'].to_s.split(',') + [payload['pull_request']['head']['sha']]).join(',')
+          process_pull_request(payload['pull_request'])
+        end
+      when 'push'
+        git_fetch_github(payload['repository']['full_name'])
+        process_push(payload)
+      end
+    rescue
+      $log_app.internal($!)
+      halt 500, { :error => 'Processing failed' }.to_json
+    end
+  end
+
+  post '/builds' do
+    begin
+      payload = JSON.parse(request.body.read)
+      $log_app.debug JSON.pretty_generate(payload) if settings.development?
+
+      case request.env['HTTP_X_GITLAB_EVENT']
+      when 'Build Hook'
+        local_name    = payload['project_name'].gsub(/\s\/\s/, '/')
+        commit        = payload['sha']
+        git_dir       = GIT_DATA_PATH + '/' + local_name + '.git'
+        git           = Git.open(git_dir, {:log => $log_git, :repository => git_dir, :working_directory => nil })
+        remote_name   = git.remotes.select { |i| i.name == 'github' }.first.url.split(':').last.gsub(/\.git$/, '')
+        build_id      = payload['build_id'].to_s
+        commit_status = payload['commit']['status']
+        build_status  = payload['build_status']
+        build_status  = 'failure' if payload['build_status'] == 'canceled' or payload['build_status'] == 'failed'
+        description   = 'The build is in progress...'
+        description   = 'The build succeeded!'  if build_status == 'success'
+        description   = 'The build has failed!' if build_status == 'failure'
+        options       = {
+                          :state        => build_status,
+                          :target_url   => GITLAB_CI_URL + '/' + remote_name + '/builds/' + build_id,
+                          :description  => description,
+                          :context      => 'continuous-integration/gitlab'
+                        }
+
+        $log_app.info '[*] Build status changed: ' + remote_name + ': ' + commit + ': ' + build_status
+
+        if ENV['OCTOLAB_COMMITS'].to_s.split(',').include?(commit)
+          $log_app.info '[*] Sending status update: ' + remote_name + ': ' + commit + ': ' + build_status
+          if build_status =~ /pending/
+            @client.create_status(remote_name, commit, build_status, options)
+          elsif build_status =~ /failure/ or (build_status =~ /success/ and commit_status =~ /success/)
+            @client.create_status(remote_name, commit, build_status, options)
+            ENV['OCTOLAB_COMMITS'] = ENV['OCTOLAB_COMMITS'].to_s.split(',').delete_if { |i| i == commit }.join(',')
+          end
+        end
+        
+        return
+      end
+    rescue
+      $log_app.internal($!)
+      halt 500, { :error => 'Processing failed' }.to_json
+    end
+  end
+
+  helpers do
+    def logger
+      request.logger
+    end
+    
+    def verify_signature(body)
+      signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), GITHUB_SECRET, body)
+      return halt 500, { :error => "Signatures didn't match!" }.to_json unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_HUB_SIGNATURE'])
+    end
+    
+    def git_fetch_github(full_name)
+      $log_app.info '[*] Fetching: ' + full_name
+
+      Git.configure do |config|
+        config.git_ssh = ROOT_DIR + '/helpers/ssh'
+      end
+
+      git_dir = GIT_DATA_PATH + '/' + full_name + '.git'
+      git = Git.open(git_dir, { :log => $log_git, :repository => git_dir, :working_directory => nil })
+      
+      if git.remotes.length == 0
+        git.add_remote('github', 'git@github.com:' + full_name + '.git', :mirror => true)
+      end
+      
+      git.remote('github').fetch
+    end
+    
+    def get_project(name)
+      begin
+        url           = GITLAB_CI_URL + '/api/v3/projects'
+        uri           = URI(url)
+        http          = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl  = true
+        headers       = { 'PRIVATE-TOKEN' => GITLAB_TOKEN }
+        path          = uri.path.empty? ? '/' : uri.path
+        code          = http.head(path, headers).code.to_i
+
+        if (code >= 200 && code < 300)
+          response = http.get(uri.path, headers)
+          JSON.parse(response.body).select { |i| i['path_with_namespace'] == name }.first
+        else
+          raise HTTPError, 'Error code: ' + code.to_s + ' URL: ' + url
+        end
+      rescue
+        raise $!
+      end
+    end
+    
+    def get_trigger_token(id)
+      begin
+        uri           = URI(GITLAB_CI_URL + '/api/v3/projects/' + id.to_s + '/triggers')
+        http          = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl  = true
+        headers       = { 'PRIVATE-TOKEN' => GITLAB_TOKEN }
+        path          = uri.path.empty? ? '/' : uri.path
+        code          = http.head(path, headers).code.to_i
+
+        if (code >= 200 && code < 300)
+          response = http.get(uri.path, headers)
+          res = JSON.parse(response.body).select { |i| i['deleted_at'] == nil }.first
+          if res == nil
+            raise HTTPError, 'Unable to obtain build trigger token for project id: ' + id.to_s
+          end
+          res
+        else
+          raise HTTPError, 'Error code: ' + code.to_s + ' URL: ' + url
+        end
+      rescue
+        raise $!
+      end
+    end
+    
+    def trigger_build(remote_name, ref)
+      begin
+        project       = get_project(remote_name)
+        token         = get_trigger_token(project['id'])['token']
+        url           = GITLAB_CI_URL + '/api/v3/projects/' + project['id'].to_s + '/trigger/builds'
+        uri           = URI(url)
+        response      = Net::HTTP.post_form(uri, 'token' => token, 'ref' => ref)
+        
+        if (response.code.to_i >= 200 && response.code.to_i < 300)
+          JSON.parse(response.body)
+        elsif response.code.to_i == 400
+          raise TriggerError, JSON.parse(response.body)['message']
+        else
+          raise HTTPError, 'Error code: ' + response.code.to_s + ' URL: ' + url
+        end
+      rescue
+        raise $!
+      end
+    end
+    
+    def process_pull_request(pull_request)
+      Thread.new do
+        begin
+          remote_name   = pull_request['base']['repo']['full_name']
+          commit        = pull_request['head']['sha']
+          ref           = pull_request['head']['ref']
+          build_status  = 'pending'
+          description   = 'The build is in progress...'
+          options       = {
+                          :state        => build_status,
+                          :description  => description,
+                          :context      => 'continuous-integration/gitlab'
+                        }
+
+          $log_app.info '[*] Processing pull request: ' + remote_name + ': ' + commit
+          @client.create_status(remote_name, commit, build_status, options)
+          trigger_build(remote_name, ref)
+        rescue Octokit::Unauthorized
+          $log_app.error '[!] ' + $!.message
+        rescue HTTPError
+          $log_app.error $!
+        rescue TriggerError
+          $log_app.error $!
+        rescue
+          $log_app.error '[!] Unable to process request for: ' + remote_name + ' ref: ' + ref
+          $log_app.internal($!)
+        ensure
+          build_status  = 'failure'
+          description   = 'The build has failed!'
+          options       = {
+                          :state        => build_status,
+                          :description  => description,
+                          :context      => 'continuous-integration/gitlab'
+                        }
+
+          @client.create_status(remote_name, commit, build_status, options)
+        end
+      end
+    end
+    
+    def process_push(payload)
+      Thread.new do
+        begin
+          remote_name   = payload['repository']['full_name']
+          ref           = payload['ref'].split("/").last
+          
+          trigger_build(remote_name, ref)
+        rescue HTTPError
+          $log_app.error $!
+        rescue TriggerError
+          $log_app.error $!
+        rescue
+          $log_app.error '[!] Unable to process request for: ' + remote_name + ' ref: ' + ref
+          $log_app.internal($!)
+        end
+      end
+    end   
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: octolab
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jakub Zubielik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-10 00:00:00.000000000 Z
+dependencies: []
+description: OctoLab allows to mirror GitHub repositories in GitLab and to trigger
+  build jobs on push requests.
+email: jzubielik@gmail.com
+executables:
+- octolab
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/octolab
+- helpers/ssh
+- lib/octolab.rb
+homepage: http://rubygems.org/gems/octolab
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: GitHub integration for GitLab CI.
+test_files: []