sonar_connector 0.8.5

data/lib/sonar_connector/emailer.rb

@@ -0,0 +1,16 @@
+module Sonar
+  module Connector
+    class Emailer < ActionMailer::Base
+      def admin_message(connector, message)
+        from          Sonar::Connector::CONFIG.email_settings["admin_sender"]
+        recipients    Sonar::Connector::CONFIG.email_settings["admin_recipients"]
+        subject       "Admin email from Sonar Connector"
+        content_type  "text/plain"
+        body          <<-BODY
+Admin email from Sonar Connector. The connector '#{connector.name}' sent the following message:
+#{message}
+BODY
+      end
+    end
+  end
+end

data/lib/sonar_connector/rspec/spec_helper.rb

@@ -0,0 +1,61 @@
+require 'spec'
+require 'spec/autorun'
+require 'rr'
+
+Spec::Runner.configure do |config|
+  config.mock_with RR::Adapters::Rspec
+  
+  config.prepend_before(:each) do
+    
+    # This dir gets wiped after every spec run, so please - pretty please - 
+    # don't change it to anything that you care about.
+    def base_dir
+      "/tmp/sonar-connector/"
+    end
+    
+    # Note this path doesn't have to be real - it's just used to intercept calls 
+    # to the stubbed read_json_file method on Config
+    def valid_config_filename
+      "path to a valid config file"
+    end
+    
+    def setup_valid_config_file
+      @config_options = {
+        "log_level" => "error",
+        "base_dir" => base_dir,
+        "email_settings" => {
+          "admin_sender" => "noreply@example.local",
+          "admin_recipients" => ["admin@example.local"],
+          "perform_deliveries" => true,
+          "delivery_method" => "test",
+          "raise_delivery_errors" => true,
+          "save_emails_to_disk" => false
+        },
+        
+        "connectors" => [
+          "class" => "Sonar::Connector::DummyConnector",
+          "name" => "dummy1",
+          "repeat_delay" => 10
+        ]
+      }
+      stub(Sonar::Connector::Config).read_json_file(valid_config_filename){@config_options}
+      Sonar::Connector.send(:remove_const, "CONFIG") if defined?(Sonar::Connector::CONFIG)
+    end
+    
+    # This is slightly dangerous.
+    FileUtils.rm_rf(base_dir) if File.directory?(base_dir)
+    FileUtils.mkdir_p(base_dir)
+  end
+  
+end
+
+
+# Creates an anonmyous throw-away class of type=parent, with an additional
+# proc for defining methods on the class. Tnx @mccraigmccraig :-)
+def new_anon_class(parent, name="", &proc)
+  klass = Class.new(parent)  
+  mc = klass.instance_eval{ class << self ; self ; end }
+  mc.send(:define_method, :to_s) {name}
+  klass.class_eval(&proc) if proc
+  klass
+end

data/lib/sonar_connector/status.rb

@@ -0,0 +1,43 @@
+module Sonar
+  module Connector
+    
+    # Represents the status and statistics collected by various connectors
+    # and is responsible for accessing, updating and persisting the status YAML file.
+    class Status
+      
+      def initialize(config)
+        @status_file = config.status_file
+        load_status
+      end
+      
+      def load_status
+        @status = YAML.load_file(status_file) rescue {}
+      end
+      
+      def save_status
+        File.open(status_file, 'w') { |f| f << status.to_yaml }
+      end
+      
+      def set(group, key, value)
+        status[group] = {} unless status[group]
+        status[group][key] = value
+        status[group]['last_updated'] = Time.now.to_s
+        save_status
+      end
+      
+      def [](group)
+        status[group]
+      end
+
+      def []=(group, hash)
+        status[group] = hash
+      end
+      
+      private
+      
+      attr_accessor :status_file
+      attr_accessor :status
+      
+    end
+  end
+end

data/lib/sonar_connector/utils.rb

@@ -0,0 +1,39 @@
+module Sonar
+  module Connector
+    module Utils
+      
+      #
+      # Disk usage utility. Returns amount of disk space 
+      # used in a given folder, in bytes.
+      def du(dir)
+        raise "#{dir} is not a directory" unless File.directory?(dir)
+        glob = File.join(dir, "**", "*")
+        Dir[glob].map {|f|
+          File.read(f).size rescue nil
+        }.compact.sum
+      end
+      
+      module_function :du
+      
+      def stdout_logger(base_config)
+        log = Logger.new STDOUT
+        log.level = base_config.log_level
+        log.formatter = Logger::Formatter.new
+        log.datetime_format = "%Y-%m-%d %H:%M:%S"
+        log
+      end
+      
+      module_function :stdout_logger
+      
+      def disk_logger(filename, base_config)
+        log = Logger.new filename, base_config.log_files_to_keep, base_config.log_file_max_size
+        log.level = base_config.log_level
+        log.formatter = Logger::Formatter.new
+        log.datetime_format = "%Y-%m-%d %H:%M:%S"
+        log
+      end
+      
+      module_function :disk_logger
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path("../../lib", __FILE__)
+
+require 'sonar_connector'
+require 'irb'
+
+CONTROLLER = Sonar::Connector::Controller.new
+CONTROLLER.prepare_connector
+IRB.start

data/spec/sonar_connector/commands/command_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Sonar::Connector::Command do
+  before do
+    @command
+  end
+  
+  describe "initialize" do
+    it "should set proc" do
+      proc = Proc.new {}
+      c = Sonar::Connector::Command.new(proc)
+      c.proc.should == proc
+    end
+  end
+  
+  describe "execute" do
+    it "should be run in context" do
+      
+      # create a context instance with a #do_it method
+      context = new_anon_class(Object, "MyContext"){
+        def do_it(instance)
+        end
+      }.new
+      
+      # the proc to run calls #do_it on self, and passes in self, which should be one and the same
+      proc = Proc.new { do_it(self) }
+      
+      # ensure that do_it gets called, and the self instance passed in is the context.
+      mock(context).do_it(context)
+      
+      Sonar::Connector::Command.new(proc).execute(context)
+    end
+  end
+end

data/spec/sonar_connector/commands/commit_seppuku_command_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Sonar::Connector::CommitSeppukuCommand do
+  
+  before do
+    @connector = Object.new
+    @controller = Object.new
+    stub(@connector).name{"name"}
+  end
+  
+  it "should update the disk usage statistic" do
+    @command = Sonar::Connector::CommitSeppukuCommand.new
+    
+    @context = Object.new
+    @status = Object.new
+    @shutdown_lambda = Object.new
+    
+    mock(@context).controller{@controller}
+    mock(@controller).shutdown_lambda{@shutdown_lambda}
+    mock(@shutdown_lambda).call
+    
+    @command.execute(@context)
+  end
+  
+end

data/spec/sonar_connector/commands/increment_status_value_command_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Sonar::Connector::IncrementStatusValueCommand do
+  before do
+    setup_valid_config_file
+    @base_config = Sonar::Connector::Config.load valid_config_filename
+    @status = Sonar::Connector::Status.new @base_config
+    stub(@connector = Object.new).name{"name"}
+    stub(@context).status{@status}
+  end
+  
+  
+  it "should set value if it is nil" do
+    @status.set("name", "foo", nil)
+    Sonar::Connector::IncrementStatusValueCommand.new(@connector, "foo").execute(@context)
+    @status["name"]["foo"].should == 1
+  end
+  
+  it "should increment a value" do
+    @status.set "name", "foo", 1
+    Sonar::Connector::IncrementStatusValueCommand.new(@connector, "foo").execute(@context)
+    @status["name"]["foo"].should == 2
+  end
+  
+end

data/spec/sonar_connector/commands/send_admin_email_command_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Sonar::Connector::SendAdminEmailCommand do
+  
+  it "should send admin email" do
+    @connector = Object.new
+    @command = Sonar::Connector::SendAdminEmailCommand.new(@connector, "message")
+    
+    mock(Sonar::Connector::Emailer).deliver_admin_message(@connector, "message")
+    
+    @command.execute
+  end
+  
+end

data/spec/sonar_connector/commands/update_disk_usage_command_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Sonar::Connector::UpdateDiskUsageCommand do
+  
+  it "should update the disk usage statistic" do
+    @connector = Object.new
+    mock(@connector).connector_dir{"dir"}
+    mock(@connector).name{"name"}
+    
+    mock(Sonar::Connector::Utils).du("dir"){2048}
+    @command = Sonar::Connector::UpdateDiskUsageCommand.new(@connector)
+    
+    @context = Object.new
+    @status = Object.new
+    mock(@status).set("name", "disk_usage", "2 Kb")
+    mock(@context).status{@status}
+    
+    @command.execute(@context)
+  end
+  
+end

data/spec/sonar_connector/commands/update_status_command_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Sonar::Connector::UpdateStatusCommand do
+  
+  it "should define constants" do
+    Sonar::Connector::ACTION_OK
+    Sonar::Connector::ACTION_FAILED
+  end
+  
+  it "should update the disk usage statistic" do
+    @connector = Object.new
+    mock(@connector).name{"name"}
+    
+    @command = Sonar::Connector::UpdateStatusCommand.new(@connector, "last_operation", Sonar::Connector::ACTION_OK)
+    
+    @context = Object.new
+    @status = Object.new
+    mock(@status).set("name", "last_operation", Sonar::Connector::ACTION_OK)
+    mock(@context).status{@status}
+    
+    @command.execute(@context)
+  end
+  
+end

data/spec/sonar_connector/config_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Sonar::Connector::Config do
+  
+  before do
+    setup_valid_config_file
+  end
+  
+  describe "self.load" do
+    before do
+      @config = Sonar::Connector::Config.load(valid_config_filename)
+    end
+    
+    it "should return config" do
+      @config.should be_instance_of(Sonar::Connector::Config)
+    end
+    
+    it "should set CONFIG constant" do
+      Sonar::Connector::CONFIG.should == @config
+    end
+    
+  end
+  
+  describe "parse" do
+    before do
+      @config = Sonar::Connector::Config.new(valid_config_filename).parse
+    end
+    
+    it "should return the config instance" do
+      @config.should be_instance_of(Sonar::Connector::Config)
+    end
+    
+    it "should symbolize log_level" do
+      @config_options["log_level"] = "error"
+      @config = Sonar::Connector::Config.new(valid_config_filename).parse
+      @config.log_level.should == Logger::ERROR
+    end
+    
+    it "should set email settings" do
+      @config.email_settings.should be_instance_of(Hash)
+    end
+  end
+  
+  describe "associate_connector_dependencies!" do
+    before do
+      @config = Sonar::Connector::Config.load(valid_config_filename)
+      @connector_klass = new_anon_class(Sonar::Connector::Base, "MyConnector")
+    end
+    
+    def connector_with_name_and_source(name, source_name)
+      @connector_klass.new({'class'=>'MyConnector', 'name'=>name, 'source_connectors'=>[source_name], 'repeat_delay'=> 10}, @config)
+    end
+    
+    it "should associate a source connector" do
+      connector1 = connector_with_name_and_source 'c1', nil
+      connector2 = connector_with_name_and_source 'c2', 'c1'
+      
+      @config.send :associate_connector_dependencies!, [connector1, connector2]
+      
+      connector1.source_connectors.should be_nil
+      connector2.source_connectors.should == [connector1]
+    end
+
+    it "should associate multiple source connectors correctly" do
+      connector1 = connector_with_name_and_source 'c1', nil
+      connector2 = connector_with_name_and_source 'c2', 'c1'
+      connector3 = connector_with_name_and_source 'c3', nil
+      connector4 = connector_with_name_and_source 'c4', 'c3'
+      
+      @config.send :associate_connector_dependencies!, [connector1, connector2, connector3, connector4]
+      
+      connector1.source_connectors.should be_nil
+      connector2.source_connectors.should == [connector1]
+      connector3.source_connectors.should be_nil
+      connector4.source_connectors.should == [connector3]
+    end
+    
+    it "should raise error when source_connector doesn't exist" do
+      connector1 = connector_with_name_and_source 'c1', 'invalid_connector_name'
+      lambda{
+        @config.send :associate_connector_dependencies!, [connector1]
+      }.should raise_error(Sonar::Connector::InvalidConfig, /no such connector name is defined/)
+    end
+    
+    it "should raise error if connector is set as its own source" do
+      connector1 = connector_with_name_and_source 'c1', 'c1'
+      lambda{
+        @config.send :associate_connector_dependencies!, [connector1]
+      }.should raise_error(Sonar::Connector::InvalidConfig, /cannot have itself as a/)
+    end
+    
+  end
+end

data/spec/sonar_connector/connectors/base_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Sonar::Connector::Base do
+  before do
+    setup_valid_config_file
+    @base_config = Sonar::Connector::Config.load(valid_config_filename)
+    @connector_klass = new_anon_class(Sonar::Connector::Base, "MyConnector") {}
+    @config = {'class'=>'MyConnector', 'name'=>'foo', 'repeat_delay'=> 10}
+    @connector = @connector_klass.new(@config, @base_config)
+  end
+  
+  describe "initialize" do
+    it "should set name" do
+      c = @connector_klass.new(@config, @base_config)
+      c.name.should == 'foo'
+    end
+    
+    it "should require repeat delay of at least 1.0 second" do
+      @config['repeat_delay'] = nil
+      lambda{
+        @connector_klass.new(@config, @base_config)
+      }.should raise_error(Sonar::Connector::InvalidConfig)
+      
+      @config['repeat_delay'] = 0
+      lambda{
+        @connector_klass.new(@config, @base_config)
+      }.should raise_error(Sonar::Connector::InvalidConfig)
+      
+      @config['repeat_delay'] = 0.9
+      lambda{
+        @connector_klass.new(@config, @base_config)
+      }.should raise_error(Sonar::Connector::InvalidConfig)
+    end
+    
+    it "should set blank state hash" do
+      c = @connector_klass.new(@config, @base_config)
+      c.state.should == {}
+    end
+    
+    it "should parse config" do
+      mock.instance_of(@connector_klass).parse(@config){}
+      @connector_klass.new(@config, @base_config)
+    end
+    
+    it "should load state after parsing config so as not to overwrite any state" do
+      @connector_klass = new_anon_class(Sonar::Connector::Base, "MyConnector"){
+        def parse(config)
+          state[:foo] = 'default state value from config'
+        end
+      }
+      
+      mock.instance_of(@connector_klass).read_state(){
+        {:foo => 'overridden by state'}
+      }
+      
+      c = @connector_klass.new(@config, @base_config)
+      c.state[:foo].should == 'overridden by state'
+    end
+  end
+  
+  describe "read_state" do
+    it "should return empty hash if the file doesn't exist" do
+      File.exists?(@connector.send :state_file).should be_false
+      @connector.read_state.should == {}
+    end
+    
+    it "should load hash from yaml file" do
+      mock(File).exist?(@connector.send :state_file){true}
+      mock(YAML).load_file(@connector.send :state_file) { {:foo=>:bar} }
+      @connector.read_state.should == {:foo=>:bar}
+    end
+    
+    it "should log error and return empty hash if the yaml read throws error" do
+      mock(File).exist?(@connector.send :state_file){true}
+      mock(YAML).load_file(@connector.send :state_file) { raise "foo" }
+      mock(@connector.log).error(anything) do |param|
+        param.should match(/error loading/)
+      end
+      @connector.read_state.should == {}
+    end
+
+    it "should return an empty-hash if the yaml read returns a non-hash" do
+      mock(File).exist?(@connector.send :state_file){true}
+      mock(YAML).load_file(@connector.send :state_file) { false }
+      mock(@connector.log).error(anything) do |param|
+        param.should match(/error loading/)
+      end
+      @connector.read_state.should == {}
+    end
+    
+  end
+  
+  describe "load_state" do
+    it "should merge keys" do
+      @connector.state[:foo] = :bar
+      @connector.state[:baz] = 'old value'
+      
+      @connector.save_state
+      
+      @connector.state[:baz] = 'new value'
+      
+      @connector.load_state
+      
+      @connector.state[:foo].should == :bar
+      @connector.state[:baz] = 'old value'
+    end
+  end
+  
+  describe "save_state" do
+    it "should save state to yaml" do
+      @connector.state[:foo] = :bar
+      @connector.save_state
+      @connector.state[:foo] = nil
+      @connector.load_state
+      @connector.state[:foo].should == :bar
+    end
+  end
+  
+  describe "start" do
+    before do
+      @connector = new_anon_class(Sonar::Connector::Base, "MyConnector"){
+        def action
+          true
+        end
+      }.new(@config, @base_config)
+      @queue = Queue.new
+      stub(@connector).sleep_for(anything)
+      
+      # don't switch to log file, but don't close stdout either
+      mock(@connector).switch_to_log_file
+    end
+    
+    it "should peform the action once per iteration" do
+      mock(@connector) do
+        run(){true}
+        run(){true}
+        run(){false}
+      end
+      
+      mock(@connector).action.times(2)
+      
+      @connector.prepare(@queue)
+      @connector.start()
+    end
+    
+    it "should catch uncaught exceptions from the action" do
+      mock(@connector) do
+        run(){true}
+        run(){true}
+        run(){false}
+      end
+      
+      mock(@connector) do
+        action(){raise "uncaught exception"}
+        action(){true}
+      end
+      
+      @connector.prepare(@queue)
+      @connector.start
+    end
+    
+    it "should terminate on ThreadTerminator exception" do
+      stub(@connector).run{true}
+      mock(@connector).action(){raise Sonar::Connector::ThreadTerminator.new}
+      @connector.prepare(@queue)
+      @connector.start
+    end
+    
+    it "should queue status update and disk usage commands on successful action" do
+      mock(@connector) do
+        run(){true}
+        run(){true}
+        run(){false}
+      end
+      
+      stub(Sonar::Connector::UpdateStatusCommand).new
+      stub(Sonar::Connector::UpdateDiskUsageCommand).new
+      stub(@queue, :<<)
+      
+      @connector.prepare(@queue)
+      @connector.start
+      
+      Sonar::Connector::UpdateStatusCommand.should have_received.new(anything, 'last_action', Sonar::Connector::ACTION_OK).times(2)
+      Sonar::Connector::UpdateDiskUsageCommand.should have_received.new(anything).times(2)
+      @queue.should have_received(:<<).with(anything).times(10) # 5x commands queued on 2x action invocations
+    end
+    
+    it "should queue error status update on unhandled action error" do
+      mock(@connector) do
+        run(){true}
+        run(){false}
+      end
+      
+      mock(@connector) do
+        action(){raise "uncaught exception"}
+      end
+      
+      command = Object.new
+      mock(Sonar::Connector::UpdateStatusCommand).new(anything, 'last_action', Sonar::Connector::ACTION_FAILED).times(1){command}
+      mock(@queue, :<<).with(command).times(1)
+      @connector.prepare(@queue)
+      @connector.start
+    end
+    
+  end
+  
+end