bixby-agent 0.3.0

data/lib/bixby-agent/agent/handshake.rb

@@ -0,0 +1,81 @@
+
+require 'facter'
+require 'uuidtools'
+
+require "bixby-agent/agent/crypto"
+
+module Bixby
+class Agent
+
+module Handshake
+
+  include Crypto
+
+  # Register the agent with the server
+  #
+  # @param [String] url                 Bixby manager URL
+  # @param [String] tenant              Tenant name
+  # @param [String] password            Tenant registration password
+  # @param [String] tags                Comma-separated list of tags (e.g., "foo,bar")
+  #
+  # @return [JsonResponse] response from server
+  def register_agent(url, tenant, password, tags=nil)
+    Bixby.manager_uri = @manager_uri = url
+    ret = Bixby::Inventory.register_agent({
+      :uuid       => @uuid,
+      :public_key => self.public_key.to_s,
+      :hostname   => get_hostname(),
+      :tenant     => tenant,
+      :password   => password,
+      :tags       => tags,
+      :version    => Bixby::Agent::VERSION
+      })
+
+    if ret.fail? then
+      return ret
+    end
+
+    @access_key = ret.data["access_key"]
+    @secret_key = ret.data["secret_key"]
+    Bixby.client = Bixby::Client.new(access_key, secret_key)
+
+    # success, store server's pub key
+    File.open(self.server_key_file, 'w') do |f|
+      f.puts(ret.data["server_key"])
+    end
+
+    return ret
+  end
+
+  def mac_changed?
+    (not @mac_address.nil? and (@mac_address != get_mac_address()))
+  end
+
+  def get_hostname
+    `hostname`.strip
+  end
+
+  # Get the mac address of the system's primary interface
+  def get_mac_address
+    return @mac if not @mac.nil?
+    Facter.collection.fact(:ipaddress).value # force value to be loaded now (usually lazy-loaded)
+    Facter.collection.fact(:interfaces).value
+    Facter.collection.fact(:macaddress).value
+    vals = Facter.collection.to_hash
+    ip = vals["ipaddress"]
+    raise "Unable to find IP address" if ip.nil?
+    # use the primary IP of the system to find the associated interface name (e.g., en0 or eth0)
+    int = vals.find{ |k,v| v == ip && k != "ipaddress" }.first.to_s.split(/_/)[1]
+    raise "Unable to find primary interface" if int.nil? or int.empty?
+    # finally, get the mac address
+    @mac = vals["macaddress_#{int}"]
+  end
+
+  def create_uuid
+    UUIDTools::UUID.random_create.hexdigest
+  end
+
+end # Handshake
+
+end # Agent
+end # Bixby

data/lib/bixby-agent/agent/shell_exec.rb

@@ -0,0 +1,111 @@
+
+require 'mixlib/shellout'
+
+module Bixby
+class Agent
+
+module ShellExec
+
+  # Shell exec a local command with the given params
+  #
+  # @param [Hash] params                  CommandSpec hash
+  # @option params [String] :repo
+  # @option params [String] :bundle
+  # @option params [String] :command
+  # @option params [String] :args
+  # @option params [String] :stdin
+  # @option params [String] :digest       Expected bundle digest
+  # @option params [Hash] :env            Hash of extra ENV key/values to pass to sub-shell
+  # @option params [String] :user         User to run as
+  # @option params [String] :group        Group to run as
+  #
+  # @return [CommandResponse]
+  #
+  # @raise [BundleNotFound] If bundle doesn't exist or digest does not match
+  # @raise [CommandNotFound] If command doesn't exist
+  def shell_exec(params)
+    digest = params.delete("digest") || params.delete(:digest)
+
+    spec = CommandSpec.new(params)
+    log.debug { "shell_exec:\n" + spec.to_s + "\n" }
+    spec.validate(digest)
+
+    cmd = "#{spec.command_file} #{spec.args}"
+
+    # Cleanup the ENV and execute
+    old_env = {}
+    %W{BUNDLE_BIN_PATH BUNDLE_GEMFILE}.each{ |r|
+      old_env[r] = ENV.delete(r) if ENV.include?(r) }
+
+    logger.debug("exec: #{cmd}")
+    shell = Mixlib::ShellOut.new(cmd, :input => spec.stdin,
+                                      :env   => spec.env,
+                                      :user  => uid(spec.user),
+                                      :group => gid(spec.group))
+
+    shell.run_command
+
+    old_env.each{ |k,v| ENV[k] = v } # reset the ENV
+
+    return CommandResponse.new({ :status => shell.exitstatus,
+                                 :stdout => shell.stdout,
+                                 :stderr => shell.stderr })
+  end
+
+
+  private
+
+  # Return uid of 'bixby' user, if it exists
+  #
+  # @param [String] user        username to run as [Optional, default=bixby]
+  # @return [Fixnum]
+  def uid(user)
+    if Process.uid != 0 then
+      logger.warn("Can't change effective uid unless running as root")
+      return nil
+    end
+
+    if user then
+      begin
+        return Etc.getpwnam(user).uid
+      rescue ArgumentError => ex
+        logger.warn("Username '#{user}' was invalid: #{ex.message}")
+      end
+    end
+
+    begin
+      return Etc.getpwnam("bixby").uid
+    rescue ArgumentError
+    end
+    return nil
+  end
+
+  # Return uid of 'bixby' group, if it exists
+  #
+  # @param [String] group         group to run as [Optional, default=bixby]
+  # @return [Fixnum]
+  def gid(group)
+    if Process.uid != 0 then
+      logger.warn("Can't change effective gid unless running as root")
+      return nil
+    end
+
+    if group then
+      begin
+        return Etc.getgrnam(group).gid
+      rescue ArgumentError => ex
+        logger.warn("Group '#{group}' was invalid: #{ex.message}")
+      end
+    end
+
+    begin
+      return Etc.getgrnam("bixby").gid
+    rescue ArgumentError
+    end
+    return nil
+  end
+
+end # Exec
+
+end # Agent
+end # Bixby

data/lib/bixby-agent/agent_handler.rb

@@ -0,0 +1,38 @@
+
+module Bixby
+
+  class AgentHandler < Bixby::RpcHandler
+
+    include Bixby::Log
+    # include Bixby::CryptoUti
+
+    def initialize(request)
+      @request = request
+    end
+
+    def handle(json_req)
+
+      begin
+        cmd_res = Bixby.agent.shell_exec(json_req.params)
+        log.debug { cmd_res.to_s + "\n---\n\n\n" }
+        return cmd_res.to_json_response
+
+      rescue Exception => ex
+        if ex.kind_of? BundleNotFound then
+          log.debug(ex.message)
+          return JsonResponse.bundle_not_found(ex.message)
+
+        elsif ex.kind_of? CommandNotFound then
+          log.debug(ex.message)
+          return JsonResponse.command_not_found(ex.message)
+        end
+
+        log.error(ex)
+        return JsonResponse.new("fail", ex.message, nil, 500)
+      end
+
+    end
+
+  end
+
+end

data/lib/bixby-agent/app.rb

@@ -0,0 +1,208 @@
+
+require 'bixby-agent/websocket/client'
+require 'bixby-agent/agent_handler'
+require 'bixby-agent/app/cli'
+require 'bixby-agent/help/system_time'
+
+require 'daemons'
+require 'highline/import'
+
+module Bixby
+class App
+
+  include CLI
+  include Bixby::Log
+
+  # Load Agent
+  #
+  # Load the agent from $BIXBY_HOME. If no existing configuration was found,
+  # try to register with the server if we have the correct parameters.
+  def load_agent
+
+    begin
+      agent = Agent.create(@config[:directory])
+    rescue Exception => ex
+      if ex.message =~ /manager URI/ then
+        # if unable to load from config and no/bad uri passed, bail!
+        $stderr.puts "ERROR: a valid manager URI is required on first run"
+        $stderr.puts
+        $stderr.puts @opt_parser.help()
+        exit 1
+      end
+      raise ex
+    end
+
+    # TODO disable mac detection for now; it doesn't work in certain cases
+    #      e.g., when you stop/start an instance on EC2 a new mac is issued
+    #
+    # if not agent.new? and agent.mac_changed? then
+    #   # loaded from config and mac has changed
+    #   agent = Agent.create(opts, false)
+    # end
+
+    if agent.new? then
+
+      if !@config[:register] then
+        # --register not passed, bail out
+        if File.exists? agent.config_file then
+          $stderr.puts "Unable to load agent config from #{agent.config_file}; pass --register to reinitialize"
+        else
+          $stderr.puts "Unable to load agent from BIXBY_HOME=#{ENV['BIXBY_HOME']}; pass --register to initialize"
+        end
+        exit 1
+      end
+
+      # validate uri
+      uri = @argv.shift || @config[:register]
+      begin
+        if uri.nil? or URI.parse(uri).nil? or URI.join(uri, "/api").nil? then
+          raise ConfigException, "Missing manager URI", caller
+        end
+      rescue URI::Error => ex
+        raise ConfigException, "Bad manager URI: '#{uri}'"
+      end
+
+      tenant   = @config[:tenant]   || HighLine.new.ask("Tenant: ")
+      password = @config[:password] || HighLine.new.ask("Enter agent registration password: ") { |q| q.echo = "*" }
+
+      # register
+      $stdout.puts "Going to register with manager: #{uri}"
+      if (ret = agent.register_agent(uri, tenant, password, @config[:tags])).fail? then
+        $stderr.puts "error: failed to register with manager!"
+        $stderr.puts "reason:"
+        if ret.message =~ /900 seconds old/ then
+          Help::SystemTime.print()
+        else
+          $stderr.puts "  #{ret.message}"
+        end
+        exit 1
+      end
+      agent.save_config()
+      ARGV.clear # make sure it's empty so daemon starts properly
+      $stdout.puts "Registration successful; launching bixby-agent into background"
+    end
+    agent
+  end
+
+  # Run the agent app!
+  #
+  # This is the main method. Will boot and configure the agent, connect to the
+  # server and start the daemon.
+  def run!
+    # load agent from config or cli opts
+    agent = load_agent()
+
+    fix_ownership()
+
+    # debug mode, stay in front
+    if @config[:debug] then
+      Logging::Logger.root.add_appenders("stdout")
+      return start_websocket_client()
+    end
+
+    # start daemon
+    validate_argv()
+    daemon_dir = Bixby.path("var")
+    ensure_state_dir(daemon_dir)
+    close_fds()
+
+    daemon_opts = {
+      :dir        => daemon_dir,
+      :dir_mode   => :normal,
+      :log_output => true,
+      :stop_proc  => lambda { logger.info "Agent shutdown on service stop command" }
+    }
+
+    Daemons.run_proc("bixby-agent", daemon_opts) do
+      Logging.logger.root.clear_appenders
+      start_websocket_client()
+    end
+  end
+
+  # Open the WebSocket channel with the Manager
+  #
+  # NOTE: this call will not return!
+  def start_websocket_client
+    # make sure log level is still set correctly here
+    Bixby::Log.setup_logger(:level => Logging.appenders["file"].level)
+    logger.info "Started Bixby Agent"
+    @client = Bixby::WebSocket::Client.new(Bixby.agent.manager_ws_uri, AgentHandler)
+    trap_signals()
+    @client.start
+  end
+
+  def trap_signals
+    %w{INT QUIT TERM}.each do |sig|
+      Kernel.trap(sig) do
+        @client.stop()
+        puts # to get a blank line after the ^C in the term
+        reason = sig + (sig == "INT" ? " (^C)" : "")
+        logger.warn  "caught #{reason} signal; exiting"
+      end
+    end
+  end
+
+  # If running as root, fix ownership of var and etc dirs
+  def fix_ownership
+    return if Process.uid != 0
+    begin
+      uid = Etc.getpwnam("bixby").uid
+      gid = Etc.getgrnam("bixby").gid
+      # user/group exists, chown
+      File.chown(uid, gid, Bixby.path("var"), Bixby.path("etc"))
+    rescue ArgumentError
+    end
+  end
+
+  # Validate ARGV
+  #
+  # If empty, default to "start", otherwise make sure we have a valid option
+  # for daemons.
+  #
+  # @raise [SystemExit] on invalid arg
+  def validate_argv
+    if ARGV.empty? then
+      ARGV << "start"
+    else
+      if not %w{start stop restart zap status}.include? ARGV.first then
+        $stderr.puts "ERROR: invalid command '#{ARGV.first}'"
+        $stderr.puts
+        $stderr.puts @opt_parser.help()
+        exit 1
+      end
+    end
+  end
+
+  # Ensure that the var dir exists and is writable
+  #
+  # @raise [SystemExit] on error
+  def ensure_state_dir(daemon_dir)
+    if not File.directory? daemon_dir then
+      begin
+        Dir.mkdir(daemon_dir)
+      rescue Exception => ex
+        $stderr.puts "Failed to create state dir: #{daemon_dir}; message:\n" + ex.message
+        exit 1
+      end
+    end
+    if not File.writable? daemon_dir then
+      $stderr.puts "State dir is not writable: #{daemon_dir}"
+      exit 1
+    end
+  end
+
+  # Copied from daemons gem. We hit a bug where closing FDs failed,
+  # probably related to prompting for a password. So close them
+  # all cleanly before daemonizing.
+  def close_fds
+    # don't close stdin/out/err (0/1/2)
+    3.upto(8192).each do |i|
+      begin
+        IO.for_fd(i).close
+      rescue Exception
+      end
+    end
+  end
+
+end # App
+end # Bixby

data/lib/bixby-agent/app/cli.rb

@@ -0,0 +1,112 @@
+
+require 'mixlib/cli'
+require 'highline/import'
+
+module Bixby
+class App
+
+module CLI
+
+  include Mixlib::CLI
+
+  def self.included(receiver)
+    receiver.extend(Mixlib::CLI::ClassMethods)
+    receiver.instance_variable_set(:@options, @options)
+    receiver.instance_variable_set(:@banner, @banner)
+    receiver.instance_variable_set(:@opt_parser, @opt_parser)
+  end
+
+  banner <<-EOF
+Usage: #{$0} <command>
+
+Run bixby-agent as a background daemon.
+
+Where <command> is one of:
+  start         start the agent
+  stop          stop the agent
+  restart       stop and start the agent
+  zap           reset the PID file
+  status        show status (PID) of the agent
+
+To register with the manager:
+
+  #{$0} --register [URL] -t TENANT -P [PASSWORD] [--tags TAG1,TAG2]
+
+Options:
+
+EOF
+
+  # :nocov:
+
+  option :register,
+      :on             => :head,
+      :long           => "--register [URL]",
+      :description    => "Register with the management server (optional URL, default: https://bixby.io)",
+      :proc           => Proc.new { |url| url || "https://bixby.io" } # default URL
+
+  option :tenant,
+      :on             => :head,
+      :short          => "-t TENANT",
+      :long           => "--tenant TENANT",
+      :description    => "Tenant name"
+
+  option :password,
+      :on             => :head,
+      :short          => "-P [PASSWORD]",
+      :long           => "--password [PASSWORD]",
+      :description    => "Agent registration password (prompt if not supplied)",
+      :proc           => Proc.new { |c|
+                           if c then
+                             c
+                           else
+                             HighLine.new.ask("Enter agent registration password: ") { |q| q.echo = "*" }
+                           end
+                         }
+
+  option :tags,
+      :on             => :head,
+      :long           => "--tags TAGS",
+      :description    => "Comma separated tags to assign to this host (optional)"
+
+  option :directory,
+      :short          => "-d DIRECTORY",
+      :long           => "--directory DIRECTORY",
+      :description    => "Root directory for Bixby (optional, default: /opt/bixby)"
+
+  option :debug,
+      :on             => :tail,
+      :long           => "--debug",
+      :description    => "Enable debug mode (don't daemonize, extra logging)",
+      :boolean        => true,
+      :proc           => Proc.new { ENV["BIXBY_LOG"] = "debug" }
+
+  option :help,
+      :on             => :tail,
+      :short          => "-h",
+      :long           => "--help",
+      :description    => "Print this help",
+      :boolean        => true,
+      :show_options   => true,
+      :exit           => 0
+
+  option :version,
+      :on             => :tail,
+      :short          => "-v",
+      :long           => "--version",
+      :description    => "Show version",
+      :proc           => Proc.new { puts "Bixby v" + Bixby::Agent::VERSION },
+      :exit           => 0
+
+  # :nocov:
+
+  def initialize
+    super
+    @argv = parse_options()
+    ARGV.clear << @argv
+    ARGV.flatten!
+  end
+
+end # CLI
+
+end # App
+end # Bixby