deep_thought 0.1.0

data/deep_thought.gemspec

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'deep_thought/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "deep_thought"
+  gem.version       = DeepThought::VERSION
+  gem.authors       = ["Ian Lollar"]
+  gem.email         = ["rhv@redhotvengeance.com"]
+  gem.description   = "Deploy smart, not hard."
+  gem.summary       = "Deploy smart, not hard."
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split("\n") - %w[.gitignore]
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "rake", "~>10.1"
+  gem.add_dependency "sinatra", "~>1.4"
+  gem.add_dependency "sinatra-contrib", "~>1.4"
+  gem.add_dependency "json", "~>1.8"
+  gem.add_dependency "activerecord", "~>3.2"
+  gem.add_dependency "pg", "~>0.17"
+  gem.add_dependency "rugged", "~>0.19"
+  gem.add_dependency "httparty", "~>0.12"
+  gem.add_dependency "bcrypt-ruby", "~>3.1"
+  gem.add_dependency "rack-ssl", "~>1.3"
+  gem.add_dependency "rack_csrf", "~>2.4"
+  gem.add_dependency "haml", "~>4.0"
+  gem.add_dependency "delayed_job_active_record", "~>0.4"
+
+  # # development
+  gem.add_development_dependency "shotgun", "~>0.9"
+  gem.add_development_dependency "thin", "~>1.6"
+  gem.add_development_dependency "racksh", "~>1.0.0"
+
+  # # testing
+  gem.add_development_dependency "minitest", "~>4.7"
+  gem.add_development_dependency "mocha", "~>0.14"
+  gem.add_development_dependency "database_cleaner", "~>1.2"
+  gem.add_development_dependency "turn", "~>0.9"
+  gem.add_development_dependency "capybara", "~>2.2"
+end

data/lib/deep_thought.rb

@@ -0,0 +1,62 @@
+require 'active_record'
+require 'delayed_job_active_record'
+
+require 'deep_thought/app'
+require 'deep_thought/api'
+require 'deep_thought/models/deploy'
+require 'deep_thought/models/project'
+require 'deep_thought/models/state'
+require 'deep_thought/models/user'
+require 'deep_thought/deployer'
+require 'deep_thought/deployer/shell'
+require 'deep_thought/ci_service'
+require 'deep_thought/ci_service/janky'
+require 'deep_thought/notifier'
+require 'deep_thought/scaler'
+require 'deep_thought/version'
+
+module DeepThought
+  def self.setup(settings)
+    env = settings['RACK_ENV']
+
+    if env != "production"
+      settings["DATABASE_URL"] ||= "postgres://deep_thought@localhost/deep_thought_#{env}"
+    end
+
+    database = URI(settings["DATABASE_URL"])
+
+    connection = {
+      :adapter   => "postgresql",
+      :encoding  => "unicode",
+      :database  => database.path[1..-1],
+      :pool      => 5,
+      :username  => database.user,
+      :password  => database.password,
+      :host      => database.host,
+      :port      => database.port
+    }
+
+    ActiveRecord::Base.establish_connection(connection)
+
+    BCrypt::Engine.cost = 12
+
+    if settings['CI_SERVICE']
+      DeepThought::CIService.setup(settings)
+    end
+  end
+
+  def self.app
+    @app ||= Rack::Builder.app {
+      map '/' do
+        run DeepThought::App
+      end
+
+      map '/deploy/' do
+        run DeepThought::Api
+      end
+    }
+  end
+
+  DeepThought::Deployer.register_adapter('shell', DeepThought::Deployer::Shell)
+  DeepThought::CIService.register_adapter('janky', DeepThought::CIService::Janky)
+end

data/lib/deep_thought/api.rb

@@ -0,0 +1,156 @@
+require 'sinatra'
+require 'sinatra/json'
+require 'rack/ssl'
+require 'deep_thought/git'
+require 'deep_thought/deployer'
+
+module DeepThought
+  class Api < Sinatra::Base
+    helpers Sinatra::JSON
+
+    if ENV['RACK_ENV'] != 'development' && ENV['RACK_ENV'] != 'test'
+      use Rack::SSL
+    end
+
+    before '*' do
+      if !is_json?
+        halt 400, 'I prefer to converse in JSON.'
+      end
+
+      if request.env['HTTP_AUTHORIZATION'] =~ /Token token="[a-zA-Z0-9\+=]+"/
+        token = request.env['HTTP_AUTHORIZATION'].gsub(/Token token="/, '').gsub(/"/, '')
+
+        @user = DeepThought::User.find_by_api_key("#{token}")
+
+        if !@user
+          halt 401
+        end
+      else
+        halt 401
+      end
+    end
+
+    get '/status' do
+      if DeepThought::Deployer.is_deploying?
+        [500, "I'm currently in mid-deployment."]
+      else
+        [200, "I'm ready to ponder the infinitely complex questions of the universe."]
+      end
+    end
+
+    get '*' do
+      [401, "I don't got what you're trying to GET."]
+    end
+
+    post '/' do
+      [500, "Must supply app name."]
+    end
+
+    post '/:app' do
+      raw = request.body.read
+      data = JSON.parse(raw) if raw != ''
+
+      app = params[:app]
+
+      if data
+        branch = data['branch'] || 'master'
+        actions = data['actions'] if data['actions']
+        environment = data['environment'] if data['environment']
+        box = data['box'] if data['box']
+        on_behalf_of = data['on_behalf_of'] if data['on_behalf_of']
+        variables = data['variables'] if data['variables']
+      else
+        branch = 'master'
+      end
+
+      project = DeepThought::Project.find_by_name(app)
+
+      if !project
+        return [500, "Hmm, that project doesn't appear to exist. Have you set it up?"]
+      end
+
+      options = {}
+      options[:branch] = branch
+
+      response = "executing deploy"
+
+      if actions
+        options[:actions] = actions
+
+        actions.each do |action|
+          response += "/#{action}"
+        end
+      end
+
+      response += " #{app}/#{branch}"
+
+      if environment
+        options[:environment] = environment
+        response += " to #{environment}"
+
+        if box
+          options[:box] = box
+          response += "/#{box}"
+        end
+      end
+
+      if variables
+        options[:variables] = variables
+        response += " with #{variables.to_s}"
+      end
+
+      if on_behalf_of
+        options[:on_behalf_of] = on_behalf_of
+        response += " on behalf of #{on_behalf_of}"
+      end
+
+      begin
+        DeepThought::Deployer.create(project, @user, 'api', options)
+
+        response
+      rescue => e
+        if ENV['RACK_ENV'] != 'test'
+          puts e.inspect
+          puts e.backtrace
+        end
+
+        [500, e.message]
+      end
+    end
+
+    post '/setup/:app' do
+      raw = request.body.read
+      data = JSON.parse(raw) if raw != ''
+
+      app = params[:app]
+
+      if data
+        repo_url = data['repo_url'] if data['repo_url']
+      end
+
+      if !repo_url
+        return [500, "Sorry, but I need a project name and repo url. No exceptions, despite how nicely you ask."]
+      end
+
+      project = Project.new(:name => app, :repo_url => repo_url)
+
+      if project.save
+        [200, "Set up new project called #{app} which pulls from #{repo_url}."]
+      else
+        [422, "Shit, something went wrong: #{project.errors.messages}."]
+      end
+    end
+
+    helpers do
+      def is_json?
+        is_json = false
+
+        request.accept.each do |a|
+          is_json = true if a.to_s == 'application/json'
+        end
+
+        is_json
+      end
+    end
+  end
+end

data/lib/deep_thought/app.rb

@@ -0,0 +1,342 @@
+require 'sinatra'
+require 'sinatra/json'
+require 'rack/ssl'
+require 'rack/csrf'
+require 'haml'
+
+module DeepThought
+  class App < Sinatra::Base
+    helpers Sinatra::JSON
+
+    set :root, File.dirname(__FILE__)
+    set :public_folder, File.join(root, 'public')
+    set :views, File.join(root, 'views')
+    set :haml, :layout => :"layouts/layout"
+
+    if ENV['RACK_ENV'] != 'development' && ENV['RACK_ENV'] != 'test'
+      use Rack::SSL
+    end
+
+    use Rack::Session::Cookie, :secret => ENV['SESSION_SECRET']
+    use Rack::Csrf, :raise => true
+    use Rack::MethodOverride
+
+    set :deep_thought_message, "Hello, human."
+
+    before /^(?!\/(login|logout))/ do
+      if !session[:user_id]
+        redirect '/login'
+      end
+    end
+
+    get '/' do
+      projects = DeepThought::Project.all
+
+      if projects.count > 0
+        settings.deep_thought_message = "Deep Thought has the answer."
+      else
+        settings.deep_thought_message = "Deep Thought knows of no projects."
+      end
+
+      haml :"projects/index", :locals => {:projects => projects}
+    end
+
+    get '/login' do
+      if session[:user_id]
+        redirect '/'
+      end
+
+      haml :"sessions/login"
+    end
+
+    post '/login' do
+      user = User.authenticate(params[:email], params[:password])
+
+      if user
+        session[:user_id] = user.id
+        redirect '/'
+      else
+        redirect '/login'
+      end
+    end
+
+    delete '/logout' do
+      session[:user_id] = nil
+      redirect '/login'
+    end
+
+    get '/projects/add/new' do
+      project = DeepThought::Project.new
+
+      haml :"projects/new", :locals => {:project => project}
+    end
+
+    get '/project/add/new' do
+      redirect "/projects/add/new"
+    end
+
+    post '/projects/add/new' do
+      project = DeepThought::Project.new(params[:project])
+
+      if project.save
+        redirect '/'
+      else
+        settings.deep_thought_message = "Deep Thought has a problem with your request."
+        haml :"projects/new", :locals => {:project => project}
+      end
+    end
+
+    get '/projects/edit/:name' do
+      project = DeepThought::Project.find_by_name(params[:name])
+
+      haml :"projects/edit", :locals => {:project => project}
+    end
+
+    get '/project/edit/:name' do
+      redirect "/projects/edit/#{params[:name]}"
+    end
+
+    put '/projects/edit/:name' do
+      project = DeepThought::Project.find_by_name(params[:name])
+
+      if project.update_attributes(params[:project])
+        redirect "/projects/#{project.name}"
+      else
+        settings.deep_thought_message = "Deep Thought has a problem with your request."
+        haml :"projects/edit", :locals => {:project => project}
+      end
+    end
+
+    delete '/projects/delete/:name' do
+      project = DeepThought::Project.find_by_name(params[:name])
+
+      project.destroy
+
+      redirect '/'
+    end
+
+    get '/projects/:name' do
+      project = DeepThought::Project.find_by_name(params[:name])
+      branches = DeepThought::Git.get_list_of_branches(project) || []
+
+      if branches.include?('master')
+        branches.unshift(branches.slice!(branches.index('master')))
+      end
+
+      deploy = DeepThought::Deploy.new
+
+      settings.deep_thought_message = "Now pondering: #{project.name}."
+
+      haml :"projects/show", :locals => {:project => project, :branches => branches, :deploy => deploy}
+    end
+
+    get '/project/:name' do
+      redirect "/projects/#{params[:name]}"
+    end
+
+    get '/projects/:name/deploys' do
+      project = DeepThought::Project.find_by_name(params[:name])
+      deploys = project.deploys.order('created_at DESC')
+
+      settings.deep_thought_message = "Now remembering: #{project.name}."
+
+      haml :"history/index", :locals => {:project => project, :deploys => deploys}
+    end
+
+    get '/project/:name/deploys' do
+      redirect "/projects/#{params[:name]}/deploys"
+    end
+
+    get '/projects/:name/deploys/:id' do
+      project = DeepThought::Project.find_by_name(params[:name])
+      deploy = project.deploys.find(params[:id])
+
+      settings.deep_thought_message = "Now remembering #{project.name} deploy: #{deploy.id}."
+
+      haml :"history/show", :locals => {:project => project, :deploy => deploy}
+    end
+
+    get '/projects/:name/deploy/:id' do
+      redirect "/projects/#{params[:name]}/deploys/#{params[:id]}"
+    end
+
+    get '/project/:name/deploys/:id' do
+      redirect "/projects/#{params[:name]}/deploys/#{params[:id]}"
+    end
+
+    get '/project/:name/deploy/:id' do
+      redirect "/projects/#{params[:name]}/deploys/#{params[:id]}"
+    end
+
+    post '/projects/:name/deploy' do
+      project = DeepThought::Project.find_by_name(params[:name])
+      branches = DeepThought::Git.get_list_of_branches(project) || []
+
+      if branches.include?('master')
+        branches.unshift(branches.slice!(branches.index('master')))
+      end
+
+      options = {}
+      options[:branch] = params[:deploy][:branch]
+      options[:environment] = params[:deploy][:environment] if !params[:deploy][:environment].blank?
+      options[:box] = params[:deploy][:box] if !params[:deploy][:box].blank?
+
+      if params[:deploy][:actions]
+        actions = params[:deploy][:actions]
+        actions.reject!(&:empty?).blank?
+
+        if actions.count > 0
+          options[:actions] = actions
+        end
+      end
+
+      if params[:deploy][:variables]
+        vars = params[:deploy][:variables]
+        keys = vars[:keys]
+        values = vars[:values]
+
+        variables = Hash[keys.zip(values)]
+        variables.reject! { |k, v| k == '' }
+        variables.reject! { |k, v| v == '' }
+
+        if variables.count > 0
+          options[:variables] = variables
+        end
+      end
+
+      begin
+        DeepThought::Deployer.create(project, current_user, 'web', options)
+
+        redirect "/projects/#{params[:name]}"
+      rescue => e
+        if ENV['RACK_ENV'] != 'test'
+          puts e.inspect
+          puts e.backtrace
+        end
+
+        settings.deep_thought_message = e.message
+        haml :"projects/show", :locals => {:project => project, :branches => branches}
+      end
+    end
+
+    get '/users' do
+      users = DeepThought::User.all
+
+      settings.deep_thought_message = "Deep Thought loves you."
+
+      haml :"users/index", :locals => {:users => users}
+    end
+
+    get '/users/new' do
+      user = DeepThought::User.new
+
+      haml :"users/new", :locals => {:user => user}
+    end
+
+    post '/users/new' do
+      user = DeepThought::User.new(params[:user])
+
+      if user.save
+        redirect '/users'
+      else
+        settings.deep_thought_message = "Deep Thought has a problem with your request."
+        haml :"users/new", :locals => {:user => user}
+      end
+    end
+
+    get '/users/:id' do
+      user = User.find(params[:id])
+
+      settings.deep_thought_message = "Deep Thought loves you."
+
+      haml :"users/show", :locals => {:user => user}
+    end
+
+    put '/users/:id' do
+      user = DeepThought::User.find(params[:id])
+
+      if user.update_attributes(params[:user])
+        redirect '/users'
+      else
+        settings.deep_thought_message = "Deep Thought has a problem with your request."
+        haml :"users/show", :locals => {:user => user}
+      end
+    end
+
+    delete '/users/:id' do
+      user = DeepThought::User.find(params[:id])
+
+      user.destroy
+
+      redirect '/users'
+    end
+
+    post '/users/:id/key' do
+      user = DeepThought::User.find(params[:id])
+
+      user.generate_api_key
+
+      redirect "/users/#{params[:id]}"
+    end
+
+    get '/deploying' do
+      pass unless is_json?
+
+      json :deploying => DeepThought::Deployer.is_deploying?
+    end
+
+    get '*' do
+      redirect '/'
+    end
+
+    helpers do
+      def csrf_tag
+        Rack::Csrf.csrf_tag(env)
+      end
+
+      def current_user
+        @current_user ||= User.find(session[:user_id]) if session[:user_id]
+      end
+
+      def current_route(item)
+        path = request.path_info
+
+        case item
+        when 'projects'
+          if path == '/' or path =~ %r{/projects}
+            "current"
+          end
+        when 'users'
+          unless path == "/users/#{@current_user.id}"
+            if path =~ %r{/users}
+              "current"
+            end
+          end
+        when 'me'
+          if path == "/users/#{@current_user.id}"
+            "current"
+          end
+        end
+      end
+
+      def is_json?
+        is_json = false
+
+        request.accept.each do |a|
+          is_json = true if a.to_s == 'application/json'
+        end
+
+        is_json
+      end
+
+      def is_deploying?
+        if DeepThought::Deployer.is_deploying?
+          settings.deep_thought_message = "Deep Thought is deploying..."
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end