houston-core 0.7.0.beta3 → 0.7.0.beta4

data/lib/houston/boot/observer.rb

@@ -2,35 +2,53 @@ require "thread_safe"
 
 module Houston
   class Observer
+    attr_accessor :async
+
+    class UnregisteredEventError < ArgumentError; end
+    class MissingParamError < ArgumentError; end
+    class UnregisteredParamError < ArgumentError; end
 
     def initialize
       @async = true
       clear!
     end
 
-    attr_accessor :async
+    def on(event, options={}, &block)
+      assert_registered! event
+      observers_of(event).push Callback.new(self, event, options, block)
+      nil
+    end
 
-    def on(event, &block)
-      observers_of(event).push(block)
+    def once(event, options={}, &block)
+      assert_registered! event
+      observers_of(event).push CallbackOnce.new(self, event, options, 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)
+    def off(callback)
+      observers_of(callback.event).delete callback
+      nil
     end
 
     def observed?(event)
+      assert_registered! 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)
+    def fire(event, params={})
+      assert_registered! event
+
+      unless params.is_a?(Hash)
+        raise ArgumentError, "params must be a Hash" unless params.respond_to?(:to_h)
+        params = params.to_h
+      end
+
+      assert_registered_params! event, params
+      assert_serializable! params
+      params = ReadonlyHash.new(params)
+
+      observers_of(event).each do |callback|
+        callback.call params
       end
       nil
     end
@@ -40,25 +58,105 @@ module Houston
     end
 
   private
+    attr_reader :observers
+
+    def observers_of(event)
+      observers[event] ||= ThreadSafe::Array.new
+    end
 
-    def invoke_callback_async(event, block, *args)
-      Houston.async do
-        invoke_callback(event, block, *args)
+    def assert_registered!(event_name)
+      return if Houston.registered_event?(event_name)
+      raise UnregisteredEventError, "#{event_name.inspect} is not a registered event"
+    end
+
+    def assert_registered_params!(event_name, params)
+      event = Houston.get_registered_event(event_name)
+
+      missing_params = event.params - params.keys.map(&:to_s)
+      unregistered_params = params.keys.map(&:to_s) - event.params
+      if missing_params.any?
+        raise MissingParamError, "#{missing_params.first.inspect} is a required param of the event #{event_name.inspect}"
+      end
+      if unregistered_params.any?
+        raise UnregisteredParamError, "#{unregistered_params.first.inspect} is a not a registered param of the event #{event_name.inspect}"
       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($!)
+    def assert_serializable!(params)
+      Houston::Serializer.new.assert_serializable!(params)
     end
 
-    def observers_of(event)
-      observers[event] ||= ThreadSafe::Array.new
+
+
+    class Callback
+      attr_reader :observer, :event
+
+      def initialize(observer, event, options, block)
+        @observer = observer
+        @event = event
+        @invoke_async = options.fetch(:async, nil)
+        @raise_exceptions = options.fetch(:raise, false)
+        @block = block
+      end
+
+      def invoke_async?
+        return @invoke_async unless @invoke_async.nil?
+        Houston.observer.async
+      end
+
+      def raise_exceptions?
+        @raise_exceptions
+      end
+
+      def call(params)
+        Houston.async(invoke_async?) do
+          begin
+            @block.call(params)
+
+          rescue Exception # rescues StandardError by default; but we want to rescue and report all errors
+            raise if raise_exceptions?
+
+            $!.additional_information[:event] = event
+            $!.additional_information[:async] = invoke_async?
+            $!.additional_information[:raise_exceptions] = raise_exceptions?
+            Houston.report_exception($!)
+          end
+        end
+      end
+
     end
 
-    attr_reader :observers
+    class CallbackOnce < Callback
+      def call(params)
+        observer.off self
+        super
+      end
+    end
+
+  end
+
+
+
+  class ReadonlyHash
+
+    def initialize(hash)
+      @hash = hash.symbolize_keys
+      @hash.keys.each do |key|
+        define_singleton_method(key) { @hash[key] }
+      end
+    end
+
+    def [](key)
+      @hash[key.to_sym]
+    end
+
+    def count
+      @hash.count
+    end
+
+    def to_h
+      @hash.dup
+    end
 
   end
 end

data/lib/houston/boot/readonly_hash_serializer.rb

@@ -0,0 +1,15 @@
+module Houston
+  class ReadonlyHashSerializer
+
+    def applies_to?(object)
+      object.is_a?(Houston::ReadonlyHash)
+    end
+
+    def pack(object)
+      object.to_h
+    end
+
+  end
+end
+
+Houston.add_serializer Houston::ReadonlyHashSerializer.new

data/lib/houston/boot/serializer.rb

@@ -0,0 +1,83 @@
+require "oj"
+
+Oj.register_odd(Date, Date, :iso8601, :iso8601)
+Oj.register_odd(DateTime, DateTime, :iso8601, :iso8601)
+
+module Houston
+  class Serializer
+    class UnserializableError < ArgumentError; end
+
+    def load(string)
+      unpack Oj.load(string, nilnil: true, auto_define: false)
+    end
+
+    def dump(object)
+      Oj.dump pack(object)
+    end
+
+    def assert_serializable!(object)
+      pack(object); nil
+    end
+
+  private
+
+    def unpack(object)
+      if object.is_a?(Array)
+        object.map { |item| unpack(item) }
+      elsif object.is_a?(Hash)
+        object = object.each_with_object({}) { |(key, value), new_object| new_object[key] = unpack(value) }
+        if serializer = object["^S"]
+          object = serializer.constantize.new.unpack(object)
+        end
+        object
+      else
+        object
+      end
+    end
+
+    def pack(object)
+      case object
+      when Array
+        object.map { |item| pack(item) }
+      when Hash
+        object.each_with_object({}) do |(key, value), new_object|
+          unless key.is_a?(String) || key.is_a?(Symbol)
+            raise UnserializableError, "Hash keys must be either strings or symbols"
+          end
+          new_object[key] = pack(value)
+        end
+      when ActiveSupport::TimeWithZone
+        object.to_datetime
+      when *SERIALIZABLE_TYPES
+        object
+      else
+        Houston.serializers.each do |serializer|
+          next unless serializer.applies_to?(object)
+          packed_object = serializer.pack(object)
+          packed_object.merge!("^S" => serializer.class.name) if serializer.respond_to?(:unpack)
+          return pack(packed_object)
+        end
+
+        raise UnserializableError, <<-STR.squish
+          Unable to serialize a #{object.class} (#{object.inspect})
+          You can add a serializer for it with `Houston.add_serializer`
+        STR
+      end
+    end
+
+    SERIALIZABLE_TYPES = [
+      BigDecimal,
+      Date,
+      DateTime,
+      FalseClass,
+      Fixnum,
+      Float,
+      NilClass,
+      String,
+      Symbol,
+      Time,
+      TrueClass
+    ].freeze
+
+  end
+end

data/lib/houston/boot/ticket_antecedent_serializer.rb

@@ -0,0 +1,21 @@
+module Houston
+  class TicketAntecedentSerializer
+
+    def applies_to?(object)
+      object.is_a?(TicketAntecedent)
+    end
+
+    def pack(antecedent)
+      { "ticket_or_commit" => antecedent.ticket_or_commit,
+        "kind" => antecedent.kind,
+        "id" => antecedent.id }
+    end
+
+    def unpack(object)
+      TicketAntecedent.new *object.values_at("ticket_or_commit", "kind", "id")
+    end
+
+  end
+end
+
+Houston.add_serializer Houston::TicketAntecedentSerializer.new

data/lib/houston/boot/timer.rb

@@ -0,0 +1,45 @@
+require "thread_safe"
+
+module Houston
+  class Timer
+
+    def initialize
+      @queued_timers = ThreadSafe::Array.new
+
+      Houston.observer.on "daemon:scheduler:start", raise: true do
+        schedule_queued_timers!
+      end
+    end
+
+    def at(time, &block)
+      return schedule_later :at, time, block unless $scheduler
+
+      days_of_the_week = :day
+      days_of_the_week, time = *time if time.is_a?(Array)
+      cronline = Whenever::Output::Cron.new(days_of_the_week, nil, time)
+      $scheduler.cron cronline.time_in_cron_syntax, &block
+    end
+
+    def every(interval, &block)
+      return schedule_later :every, interval, block unless $scheduler
+
+      $scheduler.every interval, &block
+    end
+
+  private
+
+    attr_reader :queued_timers
+
+    def schedule_later(*args)
+      queued_timers.push args
+    end
+
+    def schedule_queued_timers!
+      while timer = queued_timers.pop
+        method_name, value, block = timer
+        public_send method_name, value, &block
+      end
+    end
+
+  end
+end

data/lib/houston/boot/triggers.rb

@@ -0,0 +1,75 @@
+require "thread_safe"
+require "delegate"
+
+module Houston
+  class DuplicateTriggerError < ArgumentError; end
+
+
+  class Triggers < SimpleDelegator
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+      super ThreadSafe::Array.new
+    end
+
+
+    def at(value, action, params={})
+      push build(:at, value, action, params)
+    end
+
+    def every(value, action, params={})
+      push build(:every, value, action, params)
+    end
+
+    def on(event, action, params={})
+      push build(:on, event, action, params)
+    end
+
+    def build(method_name, value, action, params)
+      Trigger.new(self, method_name, value, action, params)
+    end
+
+    def push(trigger)
+      raise DuplicateTriggerError, "That exact trigger has already been defined" if member?(trigger)
+      super trigger
+      trigger.register!
+      trigger
+    end
+
+  end
+
+
+  class Trigger < Struct.new(:method_name, :value, :action, :params)
+
+    def initialize(triggers, *args)
+      @triggers = triggers
+      super *args
+    end
+
+    def register!
+      case method_name
+      when :at then config.timer.at(value, &method(:call))
+      when :every then config.timer.every(value, &method(:call))
+      when :on then config.observer.on(value, &method(:call))
+      else raise NotImplementedError, "Unrecognized method name: #{method_name.inspect}"
+      end
+    end
+
+    def call(params={})
+      config.actions.run action, self.params.merge(params.to_h), trigger: to_s
+    end
+
+    def to_s
+      "#{method_name}(#{value})"
+    end
+
+  private
+    attr_reader :triggers
+
+    def config
+      triggers.config
+    end
+
+  end
+end

data/lib/houston/boot.rb

@@ -2,3 +2,8 @@ require "houston/boot/configuration"
 require "houston/boot/server"
 require "houston/boot/daemonize"
 require "houston/boot/extensions"
+require "houston/boot/events"
+
+require "houston/boot/active_record_serializer"
+require "houston/boot/readonly_hash_serializer"
+require "houston/boot/ticket_antecedent_serializer"

data/lib/houston/version.rb

@@ -1,3 +1,3 @@
 module Houston
-  VERSION = "0.7.0.beta3"
+  VERSION = "0.7.0.beta4"
 end

data/lib/params_serializer.rb

@@ -0,0 +1,18 @@
+require "houston/boot/serializer"
+
+module Houston
+  class ParamsSerializer < Serializer
+
+    def load(string)
+      super(string || "{}")
+    end
+
+    def dump(object)
+      object = {} if object.nil?
+      object = object.to_h if !object.is_a?(Hash) && object.respond_to?(:to_h)
+      raise ArgumentError, "params must be a Hash, but it is a #{object.class}" unless object.is_a?(Hash)
+      super object
+    end
+
+  end
+end

data/lib/tasks/actions.rake

@@ -0,0 +1,12 @@
+namespace :houston do
+  desc "Lists actions"
+  task :actions do
+    actions = Houston.actions.to_a
+    longest_name = actions.map { |action| action.name.length }.max
+    longest_params = actions.map { |action| action.required_params.join(", ").length }.max
+    actions.sort_by(&:name).each do |action|
+      params = "#{action.required_params.join(", ")}" if action.required_params.any?
+      puts "  \e[36m#{action.name.ljust(longest_name)}\e[0m  \e[96m#{params.to_s.ljust(longest_params)}\e[0m"
+    end
+  end
+end

data/lib/tasks/events.rake

@@ -0,0 +1,11 @@
+namespace :houston do
+  desc "Lists registered events and their descriptions"
+  task :events do
+    longest_name = Houston.events.map { |event| event.name.length }.max
+    longest_params = Houston.events.map { |event| event.params.join(", ").length }.max
+    Houston.events.sort_by(&:name).each do |event|
+      params = "#{event.params.join(", ")}" if event.params.any?
+      puts "  \e[36m#{event.name.ljust(longest_name)}\e[0m  \e[96m#{params.to_s.ljust(longest_params)}\e[0m  #{event.description}"
+    end
+  end
+end

data/templates/new-instance/config/abilities.rb

@@ -39,9 +39,6 @@ Houston.config.abilities do |user|
     # Everyone can remove themselves from a role
     can :destroy, Role, user_id: user.id
 
-    # Everyone can edit their own testing notes
-    can [:update, :destroy], TestingNote, user_id: user.id
-
     # Developers can
     #  - create tickets
     #  - see other kinds of Release Changes (like Refactors)
@@ -54,12 +51,10 @@ Houston.config.abilities do |user|
     end
 
     # Testers and Developers can
-    #  - see and comment on all testing notes
     #  - create tickets
     #  - see and manage alerts
     if user.tester? or user.developer?
       can :create, Ticket
-      can [:create, :read], TestingNote
       can :manage, Houston::Alerts::Alert
     end
 
@@ -67,9 +62,6 @@ Houston.config.abilities do |user|
     roles = user.roles.participants
     if roles.any?
 
-      # Everyone can see and comment on Testing Reports for projects they are involved in
-      can [:create, :read], TestingNote, project_id: roles.pluck(:project_id)
-
       # Maintainers can manage Releases, close Tickets, and update Projects
       roles.maintainers.pluck(:project_id).tap do |project_ids|
         can :manage, Release, project_id: project_ids

data/templates/new-instance/config/{triggers → events}/alerts/slack_when_assigned.rb

@@ -1,5 +1,5 @@
 Houston.config do
-  on "alert:assign" do |alert|
+  on "alert:assign" => "alert:slack-assignee-of-assignment" do
     if alert.checked_out_by && alert.updated_by && alert.checked_out_by != alert.updated_by
       Rails.logger.info "\e[34m[slack] #{alert.type} assigned to \e[1m#{alert.checked_out_by.first_name}\e[0m"
 

data/templates/new-instance/config/{triggers → events}/alerts/slack_when_opened.rb

@@ -1,6 +1,6 @@
 Houston.config do
   # Notify #alerts of new alerts
-  on "alert:create" do |alert|
+  on "alert:create" => "alert:announce-in-slack" do
     message =  "There's a new *#{alert.type}*"
     message << " for #{alert.project.slug}" if alert.project
     slack_send_message_to message, "#alerts", attachments: [slack_alert_attachment(alert)]

data/templates/new-instance/config/{triggers → events}/daemons/health.rb

@@ -1,21 +1,21 @@
 Houston.config do
-  on "daemon:scheduler:restart" do
+  on "daemon:scheduler:restart" => "daemon:announce-scheduler-restarted-in-slack" do
     slack_send_message_to "The thread running Rufus::Scheduler errored out and is attempting to recover", "general"
   end
 
-  on "daemon:scheduler:stop" do
+  on "daemon:scheduler:stop" => "daemon:announce-scheduler-stopped-in-slack" do
     slack_send_message_to ":rotating_light: The thread running Rufus::Scheduler has terminated", "general"
   end
 
-  on "daemon:slack:restart" do
+  on "daemon:slack:restart" => "daemon:announce-slack-restarted-in-slack" do
     slack_send_message_to "The thread running Slack errored out and is attempting to recover", "general"
   end
 
-  on "daemon:slack:stop" do
+  on "daemon:slack:stop" => "daemon:announce-slack-stopped-in-slack" do
     slack_send_message_to ":rotating_light: The thread running Slack has terminated", "general"
   end
 
-  on "slack:error" do |args|
-    slack_send_message_to "An error occurred\n#{args.inspect}", "general"
+  on "slack:error" => "slack:announce-error-in-slack" do
+    slack_send_message_to "An error occurred\n#{message}", "general"
   end
 end

data/templates/new-instance/config/{triggers → events}/deploy/autoresolve_errs.rb

@@ -1,4 +1,4 @@
-Houston.config.on "alert:err:deployed" do |alert, deploy, commit|
+Houston.config.on "alert:err:deployed" => "alert:autoresolve-err" do
   error_tracker = deploy.project.error_tracker
 
   message = "Resolved by Houston when "

data/templates/new-instance/config/{triggers → events}/deploy/checkout_mentioned_alerts.rb

@@ -1,4 +1,4 @@
-Houston.config.on "alert:deployed" do |alert, deploy, commit|
+Houston.config.on "alert:deployed" => "alert:assign-alert-to-committer" do
   next if alert.checked_out_by
   next unless committer = commit.committers.first
   alert.update_attribute :checked_out_by, committer

data/templates/new-instance/config/{triggers → events}/deploy/notify_deployer_when_finished.rb

@@ -1,6 +1,6 @@
 Houston.config do
-  on "deploy:completed" do |deploy|
-    next if deploy.build_release.ignore?
+  on "deploy:completed" => "deploy:slack-deployer-of-finished-deploy" do
+    next if deploy.build_releasignore?
 
     deployer = deploy.user
     if deployer

data/templates/new-instance/config/{triggers → events}/github/publish_comments_on_slack.rb

@@ -1,16 +1,16 @@
 Houston.config do
-  on "github:comment:created:commit" do |comment|
+  on "github:comment:commit:create" => "github:slack-when-commit-comment-created" do
     channel = "##{comment["project"].slug}" if comment["project"]
     channel = "developers" unless Houston::Slack.connection.channels.include? channel
     body, url = comment.values_at "body", "html_url"
 
     message = "#{comment["user"]["login"]} commented on #{slack_link_to(comment["commit_id"][0...7], url)}"
 
-    comment = { fallback: body, text: body }
-    slack_send_message_to message, channel, as: :github, attachments: [comment], test: true
+    attachment = { fallback: body, text: body }
+    slack_send_message_to message, channel, as: :github, attachments: [attachment]
   end
 
-  on "github:comment:created:diff" do |comment|
+  on "github:comment:diff:create" => "github:slack-when-diff-comment-created" do
     channel = "##{comment["project"].slug}" if comment["project"]
     channel = "developers" unless Houston::Slack.connection.channels.include? channel
     body, url = comment.values_at "body", "html_url"
@@ -18,11 +18,11 @@ Houston.config do
     message = "#{comment["user"]["login"]} commented on #{slack_link_to(comment["path"], url)}"
     message << "\n```\n#{comment["diff_hunk"]}\n```\n"
 
-    comment = { fallback: body, text: body }
-    slack_send_message_to message, channel, as: :github, attachments: [comment], test: true
+    attachment = { fallback: body, text: body }
+    slack_send_message_to message, channel, as: :github, attachments: [attachment]
   end
 
-  on "github:comment:created:pull" do |comment|
+  on "github:comment:pull:create" => "github:slack-when-issue-comment-created" do
     channel = "##{comment["project"].slug}" if comment["project"]
     channel = "developers" unless Houston::Slack.connection.channels.include? channel
     body, url = comment.values_at "body", "html_url"
@@ -30,7 +30,7 @@ Houston.config do
     issue = comment["issue"]
     message = "#{comment["user"]["login"]} commented on #{slack_link_to("##{issue["number"]} #{issue["title"]}", url)}"
 
-    comment = { fallback: body, text: body }
-    slack_send_message_to message, channel, as: :github, attachments: [comment], test: true
+    attachment = { fallback: body, text: body }
+    slack_send_message_to message, channel, as: :github, attachments: [attachment]
   end
 end

data/templates/new-instance/config/{triggers → events}/tests/slack_when_analyzed.rb

@@ -1,5 +1,5 @@
 Houston.config do
-  on "test_run:compared" do |test_run|
+  on "test_run:compared" => "test_run:slack-about-commits-that-introduced-regressions" do
     regressions = test_run.test_results.where(different: true, status: "fail").to_a
     next if regressions.none?
 

data/templates/new-instance/config/{triggers → events}/tests/slack_when_completed.rb

@@ -1,5 +1,5 @@
 Houston.config do
-  on "test_run:complete" do |test_run|
+  on "test_run:complete" => "test_run:slack-results" do
     # When branch is nil, the test run was requested by Houston
     # not triggered by a developer pushing changes to GitHub.
     next if test_run.branch.nil?

data/templates/new-instance/config/{triggers → events}/tickets/mark_tasks_completed_on_commit.rb

@@ -1,7 +1,7 @@
 # Treat tasks as completed when a commit mentioning them is pushed
 
 Houston.config do
-  on "task:committed" do |task|
+  on "task:committed" => "task:mark-completed" do
     task.completed!
   end
 end