perkins 0.0.1

data/lib/perkins/repo.rb

@@ -0,0 +1,145 @@
+require "git"
+module Perkins
+  class Repo < ActiveRecord::Base
+    attr_accessor :git
+    attr_accessor :new_commit, :runner
+
+    has_many :build_reports, class_name: 'Perkins::BuildReport'
+    serialize :github_data, ActiveSupport::HashWithIndifferentAccess
+
+    scope :from_github, ->{where(cached: true)}
+    scope :added, ->{where(cached: false)}
+
+    DEFAULT_DIR = "/tmp/"
+
+    def self.add_from_github(id)
+      github_repo  = synced_records.find_by(gb_id: id.to_i)
+      store_from_github(github_repo)
+    end
+
+    def self.sync_github_repos(user)
+      user.api.repos.each do |repo|
+        self.sync_github_repo(repo)
+      end
+    end
+
+    def self.sync_github_repo(r)
+      return if Repo.where(gb_id: r[:id]).any?
+      repo = Repo.new
+      repo.github_data = r.to_attrs.with_indifferent_access
+      repo.cached = true
+      repo.url    = r[:clone_url]
+      repo.name   = r[:full_name]
+      repo.gb_id  = r[:id]
+      repo.working_dir = DEFAULT_DIR
+      repo.save
+    end
+
+    def self.synced_records
+      self.from_github
+    end
+
+    def self.store_from_github(repo)
+      repo
+      repo.working_dir = DEFAULT_DIR #this should be configurable from app
+      repo.cached = false
+      repo.save
+    end
+
+    def self.initialize_from_store(opts)
+      repo = Repo.new
+      repo.url = opts["github_data"]["ssh_url"]
+      repo.name = opts["name"]
+      repo.github_data = opts["github_data"]
+      repo.gb_id = opts["github_data"]["id"]
+      repo.working_dir = DEFAULT_DIR #this should be configurable from app
+      repo
+    end
+
+    def load_git
+      clone_or_load
+    end
+
+    def clone_or_load
+      if exists?
+        open
+      else
+        ssh_url = self.github_data["ssh_url"]
+        g = Git.clone(ssh_url, name, :path => working_dir)
+        open
+      end
+    end
+
+    def open
+      self.git = Git.open(local_path)  # :log => Logger.new(STDOUT)
+      build_runner_config(self.check_config_existence) if self.check_config_existence
+    end
+
+    def check_config_existence
+      config = self.git.chdir{
+        if File.exists?(".travis.yml")
+          config = Travis::Yaml.parse( File.open(".travis.yml").read )
+        else
+          config = Travis::Yaml.new
+        end
+        config
+      }
+      config
+    end
+
+    def exists?
+      File.exists?(local_path)
+    end
+
+    def local_path
+      self.working_dir + self.name.to_s
+    end
+
+    def branches
+      self.git.branches.map(&:name)
+    end
+
+    #http://docs.travis-ci.com/user/build-configuration/#The-Build-Matrix
+    def build_runner_config(config)
+      runner = Runner.new()
+      runner.config = config
+      runner.repo = self
+      self.branch = runner_branch
+      self.runner = runner
+    end
+
+    def runner_branch
+      case self.branch
+      when :all
+        self.branches
+      when nil
+        ["master"]
+      else
+        self.branches.include?(self.branch) ? [self.branch] : ["master"]
+      end
+    end
+
+    def add_commit(sha, branch)
+      if runner_branch.include?(branch)
+        @new_commit = Perkins::Commit.new(sha, self)
+        @new_commit.branch = branch
+        enqueue_commit(@new_commit)
+      else
+        puts "skipping commit from branch #{branch}"
+      end
+    end
+
+    def enqueue_commit(commit)
+      $redis.publish("commits", {id: self.id.to_s, name: self.name , sha: commit.sha, branch: commit.branch}.to_json)
+    end
+
+    def http_url
+      new_url = self.url.include?("http") ? self.url : self.url.gsub(":", "/")
+      new_url.gsub!("git@", "https://")
+      new_url.gsub!(".git", "")
+      new_url
+    end
+
+  end
+
+end

data/lib/perkins/runner.rb

@@ -0,0 +1,124 @@
+
+module Perkins
+  class Runner
+
+    attr_accessor :repo, :command, :config, :sha, :branch
+    attr_reader :build_time, :duration, :response, :status, :current_build
+
+    def exec(cmd)
+      result = run_script(cmd)
+      puts result
+      #result = `bash #{cmd} 2>&1`.chomp
+      #result = `go run #{ROOT_PATH + '/lib/perkins/build/runner.go'} -cmd="#{cmd}"`.chomp
+      process_status = $?
+
+      if successful_command?(process_status) || config_command_with_empty_value?(result,process_status)
+        @response = result
+        @status = true
+        return result
+      else
+        @response = result
+        @status = false
+        #raise "command failed"
+      end
+    end
+
+
+    def run_script(source)
+      script = File.expand_path(
+        "~/.perkins/.build/#{repo.name}/travis-build-#{sha}" #<< stages.join('-')
+      )
+      FileUtils.mkdir_p(File.dirname(script))
+      File.open(script, 'w') { |f| f.write(source) }
+      FileUtils.chmod(0755, script)
+      Bundler.with_clean_env{
+        `bash #{script} 2>&1`.chomp
+      }
+    end
+
+    def run(sha)
+
+      self.sha = sha
+      start_build
+      script = Perkins::Build::script(config, repo)
+      sh = script.compile
+      repo.git.chdir do
+        git_update(sha)
+        set_build_stats do
+          puts "perform build"
+          self.exec(sh)
+        end
+      end
+      store_report
+      stop_build
+    end
+
+    def start_build
+      #self.update_attributes(status: true)
+      @running = true #self.status
+      #$redis.set("#{repo.name}:running", true)
+    end
+
+    def stop_build
+      #self.update_attributes(status: false)
+      @running = false #self.status
+      #redis.set("#{repo.name}:running", false)
+    end
+
+    def set_build_stats(&block)
+      up = Time.now
+      #call the command itself
+      block.call
+      down = Time.now
+      @build_time = down
+      @duration = down - up
+    end
+
+    def running?
+      #repo.running?
+      @running
+    end
+
+    def successful_command?(process_status)
+      process_status.exitstatus.to_i == 0
+    end
+
+    def config_command_with_empty_value?(result, process_status)
+      process_status.exitstatus.to_i == 1 && result.empty?
+    end
+
+    def working_dir
+      repo.git.dir.path
+    end
+
+    def git_update(branch)
+      #`git fetch origin && git reset --hard #{sha}`
+      puts "git fetch & reset to #{sha}"
+      repo.git.fetch()
+      repo.git.reset_hard(sha)
+    end
+
+    def to_report
+      {id:  SecureRandom.hex ,
+      build_time: self.build_time ,
+      duration: self.duration,
+      response: self.response,
+      status: self.status,
+      sha: self.sha,
+      branch: self.branch}
+    end
+
+    def store_report
+      r = Perkins::BuildReport.new(self.to_report)
+      #return if report.keys.detect{|o| report[o].to_s == "" }
+      #builds_to_save = get_builds << self.to_report
+      #$redis.set("#{repo.name}:builds", builds_to_save.to_json )
+      repo.build_reports << r
+    end
+
+    def get_builds
+      repo.build_reports
+    end
+
+  end
+end

data/lib/perkins/server.rb

@@ -0,0 +1,314 @@
+require 'sinatra/base'
+require 'sinatra/activerecord'
+#require 'sinatra/reloader' #if ENV['RACK_ENV'] == "development"
+require 'pry'
+require 'json'
+require 'haml'
+require 'sprockets'
+require 'coffee_script'
+require "sass"
+require "rdiscount"
+require "perkins/auth/github"
+
+module Perkins
+
+  class Assets < Sinatra::Base
+
+    configure do
+      set :assets, (Sprockets::Environment.new { |env|
+        env.append_path(settings.root + "/assets/images")
+        env.append_path(settings.root + "/assets/javascripts")
+        env.append_path(settings.root + "/assets/stylesheets")
+        # compress everything in production
+        if ENV["RACK_ENV"] == "production"
+          env.js_compressor  = YUI::JavaScriptCompressor.new
+          env.css_compressor = YUI::CssCompressor.new
+        end
+      })
+    end
+
+    get "/assets/app.js" do
+      content_type("application/javascript")
+      settings.assets["app.js"]
+    end
+
+    get "/assets/app.css" do
+      content_type("text/css")
+      settings.assets["app.css"]
+    end
+
+    %w{jpg png}.each do |format|
+      get "/assets/:image.#{format}" do |image|
+        content_type("image/#{format}")
+        settings.assets["#{image}.#{format}"]
+      end
+    end
+
+    get "/assets/:image.svg" do |image|
+      content_type("image/svg+xml")
+      settings.assets["#{image}.svg"]
+    end
+
+  end
+
+  class Server < Sinatra::Application
+
+    attr_reader :app
+    set server: 'thin', connections: []
+    set :sessions, true
+    set :foo, 'bar'
+    enable :sessions
+    #set :environment, :production
+    set :session_secret, '*&(^B234'
+
+    use Perkins::Assets
+
+    register Perkins::Auth::Github
+
+    get '/' do
+      authenticate!
+      haml :index , locals: default_data
+    end
+
+    get '/config' do
+      settings.perkins_application.to_json
+    end
+
+    get '/repos/sync' do
+      @github_repos = build_data
+    end
+
+    post '/repos/receiver' do
+      #NEEDS VALIDATIONS
+      payload = JSON.parse request.body.read
+      repo = Perkins::Repo.added.find_by(gb_id: payload["repository"]["id"])
+      repo.load_git
+
+      pushed_branch = payload["ref"].split('/').last
+      repo.add_commit(payload["after"], pushed_branch)
+      #binding.pry
+      "received post #{payload}"
+    end
+
+    get '/repos/add/:id' do
+      #ADD REPO HERE
+      repo = github_user.api.repo(params[:id].to_i)
+      Repo.sync_github_repo(repo)
+      r = Repo.add_from_github(params[:id])
+      r.to_json
+      redirect "/me"
+    end
+
+    get '/repos/:login/:name' do
+      repo = find_repo(params)
+      record = repo.build_reports.last
+      haml :"repos/repo" , locals: {repo: repo, build: record }
+    end
+
+    get '/repos/:login/:name/builds' do
+      repo = find_repo(params)
+      haml :builds , locals: {repo: repo, builds: repo.build_reports }
+    end
+
+    get '/repos/:login/:name/builds/:build_id' do
+      repo = find_repo(params)
+      record = repo.build_reports.find(params[:build_id])
+
+      haml :"repos/repo" , locals: {repo: repo, build: record }
+    end
+
+    get '/repos/:login/:name/run_commit' do
+      repo = find_repo(params)
+      sha = repo.git.log.map(&:sha).first
+      repo.add_commit(sha, "master")
+      redirect "/repos/#{repo.name}"
+    end
+
+    get '/repos/:login/:name/config' do
+      repo = find_repo(params)
+      #find by id
+      hook = github_user.api.hooks("#{repo.name}").detect{|o| o[:name] == "web"}
+
+      haml :"repos/config" , locals: {repo: repo, hook: hook}
+    end
+
+    post '/repos/:login/:name/add_hook' do
+      repo = find_repo(params)
+      hook = github_user.api.hooks("#{repo.name}").detect{|o| o[:name] == "web"}
+      if hook.present?
+        res = github_user.api.edit_hook(
+          repo.name,
+          hook["id"],
+          'web',
+          {:url => params[:webhook_url], :content_type => 'json'},
+          {:active => true}
+        )
+      else
+        res = github_user.api.create_hook(
+          repo.name,
+          'web',
+          { :url => params[:webhook_url], :content_type => 'json'},
+          { :events => ['push'], :active => true}
+        )
+      end
+      redirect "/repos/#{repo.name}/config"
+    end
+
+    get '/repos/:login/:name/builds/:build_id/restart' do
+      repo = find_repo(params)
+      record = repo.build_reports.find(params[:build_id])
+      repo.add_commit(record['sha'], record['branch'])
+      redirect "/repos/#{repo.name}"
+    end
+
+    get '/stream', provides: 'text/event-stream' do
+      stream :keep_open do |out|
+        settings.connections << out
+        out.callback { settings.connections.delete(out) }
+      end
+    end
+
+    post '/sse' do
+      settings.connections.each { |out| out << "data: #{params[:msg]}\n\n" }
+      204 # response without entity body
+    end
+
+    get '/me' do
+      authenticate!
+      #binding.pry
+      #repos = github_repos
+      haml :profile, locals: { user: github_user.api }
+      #haml :"repos/github", locals: {repos: repos}
+      #"Hello There, #{github_user.name}! You have access to the #{params['id']} organization."
+    end
+
+    get '/myrepos' do
+      authenticate!
+      repos = github_user.api.repos
+      haml :"repos/github", locals: { user: github_user.api, repos: repos }
+    end
+
+    get '/orgs/:id' do
+      github_organization_authenticate!(params['id'])
+      #"Hello There, #{github_user.name}! You have access to the #{params['id']} organization."
+      org  = github_user.api.organization(params['id'])
+      orgs = github_user.api.orgs
+      repos = github_user.api.org_repos(params["id"])
+      haml :orgs, locals: { org: org, orgs: orgs, repos: repos }
+    end
+
+    get '/publicized_orgs/:id' do
+      github_publicized_organization_authenticate!(params['id'])
+      "Hello There, #{github_user.name}! You are publicly a member of the #{params['id']} organization."
+    end
+
+    get '/teams/:id' do
+      github_team_authenticate!(params['id'])
+      "Hello There, #{github_user.name}! You have access to the #{params['id']} team."
+    end
+
+    get '/logout' do
+      logout!
+      redirect 'https://github.com'
+    end
+
+    def initialize(*args)
+      super
+      puts "Start Perkins server"
+      #check_project
+      #@app = Perkin.new(options.project_path)
+    end
+
+    def github_repos
+      @github_repos ||= persisted_repos.any? ? persisted_repos : build_data
+    end
+
+    def build_data
+      Repo.sync_github_repos(github_user)
+      redirect "/me"
+    end
+
+    def persisted_repos
+      Repo.synced_records
+    end
+
+    def find_repo(params)
+      id = "#{params[:login]}/#{params[:name]}"
+      repo = Repo.find_by(name: id)
+      repo.load_git
+      repo
+    end
+
+    def self.start(config_file, options)
+
+      options = options.dup
+      ENV['RACK_ENV'] = options.delete("e")
+
+      app = eval(File.open(config_file).read)
+      self.start_listener(app)
+
+      set :perkins_application, app
+      set :github_options, {
+        :scopes => "admin:repo_hook,repo,user:email",
+        :secret => app.github_client_secret,
+        :client_id => app.github_client_id,
+      }
+
+      register Sinatra::ActiveRecordExtension
+
+      configure :development do
+        #register Sinatra::Reloader
+        #set :database, 'sqlite:///db/development.sqlite3'
+      end
+
+      configure :production do
+        #set :database, 'sqlite:///db/productions.sqlite3'
+      end
+
+      configure :test do
+        #set :database, 'sqlite:///db/test.sqlite3'
+      end
+
+      Perkins::Server.run! options
+    end
+
+    def self.start_listener(app_config)
+      fork do
+        listener = ::Perkins::Listener.new
+        listener.app = app_config
+        listener.run!
+      end
+    end
+
+    ##use in rack
+    ##And a corresponding config.ru:
+    #require './app'
+    #run Sinatra::Application
+    def default_data
+      {author: "miguel michelson", year: Time.now.year, app: @app}
+    end
+
+    helpers do
+      def status_label(status)
+        label = status == true ? "success" : "default"
+        msg = status ? "passed" : "error"
+        "<span class='label label-#{label}'>build | #{msg}</span>"
+      end
+
+      def status_class(status)
+        status ? "glyphicon glyphicon-ok" : "glyphicon glyphicon-remove"
+      end
+
+
+      def avatar_url(email, size)
+        gravatar_id = Digest::MD5.hexdigest(email.downcase)
+        "http://gravatar.com/avatar/#{gravatar_id}.png?s=#{size}"
+      end
+
+      def commit_url(repo, sha)
+        "#{repo.http_url}/commit/#{sha}"
+      end
+    end
+  end
+
+end

data/lib/perkins/thor_utils.rb

@@ -0,0 +1,79 @@
+module Perkins
+  module ThorUtils
+    include Thor::Actions
+
+    def self.source_root
+       File.dirname(__FILE__)
+    end
+
+    def create_new_file(name, file=nil)
+      log "Creating #{name}"
+      contents = file.nil? ? '' : File.read(file)
+      unless File.file?(location.join(name))
+        File.open(location.join(name), 'w') { |f| f.write(contents) }
+      end
+    end
+
+    def remove_files(*files)
+      files.each do |file|
+        log "Removing #{file} file."
+        FileUtils.rm(location.join(file))
+      end
+    end
+
+    def touch(*filenames)
+      filenames.each do |filename|
+        log "Creating #{filename} file."
+        FileUtils.touch(location.join(filename))
+      end
+    end
+
+    def create_directories(*dirs)
+      dirs.each do |dir|
+        log "Creating the #{dir} directory."
+        FileUtils.mkdir_p(location.join(dir))
+      end
+    end
+
+    def remove_directories(*names)
+      names.each do |name|
+        log "Removing #{name} directory."
+        FileUtils.rm_rf(location.join(name))
+      end
+    end
+
+    def create_with_template(name, template_location, contents={})
+      template    = templates("#{template_location}.erb")
+      eruby       = Erubis::Eruby.new(File.read(template))
+      File.open(location.join(name.gsub(/^\//, '')), 'w') { |f| f.write(eruby.result(contents))}
+    end
+
+    def templates(path)
+      ::Perkins.root.join('pullentity-client/templates').join(path)
+    end
+
+    def log(msg)
+      ::Perkins::Logger.report(msg)
+    end
+
+    def error(msg)
+      ::Perkins::Logger.error(msg)
+    end
+
+    def base_location
+      @location ||= Pathname.new(Dir.pwd)
+    end
+
+    alias_method :location, :base_location
+
+    def underscore(string)
+      string.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+  end
+
+end

data/lib/perkins/version.rb

@@ -0,0 +1,3 @@
+module Perkins
+  VERSION = "0.0.1"
+end

data/lib/perkins/views/401.haml

@@ -0,0 +1 @@
+401

data/lib/perkins/views/builds.haml

@@ -0,0 +1,46 @@
+
+
+= haml :"repos/menu" , locals:{ repo: repo, active: "builds", build: nil}
+
+.title
+  %h2#repo-name= repo.name
+  %h4= repo.url
+
+.panel.panel-default
+  .panel-heading Builds
+  .panel-body
+
+  %table.table
+    %thead
+      %tr
+        %th Build
+        %th Message
+        %th Commit
+        %th Duration
+        %th Finished
+    %tbody
+
+      - builds.each do |build|
+
+        %tr.build-row
+          %td
+            %a{href: "/repos/#{repo.name}/builds/#{build.id}"}
+              %span{class: status_class(build['status']) }
+              = build['_id'].to_s[0..7]
+
+          %td
+            = build.commit.message.split("\n")[0]
+          %td
+            %a{href: commit_url(repo, build.commit.sha), target: :blank}
+              #{build.commit.sha[0..7]}
+              - if build.branch.present?
+                %strong
+                  = "(#{build.branch})"
+
+          %td
+            = "#{build.duration.to_i.round(2)} secs"
+          %td
+            %abbr.timeago{title:build.build_time}
+
+
+