houston-core 0.5.0.beta1

data/lib/core_ext/duration.rb

@@ -0,0 +1,21 @@
+require "active_support/duration"
+
+
+module DurationExtensions
+  
+  def from(*args)
+    since(*args)
+  end
+  
+  def after(*args)
+    since(*args)
+  end
+  
+  def before(*args)
+    ago(*args)
+  end
+  
+end
+
+
+ActiveSupport::Duration.send(:include, DurationExtensions)

data/lib/core_ext/exception.rb

@@ -0,0 +1,7 @@
+# Allow exception handlers to add information
+# to an exception for upstream
+class Exception
+  def additional_information
+    @additional_information ||= {}
+  end
+end

data/lib/core_ext/hash.rb

@@ -0,0 +1,51 @@
+module CoreExt
+  module Hash
+    
+    
+    
+    def pick(*picks)
+      picks = picks.flatten
+      
+      mapped_picks = {}
+      picks.each do |pick|
+        if pick.is_a?(Hash)
+          mapped_picks.merge!(pick)
+        else
+          mapped_picks[pick] = pick
+        end
+      end
+      
+      mapped_picks.inject({}) do |result, (key, new_key)|
+        result[new_key] = self[key] if self.key?(key)
+        result
+      end
+    end
+    
+    
+    
+    def pick!(*picks)
+      picks = picks.flatten
+      keys.each {|key| self.delete(key) unless picks.member?(key) }
+    end
+    
+    
+    
+    def except(*picks)
+      result = self.dup
+      result.except!(*picks)
+      result
+    end
+    
+    
+    
+    def except!(*picks)
+      picks = picks.flatten
+      keys.each {|key| self.delete(key) if picks.member?(key) }
+    end
+    
+    
+    
+  end
+end
+
+Hash.send :include, CoreExt::Hash

data/lib/core_ext/kernel.rb

@@ -0,0 +1,23 @@
+module Kernel
+
+  def exceptions_wrapping(error_class)
+    m = Module.new
+    (class << m; self; end).instance_eval do
+      define_method(:===) do |err|
+        err.respond_to?(:original_exception) && error_class === err.original_exception
+      end
+    end
+    m
+  end
+
+  def exceptions_matching(matcher)
+    m = Module.new
+    (class << m; self; end).instance_eval do
+      define_method(:===) do |err|
+        err.message =~ matcher
+      end
+    end
+    m
+  end
+
+end

data/lib/houston/application.rb

@@ -0,0 +1 @@
+require_relative File.expand_path("../../../config/application", __FILE__)

data/lib/houston/version.rb

@@ -0,0 +1,3 @@
+module Houston
+  VERSION = "0.5.0.beta1"
+end

data/lib/houston_daemonize.rb

@@ -0,0 +1,37 @@
+module Houston
+
+  def self.daemonize(name)
+    unless Houston.server? or ENV["HOUSTON_DAEMONS"].to_s.split(",").member?(name)
+      puts "\e[94m[daemon:#{name}] Skipping daemon since we're not running as a server\e[0m" if Rails.env.development?
+      Rails.logger.info "\e[94m[daemon:#{name}] Skipping daemon since we're not running as a server\e[0m"
+      return
+    end
+
+    puts "\e[94m[daemon:#{name}] Connecting\e[0m" if Rails.env.development?
+    Rails.logger.info "\e[94m[daemon:#{name}] Connecting\e[0m"
+    Thread.new do
+      begin
+        connected_at = Time.now
+        Houston.observer.fire "daemon:#{name}:start"
+        yield
+
+      rescue Exception
+        puts "\e[91m#{$!.class}: #{$!.message}\e[0m" if Rails.env.development?
+        Houston.report_exception $!
+        unless (Time.now - connected_at) < 60
+          Houston.observer.fire "daemon:#{name}:restart"
+          retry
+        end
+      end
+
+      # This should never happen
+      puts "\e[31m[daemon:#{name}] Disconnected\e[0m" if Rails.env.development?
+      Rails.logger.error "\e[31m[daemon:#{name}] Disconnected\e[0m"
+
+      # http://stackoverflow.com/a/3516003/731300
+      Rails.logger.flush
+      Houston.observer.fire "daemon:#{name}:stop"
+    end
+  end
+
+end

data/lib/houston_observer.rb

@@ -0,0 +1,69 @@
+require "thread_safe"
+
+module Houston
+  class Observer
+
+    def initialize
+      @async = true
+      clear!
+    end
+
+    attr_accessor :async
+
+    def on(event, &block)
+      observers_of(event).push(block)
+      nil
+    end
+
+    def once(event, &block)
+      wrapped_block = Proc.new do |*args|
+        block.call(*args)
+        observers_of(event).delete wrapped_block
+      end
+      on(event, &wrapped_block)
+    end
+
+    def observed?(event)
+      observers_of(event).any?
+    end
+
+    def fire(event, *args)
+      invoker = async ? method(:invoke_callback_async) : method(:invoke_callback)
+      observers_of(event).each do |block|
+        invoker.call(event, block, *args)
+      end
+      nil
+    end
+
+    def clear!
+      @observers = {}
+    end
+
+  private
+
+    def invoke_callback_async(event, block, *args)
+      Thread.new do
+        begin
+          invoke_callback(event, block, *args)
+        ensure
+          ActiveRecord::Base.clear_active_connections!
+          Rails.logger.flush # http://stackoverflow.com/a/3516003/731300
+        end
+      end
+    end
+
+    def invoke_callback(event, block, *args)
+      block.call(*args)
+    rescue Exception # rescues StandardError by default; but we want to rescue and report all errors
+      $!.additional_information[:event] = event
+      Houston.report_exception($!)
+    end
+
+    def observers_of(event)
+      observers[event] ||= ThreadSafe::Array.new
+    end
+
+    attr_reader :observers
+
+  end
+end

data/lib/houston_server.rb

@@ -0,0 +1,31 @@
+module Houston
+  
+  def self.server?
+    !!server
+  end
+  
+  def self.server
+    @server ||= discover_server
+  end
+  
+private
+  
+  def self.discover_server
+    if defined?(::PhusionPassenger)
+      :passenger
+    elsif defined?(::Unicorn) && defined?(::Unicorn::HttpServer) && in_object_space?(::Unicorn::HttpServer)
+      :unicorn
+    else
+      $WEB_SERVER
+    end
+  end
+  
+  def self.in_object_space?(klass)
+    ObjectSpace.each_object(klass).any?
+  end
+  
+end
+
+if Houston.server?
+  puts "\e[94mRunning as a #{Houston.server.inspect} application\e[0m"
+end

data/lib/parallel_enumerable.rb

@@ -0,0 +1,56 @@
+module Enumerable
+  
+  def parallel
+    ParallelEnumerable.new(self)
+  end
+  
+end
+
+class ParallelEnumerable
+  
+  def initialize(enumerable)
+    @enumerable = enumerable
+  end
+  
+  
+  
+  def each
+    enumerable.map do |item|
+      Thread.new do
+        begin
+          yield item
+        rescue Exception # rescues StandardError by default; but we want to rescue and report all errors
+          Houston.report_exception $!
+        ensure
+          ActiveRecord::Base.clear_active_connections!
+        end
+      end
+    end.each(&:join)
+  end
+  
+  def map
+    queue = Queue.new
+    
+    each do |item|
+      queue << yield(item)
+    end
+    
+    [].tap do |results|
+      results.push queue.pop until queue.empty?
+    end
+  end
+  
+  
+  
+  def method_missing(method_name, *args, &block)
+    return super unless enumerable.respond_to?(method_name)
+    
+    $stderr.puts "[parallel-enumerable] ##{method_name} is not defined"
+    enumerable.public_send(method_name, *args, &block)
+  end
+  
+private
+  
+  attr_reader :enumerable
+  
+end

data/lib/patches/sprockets_output_path_for_assets.rb

@@ -0,0 +1,29 @@
+# Sprockets 2.x constructs the path where assets are compiled to like this:
+#
+#   Rails.root + "public/assets"
+#
+# Rails.root is always the path to _this_ project, Houston Core.
+#
+# Sprockets 3.x constructs the path where assets are compiled to like this:
+#
+#  Rails.public_path + "assets"
+#
+# This is more desirable because Houston can configure the public path
+# to be relative to the root of the instance of Houston. So we backport
+# that change to Sprockets here.
+
+require "sprockets/rails/task"
+
+module Patches
+  module SprocketsOutputPathForAssets
+    def output
+      if app
+        File.join(app.paths["public"].first, app.config.assets.prefix)
+      else
+        super
+      end
+    end
+  end
+end
+
+Sprockets::Rails::Task.send :prepend, Patches::SprocketsOutputPathForAssets

data/lib/tasks/config.rake

@@ -0,0 +1,255 @@
+module ConfigSanitizer
+  
+  def replace_value!(name, value)
+    gsub! /^  #{name} .*$/, "  #{name} #{value.inspect}"
+  end
+  
+  def replace_block!(name, value, comment_out: false)
+    value = value.rstrip
+    if comment_out
+      value = "  \# #{name}\\1do\\2\n#{value.gsub(/^  /, '  # ')}\n  \# end"
+    else
+      value = "  #{name}\\1do\\2\n#{value}\n  end"
+    end
+    gsub! /^  #{name}([^\n]+)do( \|[^\|]+\|)?\n.*?^  end/m, value
+  end
+  
+  def remove!(text)
+    gsub! text, ''
+  end
+  
+  def insert_after!(regex, text)
+    gsub! /(#{regex})/, "\\1\n#{text.chomp}"
+  end
+  
+  def remove_block!(name)
+    gsub! /^  #{name}[^\n]+do( \|[^\|]+\|)?\n.*?^  end\s*/m, '  '
+  end
+  
+end
+
+namespace :config do
+  
+  desc "Generate config.sample.rb from config.rb"
+  task :generate do
+    config = File.read Rails.root.join("config", "config.rb")
+    config.extend ConfigSanitizer # Strip out sensitive information
+    
+    
+    
+    # GENERAL
+    config.replace_value! :host, "houston.my-company.com"
+    config.replace_value! :mailer_sender, "houston@my-company.com"
+    config.replace_value! :passphrase, "Keep it secret! Keep it safe."
+    config.replace_value! :parallelization, :on
+    config.replace_block! :smtp, <<-TEXT
+    address "10.10.10.10"
+    port 25
+    domain "10.10.10.10"
+    TEXT
+    config.replace_block! :s3, <<-TEXT, comment_out: true
+    access_key ACCESS_KEY
+    secret SECRET
+    bucket "houston-\#{ENV["RAILS_ENV"] || "development"}"
+    TEXT
+    
+    
+    
+    # MODULES
+    config.replace_block! 'use :scheduler', <<-TEXT, comment_out: true
+    planning_poker :off
+    estimate_effort :off
+    estimate_value :off
+    mixer :off
+    TEXT
+    config.replace_block! 'use :alerts', <<-TEXT
+    workers { User.developers }
+
+    sync :all, "ue", every: "75s", first_in: "15s" do
+      app_project_map = Hash[Project
+        .where(error_tracker_name: "Errbit")
+        .pluck("cast(extended_attributes->'errbit_app_id' as integer)", :id)]
+
+      Houston::Adapters::ErrorTracker::ErrbitAdapter \\
+        .all_problems(app_id: app_project_map.keys)
+        .map { |problem|
+          key = problem.id.to_s
+          key << "-\#{problem.opened_at.to_i}"
+          { key: key,
+            project_id: app_project_map[problem.app_id],
+            summary: problem.message,
+            closed_at: problem.resolved_at,
+            url: problem.url
+          } }
+    end
+
+    sync :open, "cve", every: "5m", first_in: "30s" do
+      Gemnasium::Alert.open
+        .map { |alert|
+          advisory = alert["advisory"]
+          { key: "\#{alert["project_slug"]}-\#{advisory["id"]}",
+            project_slug: alert["project_slug"],
+            summary: advisory["title"],
+            url: "https://gemnasium.com/\#{alert["project_id"]}/alerts#advisory_\#{advisory["id"]}"
+          } }
+    end
+    TEXT
+    config.insert_after! /^  use :itsm.*/, <<-TEXT
+  # use :kanban, github: "houston/houston-kanban", branch: "master" do
+  #   queues do
+  #     unprioritized do
+  #       name "To Prioritize"
+  #       description "Tickets for <b>Product Owners</b> to prioritize"
+  #       where { |tickets| tickets.unresolved.able_to_prioritize.unprioritized }
+  #     end
+  # 
+  #     unestimated do
+  #       name "To Estimate"
+  #       description "Tickets for <b>Developers</b> to estimate"
+  #       where { |tickets| tickets.unresolved.able_to_estimate.unestimated }
+  #     end
+  # 
+  #     sprint do
+  #       name "Sprint"
+  #       description "Tickets left in the current sprint"
+  #       where { |tickets| tickets.unresolved.in_current_sprint }
+  #     end
+  # 
+  #     testing do
+  #       name "To Test"
+  #       description "Tickets for <b>Testers</b> to test"
+  #       where { |tickets| tickets.resolved.open.deployed }
+  #     end
+  # 
+  #     staging do
+  #       name "To Release"
+  #       description "Tickets ready for <b>Maintainers</b> to deploy"
+  #       where { |tickets| tickets.closed.fixed.unreleased }
+  #     end
+  #   end
+  # end
+    TEXT
+    config.remove! /^  use :itsm,[^\n]+\n/
+    config.remove! /^  use :reports,[^\n]+\n/
+    config.remove! /^  use :support_form,[^\n]+\n/
+    config.remove! /^  gem "star",[^\n]+\n/
+    
+    
+    
+    # INTEGRATIONS
+    config.replace_block! "authentication_strategy :ldap", <<-TEXT, comment_out: true
+    host "10.10.10.10"
+    port 636
+    base "ou=people,dc=example,dc=com"
+    ssl :simple_tls
+    username_builder Proc.new { |attribute, login, ldap| "\#{login}@example.com" }
+    TEXT
+    config.replace_block! "ticket_tracker :unfuddle", <<-TEXT, comment_out: true
+    subdomain "UNFUDDLE_SUBDOMAIN"
+    username "UNFUDDLE_USERNAME"
+    password "UNFUDDLE_PASSWORD"
+    
+    identify_tags lambda { |ticket|
+      # ...
+    }
+    
+    identify_type lambda { |ticket|
+      # ...
+    }
+    
+    attributes_from_type lambda { |ticket|
+      # ...
+    }
+    TEXT
+    config.replace_block! "ticket_tracker :github", <<-TEXT, comment_out: true
+    identify_tags lambda { |ticket|
+      # ...
+    }
+    
+    identify_type lambda { |ticket|
+      # ...
+    }
+    
+    attributes_from_type lambda { |ticket|
+      # ...
+    }
+    TEXT
+    config.replace_block! "ci_server :jenkins", <<-TEXT, comment_out: true
+    host "jenkins.example.com"
+    username "JENKINS_USERNAME"
+    password "JENKINS_PASSWORD"
+    TEXT
+    config.replace_block! "error_tracker :errbit", <<-TEXT, comment_out: true
+    host "errbit.example.com"
+    port 443
+    auth_token "ERRBIT_AUTH_TOKEN"
+    TEXT
+    config.replace_block! "github", <<-TEXT, comment_out: true
+    access_token "GITHUB_ACCESS_TOKEN"
+    key "GITHUB_OAUTH_KEY"
+    secret "GITHUB_OAUTH_SECRET"
+    
+    # If you specify a GitHub organization, Houston can
+    # grab Pull Requests for that organization and put them
+    # into your To-Do Lists.
+    # organization "GITHUB_ORGANIZATION"
+    TEXT
+    config.replace_block! "gemnasium", <<-TEXT, comment_out: true
+    api_key "GEMNASIUM_API_KEY"
+    TEXT
+    
+    
+    
+    # EVENTS
+    config.remove_block! 'on "deploy:completed"'
+    config.remove_block! 'on "hooks:mailgun_complaint"'
+    config.remove_block! 'on "testing_note:create"'
+    config.remove_block! 'on "test_run:complete"'
+    config.remove_block! 'on "ticket:release"'
+    config.remove_block! 'on "scheduler:shutdown"'
+    config.remove_block! 'on "alert:itsm:create"'
+    config.replace_block! 'on "boot"', <<-TEXT, comment_out: true
+    Airbrake.configure do |config|
+      config.api_key          = AIRBRAKE_API_KEY
+    end
+    TEXT
+    config.replace_block! 'on "alert:assign"', <<-TEXT, comment_out: true
+    EXAMPLE
+    Put code here to notify the developer who
+    has been assigned the alert via Slack or Campfire.
+    TEXT
+    config.replace_block! 'on "alert:create"', <<-TEXT, comment_out: true
+    EXAMPLE
+    Put code here to assign the alert to a developer
+    based on the alert's project or content.
+    TEXT
+    
+    
+    
+    # BACKGROUND JOBS
+    config.replace_block! 'at "6:40am", "report:alerts", every: :weekday', <<-TEXT
+    Houston::Alerts::Mailer.deliver_to!(User.pluck(:email))
+    TEXT
+    
+    
+    
+    # OTHER
+    config.replace_block! :identify_committers, <<-TEXT
+    [commit.committer_email]
+    TEXT
+    config.replace_block! "parse_ticket_description", <<-TEXT, comment_out: true
+    This block is invoked whenever a ticket's description is changed,
+    allowing you to parse its contents and trigger behavior when
+    certain patterns are recognized.
+    TEXT
+    
+    
+    
+    # Remove all the globals and other stuff at the end of the config file
+    config.gsub! /^end.*\Z/m, "end\n"
+    
+    File.open Rails.root.join("config", "config.sample.rb"), "w" do |f|
+      f.write(config)
+    end
+  end
+end