ship_it 0.0.1

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,31 @@
+class SessionsController < ApplicationController
+
+  layout 'homepage'
+  skip_before_filter :authorize
+
+  def homepage
+    redirect_to projects_path if authorized?
+  end
+
+  def new
+  end
+
+  def create
+    @user = User.find_or_create_from_auth_hash(auth_hash)
+    session[:user_id] = @user.id
+    session[:user_name] = @user.name
+    redirect_to projects_path
+  end
+
+  def destroy
+    reset_session
+    redirect_to root_path
+  end
+
+  protected
+
+  def auth_hash
+    request.env['omniauth.auth']
+  end
+
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,2 @@
+class UsersController < ApplicationController
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,70 @@
+module ApplicationHelper
+
+  def recent_failures
+    @recent_failures ||= Environment.includes(:last_deployment).map(&:last_deployment).compact.select(&:failed?)
+  end
+
+  def in_progress
+    @in_progress ||= Deployment.in_progress.all
+  end
+
+  def last_successful_duration(deployment)
+    deployment.environment.last_successful_deployment &&
+      deployment.environment.last_successful_deployment.duration
+  end
+
+  def progress_classes(deployment)
+    lsd = last_successful_duration(deployment)
+    ["progress", "progress-striped"].tap do |classes|
+      if !lsd
+        classes << "progress-warning"
+      elsif !deployment.started?
+      elsif deployment.duration > lsd
+        classes << "progress-danger"
+      else
+        classes << "progress-success"
+      end
+      classes << "active" unless deployment.completed?
+    end
+  end
+
+  def deployment_percent(deployment)
+    lsd = last_successful_duration(deployment)
+    if !lsd
+      return 100
+    elsif !deployment.started?
+      return 0
+    elsif deployment.duration > lsd
+      return 100
+    else
+      return deployment.duration * 100 / lsd
+    end
+  end
+
+  def time_remaining(deployment)
+    if last_successful_deployment = deployment.environment.last_successful_deployment
+      time_remaining = last_successful_deployment.duration - deployment.duration
+      if time_remaining < 0
+        "unknown"
+      elsif time_remaining < 60
+        "< 1 minute"
+      else
+        pluralize((time_remaining / 60).round, 'minute')
+      end
+    else
+      "unknown"
+    end
+  end
+
+  def duration_text(seconds)
+    minutes = (seconds / 60.floor)
+    seconds %= 60
+    
+    string = ""
+    string << "#{minutes}m " if minutes
+    string << "#{seconds}s"
+    
+    string
+  end
+
+end

data/app/models/branch.rb

@@ -0,0 +1,15 @@
+class Branch < ActiveRecord::Base
+
+  belongs_to :project
+  has_many :deployments, dependent: :destroy
+  validates :name, presence: true, uniqueness: {scope: :project_id}
+
+  def current_revision
+    project.git.revparse("remotes/origin/#{name}")
+  end
+  
+  def last_commit
+    @last_commit ||= project.git.log.between("#{current_revision}^", current_revision).first
+  end
+
+end

data/app/models/commit.rb

@@ -0,0 +1,8 @@
+class Commit < ActiveRecord::Base
+
+  belongs_to :deployment
+
+  validates :deployment, presence: true
+  validates :sha, presence: true
+
+end

data/app/models/deploy_option.rb

@@ -0,0 +1,11 @@
+class DeployOption < ActiveRecord::Base
+
+  belongs_to :project
+
+  validates :name, presence: true
+  validates :value, presence: true
+
+  def value
+    visible? ? read_attribute(:value) : "(not visible)"
+  end
+end

data/app/models/deployment.rb

@@ -0,0 +1,137 @@
+class Deployment < ActiveRecord::Base
+
+  belongs_to :branch
+  belongs_to :environment
+  belongs_to :created_by, class_name: "User"
+  has_many :commits, dependent: :destroy
+
+  scope :pending, -> { where(started_at: nil) }
+  scope :awaiting_termination, -> { where(user_terminated: true, finished_at: nil) }
+  
+  scope :in_progress, -> { where("started_at is not null and finished_at is null") }
+
+  delegate :project, to: :environment
+
+  before_validation :set_revision, on: :create
+  before_validation :set_created_by, on: :create
+  before_create :build_pending_commits
+  after_destroy :destroy_log
+
+  def started?
+    started_at.present?
+  end
+
+  def completed?
+    finished_at.present?
+  end
+  
+  def failed?
+    completed? && !success?
+  end
+  
+  def short_revision
+    revision.andand[0...8]
+  end
+
+  def percent_complete
+    return 100 if completed?
+    return 0 unless started?
+    last_duration = environment.deployments.last_successfull_deployment.andand.duration
+    return nil unless last_duration
+    duration * 100 / last_duration
+  end
+
+  def duration
+    return nil unless started?
+    (finished_at || Time.now).to_i - started_at.to_i
+  end
+
+  def status
+    if !started?
+      return "pending"
+    elsif !completed?
+      # still running
+      if user_terminated?
+        return "awaiting termination"
+      else
+        return "in progress"
+      end
+    elsif success?
+      return "succeeded"
+    elsif user_terminated?
+      return "terminated"
+    else
+      return "failed"
+    end
+  end
+
+  def log
+    # read log file
+    File.read(log_file) if log_file.present?
+  end
+  
+  def terminate!
+    update_attributes(user_terminated: true)
+  end
+
+  def deploy!
+    log_file = File.join(ShipIt.log_dir, "#{branch.name}-#{environment.name}-#{Time.now.strftime("%Y%m%d%H%M%S")}.log")
+    update_attributes(log_file: log_file)
+
+    deploy_options = ["branch=#{revision}"] + project.deploy_options.map{|option| "#{option.name}=#{option.read_attribute(:value)}"}
+    deploy_options = deploy_options.map{|str| "-S #{str}"}.join(" ")
+
+    command = "bundle install --deployment --without development test && bundle exec cap #{environment.name} #{deploy_options} deploy:migrations"
+    #command = "bundle exec cap #{environment.name} #{deploy_options} deploy:migrations"
+    success = run_command(command, log_file)
+
+    update_attributes(finished_at: Time.now, success: success)
+  end
+
+  protected
+
+  def run_command(command, log_file)
+    pid = nil
+    
+    puts "running command: #{command}"
+
+    Bundler.with_clean_env do
+      new_env = {"HOME" => ENV["HOME"]}
+      pid = Process.spawn(new_env, command, [:out, :err] => [log_file, "w"], chdir: project.workspace)
+
+      Process.wait(pid)
+    end
+    
+    status = $?
+    
+    return (status.exitstatus == 0)
+    
+  rescue Exception => e
+    puts "deploy error: #{e.message}"
+    Process.kill("INT", pid) if pid
+
+    return false
+  end
+
+  def set_revision
+    self.revision ||= branch.current_revision
+  end
+
+  def set_created_by
+    self.created_by ||= User.current
+  end
+
+  def build_pending_commits
+    environment.pending_changes(branch).andand.each do |commit|
+      commits.build({
+        sha: commit.sha,
+        message: commit.message,
+      })
+    end
+  end
+
+  def destroy_log
+    File.unlink(log_file) if log_file.present? && File.exists?(log_file)
+  end
+
+end

data/app/models/environment.rb

@@ -0,0 +1,29 @@
+class Environment < ActiveRecord::Base
+
+  belongs_to :project
+  has_many :deployments, dependent: :destroy
+  has_one :last_deployment, order: "id desc", class_name: "Deployment"
+  has_one :last_successful_deployment, order: "id desc", class_name: "Deployment", conditions: {success: true}
+
+  validates :name, presence: true, uniqueness: {scope: :project_id}
+
+  def current_branch
+    last_successful_deployment.andand.branch
+  end
+
+  def pending_changes(branch = nil)
+    branch ||= current_branch
+    return nil unless current_branch
+
+    @pending_changes ||= begin
+      commits = []
+      current_rev = last_successful_deployment.revision
+      latest_rev = branch.current_revision
+
+      project.git.log.between(current_rev, latest_rev).each do |commit|
+        commits << commit
+      end
+      commits
+    end
+  end
+end

data/app/models/project.rb

@@ -0,0 +1,79 @@
+require 'fileutils'
+require 'git'
+
+class Project < ActiveRecord::Base
+
+  validates :name, :git_repo_url, presence: true
+
+  has_many :branches, inverse_of: :project, dependent: :destroy
+  has_many :environments, inverse_of: :project, dependent: :destroy
+  has_many :deploy_options, inverse_of: :project, dependent: :destroy
+
+  after_destroy :cleanup_workspace
+
+  def cloned?
+    File.directory?(workspace)
+  end
+
+  def underscored_name
+    name.underscore
+  end
+
+  def workspace
+    File.join(ShipIt.workspace, underscored_name)
+  end
+
+  def git
+    @git ||= Git.open(workspace) if cloned?
+  end
+
+  def clone!
+    puts "cloning: #{git_repo_url} -> #{workspace}"
+    Git.clone(git_repo_url, underscored_name, path: ShipIt.workspace)
+  rescue => e
+    puts "error cloning: #{e.message}"
+  end
+
+  def pull!
+    puts "pulling"
+    git.fetch
+    git.lib.send(:command, "rebase")
+  end
+
+  def poll!
+    puts "in poll!"
+    clone! unless cloned?
+    pull!
+
+    # sync branches and environments
+    remotes = git.branches.remote.reject{|br| br.full.match("HEAD")}.map{|br| br.full.split("/").last}
+    branches.each do |branch|
+      branch.destroy unless remotes.include?(branch.name)
+    end
+    (remotes - branches.map(&:name)).each do |name|
+      branches.create({:name => name})
+    end
+
+    envs = []
+    Dir.glob(File.join(workspace, "config", "deploy", "*.rb")).each do |environment|
+      envs << File.basename(environment).gsub(/.rb$/, "")
+    end
+    environments.each do |environment|
+      environment.destroy unless envs.include?(environment.name)
+    end
+    (envs - environments.map(&:name)).each do |name|
+      environments.create({:name => name})
+    end
+  rescue => e
+    puts "error polling: #{e.message}"
+
+    pp e.backtrace
+  end
+
+  protected
+
+  def cleanup_workspace
+    FileUtils.rm_rf workspace
+  end
+
+end

data/app/models/user.rb

@@ -0,0 +1,18 @@
+class User < ActiveRecord::Base
+  has_many :deployments
+
+  class << self
+    attr_accessor :current
+
+    def find_or_create_from_auth_hash(auth_hash)
+      user = find_by_id(auth_hash["uid"])
+      return user if user
+
+      user = create({
+        :id => auth_hash["uid"],
+        :name => auth_hash["info"]["name"],
+        :email_address => auth_hash["info"]["email"],
+      })
+    end
+  end
+end

data/app/views/deploy_options/new.html.slim

@@ -0,0 +1,15 @@
+h1 Add Deploy Option
+
+= form_for [@project, @deploy_option] do |form|
+  = form.label :name
+  = form.text_field :name
+
+  = form.label :value
+  = form.text_field :value
+
+  = form.label :visible do
+    = form.check_box :visible
+    | Value visible?
+
+  .form-actions
+    = form.submit "Add Option", class: "btn btn-primary"

data/app/views/deployments/_current.html.slim

@@ -0,0 +1,15 @@
+.current_deployments data-poll=in_progress_deployments_path
+  - if recent_failures.present?
+    h4 Recent Failures
+    ul.unstyled
+      = render recent_failures
+    br
+    hr
+    br
+
+  h4 Active Deployments
+  - if in_progress.present?
+    ul.unstyled
+      = render in_progress
+  - else
+    p.muted None.