bixby-agent 0.3.0

data/lib/bixby-agent/config_exception.rb

@@ -0,0 +1,5 @@
+
+module Bixby
+  class ConfigException < Exception
+  end
+end

data/lib/bixby-agent/help/system_time.rb

@@ -0,0 +1,41 @@
+
+module Bixby
+  module Help
+    class SystemTime
+
+      extend Bixby::Script::Distro
+      extend Bixby::Script::Platform
+
+      def self.print
+        $stderr.puts self.message
+      end
+
+      # Registration may fail if the system clock is too far in the past (more than 15 minutes)
+      # Show the user how to fix the issue and try again
+      def self.message
+        s = "  it appears your system clock is out of sync"
+
+        res = HTTPI.get("http://google.com")
+        if not res.error? then
+          current_time = Time.parse(res.headers["Date"]).utc
+          s += "  > current time: #{current_time}"
+          s += "  >  system time: #{Time.new.utc}"
+        end
+
+        $stderr.puts
+        if linux? && ubuntu? then
+          s += "  to fix:"
+          s += "  sudo apt-get install ntpdate && sudo ntpdate ntp.ubuntu.com"
+        elsif linux? && centos? then
+          s += "  to fix:"
+          s += "  sudo yum install ntpdate && sudo ntpdate ntp.ubuntu.com"
+        else
+          s += "  you can fix this on most unix systems by running 'sudo ntpdate ntp.ubuntu.com'"
+        end
+
+        s
+      end
+
+    end
+  end
+end

data/lib/bixby-agent/version.rb

@@ -0,0 +1,8 @@
+
+module Bixby
+  class Agent
+
+    VERSION = File.new(File.expand_path(File.join(File.dirname(__FILE__), "../../VERSION"))).read.strip
+
+  end
+end

data/lib/bixby-agent/websocket/client.rb

@@ -0,0 +1,186 @@
+
+require 'bixby-agent/help/system_time'
+
+require 'faye/websocket'
+require 'eventmachine'
+require 'timeout'
+
+module Bixby
+  module WebSocket
+
+    # WebSocket Client
+    class Client
+
+      include Bixby::Log
+
+      attr_reader :ws, :api
+
+      def initialize(url, handler)
+        @url = url
+        @handler = handler
+        @tries = 0
+        @exiting = false
+      end
+
+      # Start the Client thread
+      #
+      # NOTE: This call never returns!
+      def start
+
+        @exiting = false
+
+        Kernel.trap("EXIT") do
+          # :nocov:
+          @exiting = true
+          # :nocov:
+        end
+
+        logger.debug "connecting to #{@url}"
+        EM.run {
+          connect()
+        }
+      end
+
+      def stop
+        @exiting = true
+        EM.stop_event_loop if EM.reactor_running?
+      end
+
+
+      private
+
+      # Connect to the WebSocket endpoint given by @url. Will attempt to keep
+      # the connection open forever, reconnecting as needed.
+      def connect
+
+        # Ping is set to 55 sec to workaround issues with certain gateway devices which have a hard
+        # 60 sec timeout, like the AWS ELB:
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/ts-elb-healthcheck.html
+        @ws = Faye::WebSocket::Client.new(@url, nil, :ping => 55)
+        @api = Bixby::WebSocket::APIChannel.new(@ws, @handler)
+
+        ws.on :open do |e|
+          begin
+            authenticate(e)
+          rescue Exception => ex
+            logger.error ex
+          end
+        end
+
+        ws.on :message do |e|
+          begin
+            api.message(e)
+          rescue Exception => ex
+            raise ex if ex.kind_of? SystemExit # possible when message is a connect() response
+            logger.error ex
+          end
+        end
+
+        ws.on(:close, &lambda { |e|
+          begin
+            was_connected = api.connected?
+            api.close(e)
+            return if @exiting or not EM.reactor_running?
+            if was_connected then
+              logger.info "lost connection to manager"
+            else
+              logger.debug "failed to connect"
+            end
+            reconnect()
+          rescue Exception => ex
+            logger.error ex
+          end
+        })
+      end
+
+      # Send a connection request to authenticate with the manager
+      def authenticate(e)
+        logger.debug "connected to manager, authenticating"
+
+        json_req   = JsonRequest.new("", "")
+        signed_req = SignedJsonRequest.new(json_req, Bixby.agent.access_key, Bixby.agent.secret_key)
+        auth_req   = Request.new(signed_req, SecureRandom.uuid, "connect")
+
+        id = api.execute_async(auth_req) do |ret|
+          if ret.success? then
+            logger.info "Successfully connected to manager at #{@url}"
+            api.open(e)
+            @tries = 0
+
+          else
+            if ret.message =~ /900 seconds old/ then
+              logger.error "error authenticating with manager:\n" + Help::SystemTime.message
+            else
+              logger.error "error authenticating with manager: #{ret.code} #{ret.message}"
+            end
+            logger.error "exiting since we failed to auth"
+            @exiting = true
+            exit 1 # bail out since we failed to connect, nothing to do
+          end
+        end
+
+        # Start a thread to watch for auth timeout
+        Thread.new do
+          begin
+            sec = 60
+            Timeout.timeout(sec) do
+              api.fetch_response(id) # blocks until request is completed
+            end
+
+          rescue Timeout::Error => ex
+            logger.warn("Authentication timed out after #{sec} seconds; trying again")
+            reconnect()
+
+          rescue Exception => ex
+            logger.error(ex)
+          end
+        end
+
+      end
+
+      def cleanup
+        @api.close(nil) if @api
+        @ws.close if @ws
+      end
+
+      def reconnect
+        if backoff() then
+          cleanup()
+          connect()
+        end
+      end
+
+      # Delay reconnection by a slowly increasing interval
+      def backoff
+
+        if @exiting or not EM.reactor_running? then
+          # shutting down, don't try to reconnect
+          logger.debug "not retrying since we are shutting down"
+          return false
+        end
+
+        @tries += 1
+        if @tries == 1 then
+          logger.debug "retrying immediately"
+
+        # :nocov:
+        elsif @tries == 2 then
+          logger.debug "retrying every 1 sec"
+          sleep 1
+        elsif @tries <= 30 then
+          sleep 1
+        elsif @tries == 31 then
+          logger.debug "retrying every 5 sec"
+          sleep 5
+        else
+          sleep 5
+        end
+        # :nocov:
+
+        true
+      end
+
+    end
+
+  end
+end

data/tasks/cane.rake

@@ -0,0 +1,14 @@
+
+begin
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.abc_max = 10
+    cane.add_threshold 'coverage/covered_percent', :>=, 99
+    cane.no_style = true
+  end
+
+  task :default => :quality
+rescue LoadError
+end

data/tasks/coverage.rake

@@ -0,0 +1,2 @@
+
+require "easycov/rake"

data/tasks/coveralls.rake

@@ -0,0 +1,11 @@
+
+desc "Report coverage to coveralls"
+task :coveralls do
+  require "easycov"
+  require "coveralls"
+
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  if File.exists? File.join(EasyCov.path, ".resultset.json") then
+    SimpleCov::ResultMerger.merged_result.format!
+  end
+end

data/tasks/jeweler.rake

@@ -0,0 +1,21 @@
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |gemspec|
+  gemspec.name        = "bixby-agent"
+  gemspec.summary     = "Bixby Agent"
+  gemspec.description = "Bixby Agent"
+  gemspec.email       = "chetan@pixelcop.net"
+  gemspec.homepage    = "http://github.com/chetan/bixby-agent"
+  gemspec.authors     = ["Chetan Sarva"]
+  gemspec.license     = "MIT"
+
+  gemspec.executables = %w{ bixby-agent }
+
+  # exclude these bin scripts for now
+  %w{ ci.sh ci_setup.sh install.sh }.each do |f|
+    gemspec.files.exclude "bin/#{f}"
+  end
+
+end
+Jeweler::RubygemsDotOrgTasks.new

data/tasks/test.rake

@@ -0,0 +1,5 @@
+
+require "micron/rake"
+Micron::Rake.new do |task|
+end
+task :default => :test

data/tasks/yard.rake

@@ -0,0 +1,6 @@
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+end

data/test/base.rb

@@ -0,0 +1,92 @@
+
+require 'helper'
+require 'micron/test_case/redir_logging'
+
+module Bixby
+  module Test
+
+    class TestCase < Micron::TestCase
+
+      include Micron::TestCase::RedirLogging
+      self.redir_logger = Logging.logger[Bixby]
+
+      def setup
+        super
+        WebMock.reset!
+
+        @git_path = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+        @support_path = File.join(@git_path, "test", "support")
+
+        @manager_uri = "http://localhost:3000"
+        @tenant = "pixelcop"
+        @password = "foobar"
+        @root_dir = Dir.mktmpdir("bixby-agent-test-")
+        @port = 9999
+
+        Bixby.manager_uri = @manager_uri
+        @api_url = @manager_uri + "/api"
+        `rm -rf #{@root_dir}`
+
+        vendor_path = File.join(@root_dir, "repo", "vendor")
+        `mkdir -p #{vendor_path}`
+        `cp -a #{File.join(@git_path, "repo/vendor/*")} #{vendor_path}`
+
+        ENV["BIXBY_NOCRYPTO"] = "1"
+        ENV["BIXBY_HOME"] = @root_dir
+        ARGV.clear
+      end
+
+      def teardown
+        `rm -rf #{@root_dir}`
+        @agent = nil
+        ENV["BIXBY_HOME"] = nil
+      end
+
+      def setup_existing_agent
+        ENV["BIXBY_HOME"] = @root_dir
+        src = File.join(@support_path, "root_dir")
+        dest = File.join(@root_dir, "etc")
+        FileUtils.mkdir_p(dest)
+        FileUtils.copy_entry(src, dest)
+        @agent = Agent.create
+      end
+
+      def setup_root
+        # copy repo to path
+        `mkdir -p #{@root_dir}/repo/support`
+        `cp -a #{@bundle_path} #{@root_dir}/repo/support/`
+      end
+
+      def setup_test_bundle(repo, bundle, command, digest=nil)
+        @bundle_path = File.join(@support_path, "test_bundle")
+        @c = CommandSpec.new({ :repo => repo, :bundle => bundle,
+                :command => command, :digest => digest })
+      end
+
+      def create_new_agent
+        ENV["BIXBY_HOME"] = nil
+        @agent = Agent.create(@root_dir)
+      end
+
+
+      # common routines for crypto tests
+
+      def server_private_key
+        s = File.join(@root_dir, "etc", "server")
+        OpenSSL::PKey::RSA.new(File.read(s))
+      end
+
+      def encrypt_for_agent(msg)
+        Bixby::CryptoUtil.encrypt(msg, "server_uuid", @agent.private_key, server_private_key)
+      end
+
+      def decrypt_from_agent(data)
+        data = StringIO.new(data, 'rb')
+        uuid = data.readline.strip
+        Bixby::CryptoUtil.decrypt(data, server_private_key, @agent.private_key)
+      end
+
+    end
+
+  end
+end

data/test/helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development, :test)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'micron/minitest'
+
+# load curb first so webmock can stub it out as necessary
+require 'curb'
+require 'webmock'
+include WebMock::API
+require 'mocha/setup'
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+ENV["RUBYLIB"] = $:.first
+require 'bixby-agent'
+
+require "base"
+Dir.glob(File.dirname(__FILE__) + "/../lib/**/*.rb").each{ |f| require f }
+
+EasyCov.path = "coverage"
+EasyCov.filters << EasyCov::IGNORE_GEMS << EasyCov::IGNORE_STDLIB
+EasyCov.start

data/test/stub_eventmachine.rb

@@ -0,0 +1,38 @@
+
+module EventMachine
+  class << self
+
+    alias_method :_orig_run, :run
+    alias_method :_orig_next_tick, :next_tick
+    alias_method :_orig_stop, :stop
+    alias_method :_orig_stop_event_loop, :stop_event_loop
+
+    def run_immediately(&block)
+      @reactor_running = true
+      block.call() if block
+    end
+
+    def tick_immediately(&block)
+      block.call() if block
+    end
+
+    def noop
+    end
+
+    def stub!
+      define_singleton_method :run, method(:run_immediately)
+      define_singleton_method :next_tick, method(:tick_immediately)
+      define_singleton_method :stop, method(:noop)
+      define_singleton_method :stop_event_loop, method(:noop)
+    end
+
+    def disable_stub!
+      define_singleton_method :run, method(:_orig_run)
+      define_singleton_method :next_tick, method(:_orig_next_tick)
+      define_singleton_method :stop, method(:_orig_stop)
+      define_singleton_method :stop_event_loop, method(:_orig_stop_event_loop)
+    end
+
+  end
+end
+