perkins 0.0.3 → 0.0.5

data/lib/perkins/build/script.rb

@@ -157,7 +157,8 @@ module Perkins
       end
 
       def template(filename)
-        @working_dir = @repo.working_dir + @repo.name
+        @working_dir = @repo.working_dir + @repo.download_name
+        #puts "REPO REPO #{@working_dir}"
         ERB.new(File.read(File.expand_path(filename, TEMPLATES_PATH))).result(binding)
       end
 

data/lib/perkins/build/script/go.rb

@@ -42,7 +42,7 @@ module Perkins
           # `go` commands.
           source_path = repo.url.gsub(/https\:\/\/|\.git/, "")
           source_owner_path = source_path.split('/')[0..1].join("/")
-          local_path = self.repo.working_dir + self.repo.name
+          local_path = self.repo.working_dir + self.repo.download_name
           "export GOPATH=#{HOME_DIR}/gopath:$GOPATH && " <<
           #binding.pry
           "mkdir -p #{HOME_DIR}/gopath/src/#{source_owner_path} && " <<

data/lib/perkins/build/script/ruby.rb

@@ -8,7 +8,7 @@ module Perkins
         }
 
         include Jdk
-        #include RVM
+        include RVM
         include Bundler
 
         def announce

data/lib/perkins/build/script/stages.rb

@@ -18,7 +18,6 @@ module Perkins
         end
 
         def call_custom_stage(stage)
-          #binding.pry
           @config.send(stage).present? ? cmd(@config.send(stage)) : self.send(stage)
         end
 

data/lib/perkins/build_report.rb

@@ -2,9 +2,24 @@ module Perkins
   class BuildReport < ActiveRecord::Base
     belongs_to :repo
 
-    def commit
-      self.repo.load_git
-      @commit ||= Perkins::Commit.new(self.sha, self.repo)
+    after_create :enqueue
+
+    serialize :commit
+
+    def enqueue
+      BuildWorker.perform_async(self.id, sha, branch )
+    end
+
+    #def formatted_commit
+      #self.repo.load_git
+    #  self.commit ||= $github_client.commits(repo.name, sha)
+    #   Perkins::Commit.new(self.commit)
+    #end
+
+    def retrieve_commit_info
+      hsh = $github_client.commits(repo.name, sha).first.to_attrs
+      self.commit = hsh
+      self.save
     end
 
     def send_github_status(sha)
@@ -17,7 +32,7 @@ module Perkins
 
       unless fields = options[:only]
         fields = [:id, :sha, :commit, :branch, :build_time,
-                  :status, :duration, :build_time, :response]
+                  :status, :duration, :build_time, :response, :build_status]
       end
 
       fields.each { |k| data[k] = send(k) }
@@ -25,10 +40,7 @@ module Perkins
       data
     end
 
-
-
     # Status report to GITHUB repo
-
     def build_status_report(sha)
       $github_client.create_status(
         self.repo.name, sha,
@@ -53,5 +65,13 @@ module Perkins
       "#{Perkins::Application.instance.sse_endpoint}/repos/#{repo.name}/builds/#{self.id}"
     end
 
+    def start!
+      update_attribute(:build_status, "started")
+    end
+
+    def stop!
+      update_attribute(:build_status, "stopped")
+    end
+
   end
 end

data/lib/perkins/build_worker.rb

@@ -6,33 +6,28 @@ module Perkins
 
     include Sidekiq::Worker
 
-    def perform(repo_id, sha, branch)
-      repo = Perkins::Repo.find(repo_id)
-      #it actually clone repo and instantiates git data
+    def perform(report_id, sha, branch)
+      report = Perkins::BuildReport.find(report_id)
+      report.retrieve_commit_info
+      repo = report.repo
+      repo.virtual_sha = "-#{report.id}-#{sha}"
+      #repo.build_runner_config
+      #it actually clone repo and instantiates git data & check travis.yml
       repo.load_git
 
       return if repo.runner.blank?
-
+      repo.runner.report = report
       repo.runner.sha    = sha
       repo.runner.branch = branch
 
-      send_sse({repo: {id: repo.id, name: repo.name , status: "start"} })
+      repo.send_sse(status: "start")
 
       repo.runner.run(sha)
 
       report = repo.build_reports.find_by(sha: sha)
       report.send_github_status(sha)
 
-      send_sse({repo: {id: repo.id, name: repo.name , status: "stop", report: report } })
-    end
-
-    def send_sse(msg)
-      url = "#{Perkins::Application.instance.sse_endpoint}/sse"
-      puts "send sse post to #{url} with msg: #{msg.to_json}".pink
-      postData = Net::HTTP.post_form(
-        URI.parse(url),
-        {'msg'=> msg.to_json }
-      )
+      repo.send_sse({ status: "stop", report: report })
     end
 
   end

data/lib/perkins/git_loader_worker.rb

@@ -8,22 +8,9 @@ module Perkins
 
     def perform(repo_id)
       repo = Perkins::Repo.find(repo_id)
+      #return if repo.downloading? or repo.downloaded?
       #it actually clone repo and instantiates git data
-      send_sse({repo: {id: repo.id, name: repo.name , status: "downloading"} })
-
       repo.load_git
-
-      send_sse({repo: {id: repo.id, name: repo.name , status: "downloaded" } })
     end
-
-    def send_sse(msg)
-      url = "#{Perkins::Application.instance.sse_endpoint}/sse"
-      puts "send sse post to #{url} with msg: #{msg.to_json}".pink
-      postData = Net::HTTP.post_form(
-        URI.parse(url),
-        {'msg'=> msg.to_json }
-      )
-    end
-
   end
 end

data/lib/perkins/repo.rb

@@ -2,7 +2,7 @@ require "git"
 module Perkins
   class Repo < ActiveRecord::Base
     attr_accessor :git
-    attr_accessor :new_commit, :runner
+    attr_accessor :new_commit, :runner, :virtual_sha
 
     has_many :build_reports, class_name: 'Perkins::BuildReport'
     serialize :github_data, ActiveSupport::HashWithIndifferentAccess
@@ -31,7 +31,7 @@ module Perkins
       repo.url    = r[:clone_url]
       repo.name   = r[:full_name]
       repo.gb_id  = r[:id]
-      repo.working_dir = DEFAULT_DIR
+      repo.working_dir ||= DEFAULT_DIR
       repo.save
     end
 
@@ -41,9 +41,10 @@ module Perkins
 
     def self.store_from_github(repo)
       #repo
-      repo.working_dir = DEFAULT_DIR #this should be configurable from app
+      repo.working_dir ||= DEFAULT_DIR #this should be configurable from app
       repo.cached = false
       repo.save
+      repo
     end
 
     def self.initialize_from_store(opts)
@@ -52,7 +53,7 @@ module Perkins
       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.working_dir ||= DEFAULT_DIR #this should be configurable from app
       repo
     end
 
@@ -60,31 +61,103 @@ module Perkins
       clone_or_load
     end
 
-    def downloaded?
-      self.download_status.present? && self.download_status == "downloaded"
+    #def downloaded?
+    #  self.download_status == "downloaded"
+    #end
+
+    #def downloading?
+    #  self.download_status == "downloading"
+    #end
+
+    def download!
+      # we need this only in the context of the first clone
+      # in the context of builds we are not going to notice 
+      # the user that we are cloning the repo
+      if self.virtual_sha.present?
+        send_sse( status: "downloading")
+        #self.update_column(:download_status, "downloading")
+      end
+
+      #clone repo
+      ssh_url = self.github_data["ssh_url"]
+      Git.clone(ssh_url, download_name, :path => working_dir)
+      open
+      
+      #TODO: fix this & handle with care
+      begin
+        add_hook #permissions issue
+      rescue Exception => e
+        puts e.message
+      end
+
+      send_sse(status: "downloaded") if self.virtual_sha.present?
+    end
+
+    def download_name
+      [name, self.virtual_sha].join
+    end
+
+    def add_hook(url=nil)
+      url = hook_url if url.blank?
+
+      if hook_id.blank?
+        res = $github_client.create_hook(
+          self.name,
+          'web',
+          { :url => url, :content_type => 'json'},
+          { :events => ['push', 'pull_request'], 
+            :active => true}
+        )
+        self.update_attribute(:hook_id, res[:id]) if res[:id].present?
+      end
+    end
+
+    def edit_hook(url)
+
+      url = hook_url if url.blank?
+ 
+      hook = get_hook
+            
+      if hook.present?
+        res = $github_client.edit_hook(
+          self.name,
+          hook["id"],
+          'web',
+          {:url => url, :content_type => 'json'},
+          {:active => true}
+        )
+        self.update_attribute(:hook_id, res[:id]) if res[:id].present?
+      end
+    end
+
+    def hook_url
+      u = Perkins::Application.instance.sse_endpoint
+      p = Perkins::Application.instance.port == "80" ? nil : Perkins::Application.instance.port
+      host = [u, p].compact.join(":")
+      url = "#{host}/repos/receiver.json"
     end
 
-    def downloading?
-      self.download_status.present? && self.download_status == "downloading"
+    def get_hook
+      return {} if self.hook_id.blank?
+      $github_client.hook(self.name, self.hook_id)
     end
 
     def clone_or_load
       if exists?
         open
       else
-        ssh_url = self.github_data["ssh_url"]
-        Git.clone(ssh_url, name, :path => working_dir)
-        open
+        download!
       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
-      self.update_column(:download_status, "downloaded")
+      build_runner_config
+      #self.update_column(:download_status, "downloaded") #unless self.downloaded?
     end
 
     def check_config_existence
+      #puts "CURRENT GIT DIR: #{self.git.dir.path} !!!!!"
       config = self.git.chdir{
         if File.exist?(".travis.yml")
           config = Travis::Yaml.parse( File.open(".travis.yml").read )
@@ -101,7 +174,7 @@ module Perkins
     end
 
     def local_path
-      self.working_dir + self.name.to_s
+     [ self.working_dir , self.download_name].join
     end
 
     def branches
@@ -109,7 +182,8 @@ module Perkins
     end
 
     #http://docs.travis-ci.com/user/build-configuration/#The-Build-Matrix
-    def build_runner_config(config)
+    def build_runner_config
+      config = self.check_config_existence
       runner = Runner.new()
       runner.config = config
       runner.repo = self
@@ -129,18 +203,23 @@ module Perkins
     end
 
     def add_commit(sha, branch)
-      if runner_branch.include?(branch)
+      #if runner_branch.include?(branch)
         #@new_commit = Perkins::Commit.new(sha, self)
         #@new_commit.branch = branch
         #enqueue_commit(@new_commit)
         enqueue_commit(sha, branch)
-      else
-        puts "skipping commit from branch #{branch}"
-      end
+      #else
+      #  puts "skipping commit from branch #{branch}"
+      #end
     end
 
     def enqueue_commit(sha, branch)
-      BuildWorker.perform_async(self.id, sha, branch )
+      report = Perkins::BuildReport.new
+      report.sha = sha 
+      report.branch = branch
+
+      self.build_reports << report
+      self.save
     end
 
     def http_url
@@ -154,7 +233,13 @@ module Perkins
       build_reports.last.id if build_reports.any?
     end
 
-
+    def send_sse(msg)
+      opts = {repo: {id: self.id, name: self.name }}
+      opts[:repo].merge!(msg) if msg.is_a?(Hash)
+      json_opts = opts.to_json
+      puts "Notify #{json_opts}".yellow
+      Redis.current.publish("message.", json_opts)
+    end
 
   end
 

data/lib/perkins/runner.rb

@@ -2,22 +2,34 @@
 module Perkins
   class Runner
 
-    attr_accessor :repo, :command, :config, :sha, :branch
+    #include Process
+
+    attr_accessor :repo, :report, :command, :config, :sha, :branch
     attr_reader :build_time, :duration, :response, :status, :current_build
 
     def exec(cmd)
       result = run_script(cmd)
-      puts result
-      process_status = $?
-
-      if successful_command?(process_status) || config_command_with_empty_value?(result,process_status)
-        @response = result
+      @response = result.join("")
+      
+      if result.last.chomp.include?("with 0")
         @status = true
-        return result
+      elsif result.last.chomp.include?("with 1")
+        @status = false
       else
-        @response = result
+        puts "status result not found!!"
         @status = false
       end
+          
+      #puts result
+      #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
+      #end
     end
 
     def run_script(source)
@@ -28,33 +40,67 @@ module Perkins
       File.open(script, 'w') { |f| f.write(source) }
       FileUtils.chmod(0755, script)
       Bundler.with_clean_env{
-        `bash #{script} 2>&1`.chomp
+        pipe_command("#{script} 2>&1")
+        #`bash #{script} 2>&1`.chomp
       }
     end
 
+    def pipe_command(cmd)
+      output = []
+      r, io = IO.pipe
+      pid = fork do
+        @process = system(cmd, out: io, err: :out)
+      end
+      io.close
+      r.each_line{|l| 
+        puts l.yellow
+        output << l
+        #puts "CURRENT DIR: #{Dir.pwd} !!!!!"
+        #puts "CURRENT GIT DIR: #{repo.git.dir.path} !!!!!"
+        #puts "#{repo.download_name} !!!!!!!"
+        #updates each time, this should trigger event to interface to refresh
+        @current_report.update_column(:response, output.join(""))
+      } 
+      #Process.waitpid(p1) #this is to get the $ exitstatus
+      output
+    end
+
     def run(sha)
       self.sha = sha
       start_build
+      self.repo.virtual_sha = "-#{@current_report.id}-#{self.sha}"
+      #it actually clone repo and instantiates git data
+      repo.load_git
+
       script = Perkins::Build::script(config, repo)
       sh = script.compile
+
       repo.git.chdir do
+        #puts "CURRENT DIR: #{Dir.pwd} !!!!!"
+        #puts "CURRENT GIT DIR: #{repo.git.dir.path} !!!!!"
         git_update(sha)
         set_build_stats do
           puts "perform build".green
           self.exec(sh)
         end
       end
-      store_report
+      #store_report
       stop_build
     end
 
     def start_build
       @running = true
+      store_report
+      @current_report.start!
       @repo.update_column(:build_status, "started")
     end
 
     def stop_build
       @running = false
+      @current_report.stop!
+      
+      @current_report.update_attributes(self.to_report)
+    
       @repo.update_column(:build_status, "stopped")
     end
 
@@ -103,8 +149,7 @@ module Perkins
     end
 
     def store_report
-      r = Perkins::BuildReport.new(self.to_report)
-      repo.build_reports << r
+      @current_report = Perkins::BuildReport.find(report)
     end
 
     def get_builds