deep_thought 0.1.0

data/lib/deep_thought/ci_service.rb

@@ -0,0 +1,39 @@
+module DeepThought
+  module CIService
+    class CIServiceNotFoundError < StandardError; end
+    class CIBuildNotGreenError < StandardError; end
+    class CIProjectAccessError < StandardError; end
+
+    class << self
+      attr_accessor :adapters, :ci_service
+    end
+
+    def self.adapters
+      @adapters ||= {}
+    end
+
+    def self.register_adapter(name, service)
+      self.adapters[name] = service
+    end
+
+    def self.setup(settings)
+      if settings['CI_SERVICE']
+        if @adapters.keys.include?(settings['CI_SERVICE'])
+          klass = adapters[settings['CI_SERVICE']]
+          @ci_service = klass.new
+          @ci_service.setup(settings)
+        else
+          raise CIServiceNotFoundError, "I don't have a CI service called \"#{settings['CI_SERVICE']}\"."
+        end
+      end
+    end
+
+    def self.is_branch_green?(app, branch, hash)
+      begin
+        @ci_service.is_branch_green?(app, branch, hash)
+      rescue
+        raise CIProjectAccessError, "Something went wrong asking #{ENV['CI_SERVICE']} about commit #{hash} in #{app} on the #{branch} branch."
+      end
+    end
+  end
+end

data/lib/deep_thought/ci_service/janky.rb

@@ -0,0 +1,34 @@
+require 'httparty'
+
+module DeepThought
+  module CIService
+    class Janky
+      attr_accessor :endpoint, :username, :password
+
+      def setup(settings)
+        @endpoint = settings['CI_SERVICE_ENDPOINT']
+        @username = settings['CI_SERVICE_USERNAME']
+        @password = settings['CI_SERVICE_PASSWORD']
+      end
+
+      def is_branch_green?(app, branch, hash)
+        is_green = false
+
+        response = HTTParty.get("#{@endpoint}/_hubot/#{app}/#{branch}", {:basic_auth => {:username => @username, :password => @password}})
+        builds = JSON.parse(response.body)
+
+        builds.each do |build|
+          if build['sha1'].to_s == hash.to_s
+            if build['green']
+              is_green = true
+            end
+
+            break
+          end
+        end
+
+        is_green
+      end
+    end
+  end
+end

data/lib/deep_thought/deployer.rb

@@ -0,0 +1,180 @@
+require 'yaml'
+require 'deep_thought/git'
+
+module DeepThought
+  module Deployer
+    class DeployerNotFoundError < StandardError; end
+    class DeploymentFailedError < StandardError; end
+    class DeploymentInProgressError < StandardError; end
+
+    class << self
+      attr_accessor :adapters
+    end
+
+    def self.adapters
+      @adapters ||= {}
+    end
+
+    def self.register_adapter(name, service)
+      self.adapters[name] = service
+    end
+
+    def self.create(project, user, via, options = {})
+      branch = options[:branch] || 'master'
+      actions = options[:actions] if options[:actions]
+      environment = options[:environment] if options[:environment]
+      box = options[:box] if options[:box]
+      variables = options[:variables] if options[:variables]
+      on_behalf_of = options[:on_behalf_of] if options[:on_behalf_of]
+
+      if is_deploying?
+        raise DeploymentInProgressError, "Sorry, but I'm currently in mid-deployment. Ask me again when I'm done."
+      end
+
+      project.setup
+
+      hash = Git.get_latest_commit_for_branch(project, branch)
+
+      project_config = YAML.load_file(".projects/#{project.name}/.deepthought.yml")
+
+      if project_config['ci']
+        uses_ci = project_config['ci']['enabled'] || false
+      else
+        uses_ci = false
+      end
+
+      if DeepThought::CIService.ci_service
+        if uses_ci
+          ci_project_name = project_config['ci']['name'] || project.name
+          if !DeepThought::CIService.is_branch_green?(ci_project_name, branch, hash)
+            raise DeepThought::CIService::CIBuildNotGreenError, "Commit #{hash} on project #{app} (in branch #{branch}) is not green. Fix it before deploying."
+          end
+        end
+      end
+
+      deploy = DeepThought::Deploy.new
+      deploy.project_id = project.id
+      deploy.user_id = user.id
+      deploy.branch = branch
+      deploy.commit = hash.to_s
+      deploy.via = via
+      deploy.actions = actions.to_yaml if actions
+      deploy.environment = environment if environment
+      deploy.box = box if environment && box
+      deploy.variables = variables.to_yaml if variables
+      deploy.on_behalf_of = on_behalf_of if on_behalf_of
+      deploy.save!
+    end
+
+    def self.execute(deploy)
+      if !is_deploying?
+        Git.switch_to_branch(deploy.project, deploy.branch)
+
+        deploy.project.setup
+
+        project_config = YAML.load_file(".projects/#{deploy.project.name}/.deepthought.yml") || {}
+        deploy_type = project_config['deploy_type'] || 'shell'
+
+        if @adapters.keys.include?(deploy_type)
+          lock_deployer
+
+          deploy.started_at = DateTime.now
+          deploy.in_progress = true
+          deploy.save!
+
+          klass = adapters[deploy_type]
+          deployer = klass.new
+          deployer.setup(deploy.project, project_config)
+          deploy_status = deployer.execute(deploy, project_config)
+
+          unlock_deployer
+
+          deploy.finished_at = DateTime.now
+          deploy.in_progress = false
+
+          deploy_summary = deploy.project.name
+
+          if deploy.actions
+            actions = YAML.load(deploy.actions)
+            actions.each do |action|
+              deploy_summary += "/#{action}"
+            end
+          end
+
+          deploy_summary += " #{deploy.branch}"
+
+          if deploy.environment
+            deploy_summary += " to #{deploy.environment}"
+
+            if deploy.box
+              deploy_summary += "/#{deploy.box}"
+            end
+          end
+
+          if deploy.variables
+            variables = YAML.load(deploy.variables)
+            variables.each do |k, v|
+              deploy_summary += " #{k}=#{v}"
+            end
+          end
+
+          if deploy_status
+            deploy.was_successful = true
+            deploy.save!
+
+            DeepThought::Notifier.notify(deploy.user, "SUCCESS: #{deploy_summary}")
+
+            true
+          else
+            deploy.was_successful = false
+            deploy.save!
+
+            DeepThought::Notifier.notify(deploy.user, "FAILED: #{deploy_summary}")
+
+            raise DeploymentFailedError, "The deployment pondered its own short existence before hitting the ground with a sudden wet thud."
+          end
+        else
+          raise DeployerNotFoundError, "I don't have a deployer called \"#{deploy_type}\"."
+        end
+      else
+        raise DeploymentInProgressError, "Sorry, but I'm currently in mid-deployment. Ask me again when I'm done."
+      end
+    end
+
+    def self.is_deploying?
+      deployer_state = get_or_create_deployer_state
+
+      if deployer_state.state == 'true'
+        true
+      else
+        false
+      end
+    end
+
+    def self.lock_deployer
+      deployer_state = get_or_create_deployer_state
+
+      deployer_state.state = 'true'
+      deployer_state.save
+    end
+
+    def self.unlock_deployer
+      deployer_state = get_or_create_deployer_state
+
+      deployer_state.state = 'false'
+      deployer_state.save
+    end
+
+    private
+
+    def self.get_or_create_deployer_state
+      deployer_state = DeepThought::State.find_by_name('deployer')
+
+      if !deployer_state
+        deployer_state = DeepThought::State.create(:name => 'deployer', :state => 'false')
+      end
+
+      deployer_state
+    end
+  end
+end

data/lib/deep_thought/deployer/deployer.rb

@@ -0,0 +1,17 @@
+module DeepThought
+  module Deployer
+    class Deployer
+      def initialize
+        if self.class.name == 'DeepThought::Deployer::Deployer'
+          raise "#{self.class.name} is abstract, you cannot instantiate it directly."
+        end
+      end
+
+      def setup(project, config)
+      end
+
+      def execute(deploy, config)
+      end
+    end
+  end
+end

data/lib/deep_thought/deployer/shell.rb

@@ -0,0 +1,45 @@
+require 'deep_thought/deployer/deployer'
+
+module DeepThought
+  module Deployer
+    class Shell < DeepThought::Deployer::Deployer
+      def execute(deploy, config)
+        environment = deploy.environment || "development"
+
+        root = config['root'] || "script/deploy"
+
+        command = "#{root} #{environment} deploy"
+
+        if deploy.actions
+          actions = YAML.load(deploy.actions)
+          actions.each do |action|
+            command += ":#{action}"
+          end
+        end
+
+        command += " branch=#{deploy.branch}"
+        command += " box=#{deploy.box}" if deploy.box
+
+        if deploy.variables
+          variables = YAML.load(deploy.variables)
+          variables.each do |k, v|
+            command += " #{k}=#{v}"
+          end
+        end
+
+        commands = []
+
+        commands << "cd ./.projects/#{deploy.project.name}"
+        commands << "#{command} 2>&1"
+
+        executable = commands.join(" && ")
+
+        log = `#{executable}`
+
+        deploy.log = log
+
+        $?.success?
+      end
+    end
+  end
+end

data/lib/deep_thought/git.rb

@@ -0,0 +1,76 @@
+require 'rugged'
+
+module DeepThought
+  module Git
+    class GitRepositoryNotFoundError < StandardError; end
+    class GitBranchNotFoundError < StandardError; end
+
+    def self.setup(project)
+      if !File.directory?(".projects/#{project.name}/.git")
+        exit_status = system "git clone #{project.repo_url} .projects/#{project.name} > /dev/null 2>&1"
+
+        if exit_status
+          if !File.directory?(".projects/#{project.name}/.git")
+            false
+          else
+            if Dir.entries(".projects/#{project.name}") == [".", "..", ".git"]
+              false
+            else
+              true
+            end
+          end
+        else
+          false
+        end
+      else
+        true
+      end
+    end
+
+    def self.get_list_of_branches(project)
+      self.clone_if_not_exists(project)
+
+      system "cd ./.projects/#{project.name} && git fetch -p > /dev/null 2>&1"
+
+      repo = Rugged::Repository.new(".projects/#{project.name}")
+
+      branches = Rugged::Branch.each_name(repo, :remote).sort
+      branches.map! { |x| x.sub!('origin/', '') }
+      branches.delete('HEAD')
+
+      branches
+    end
+
+    def self.get_latest_commit_for_branch(project, branch)
+      self.clone_if_not_exists(project)
+
+      system "cd ./.projects/#{project.name} && git fetch -p > /dev/null 2>&1"
+
+      repo = Rugged::Repository.new(".projects/#{project.name}")
+
+      switch_to_branch(project, branch)
+
+      repo.head.target
+    end
+
+    def self.switch_to_branch(project, branch)
+      self.clone_if_not_exists(project)
+
+      exit_status = system "cd ./.projects/#{project.name} && git fetch -p > /dev/null 2>&1 && git reset --hard origin/#{branch} > /dev/null 2>&1"
+
+      if exit_status
+        true
+      else
+        raise GitBranchNotFoundError, "#{project.name} doesn't appear to have a branch called #{branch}. Have you pushed it?"
+      end
+    end
+
+    private
+
+    def self.clone_if_not_exists(project)
+      if !self.setup(project)
+        raise DeepThought::Git::GitRepositoryNotFoundError, "I can't seem to access that repo. Are you sure the URL is correct and that I have access to it?"
+      end
+    end
+  end
+end

data/lib/deep_thought/models/deploy.rb

@@ -0,0 +1,27 @@
+module DeepThought
+  class Deploy < ActiveRecord::Base
+    belongs_to :project
+    belongs_to :user
+
+    after_create :queue
+
+    validates_presence_of :branch
+    validates_presence_of :commit
+    validates_presence_of :project
+    validates_presence_of :user
+
+    def queue
+      Delayed::Job.enqueue self
+
+      DeepThought::Scaler.scale
+    end
+
+    def perform
+      DeepThought::Deployer.execute(self)
+    end
+
+    def max_attempts
+      return 1
+    end
+  end
+end

data/lib/deep_thought/models/project.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+module DeepThought
+  class ProjectConfigNotFoundError < StandardError; end
+
+  class Project < ActiveRecord::Base
+    has_many :deploys
+
+    before_destroy :delete_repo
+
+    validates :name, presence: true, uniqueness: true
+    validates :repo_url, presence: true
+
+    def setup
+      if DeepThought::Git.setup(self)
+        if !File.exists?(".projects/#{self.name}/.deepthought.yml")
+          delete_repo
+
+          raise DeepThought::ProjectConfigNotFoundError, "#{self.name} does not appear to have a .deepthought.yml config file. Add one and try again."
+        end
+      else
+        raise DeepThought::Git::GitRepositoryNotFoundError, "I can't seem to access that repo. Are you sure the URL is correct and that I have access to it?"
+      end
+    end
+
+    def delete_repo
+      if File.directory?(".projects/#{self.name}")
+        FileUtils.rm_rf(".projects/#{self.name}")
+      end
+    end
+  end
+end