bixby-agent 0.3.0

data/etc/bixby-god.initd

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+### BEGIN INIT INFO
+# Provides:          bixby-god
+# Required-Start:    $local_fs $remote_fs $syslog $named $network $time
+# Required-Stop:     $local_fs $remote_fs $syslog $named $network
+# Should-Start:
+# Should-Stop:
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Start/Stop the bixby god daemon
+### END INIT INFO
+
+# processname: god
+# pidfile: /opt/bixby/var/bixby-god.pid
+
+NAME=bixby
+DESC=bixby
+
+export BIXBY_HOME=/opt/bixby
+GOD_PORT=18165 # actually used in unix socket name
+GOD_CONF="-c $BIXBY_HOME/etc/bixby.god"
+GOD_PID=$BIXBY_HOME/var/bixby-god.pid
+GOD_BIN="$BIXBY_HOME/embedded/bin/god -P $GOD_PID -p $GOD_PORT"
+
+start() {
+  echo " * Starting bixby"
+  $GOD_BIN $GOD_CONF
+}
+stop() {
+  echo " * Stopping bixby"
+  $GOD_BIN terminate >/dev/null
+}
+quit() {
+  $GOD_BIN quit >/dev/null
+}
+
+case $1 in
+start)
+        start
+        ;;
+stop)
+        stop
+        ;;
+restart)
+        stop
+        start
+        ;;
+reload)
+        quit
+        start
+        ;;
+status)
+        $GOD_BIN status >/dev/null 2>&1
+        if [[ $? -eq 1 ]]; then
+          echo "Not running"
+        else
+          $GOD_BIN status
+        fi
+        ;;
+god)
+        $GOD_BIN ${@:2}
+;;
+*)
+  echo "Usage: $NAME {start|stop|restart|status|reload|god}" >&2
+  exit 1
+  ;;
+esac
+
+exit 0

data/etc/bixby.god

@@ -0,0 +1,20 @@
+
+# Main God config
+#
+# usage:
+#
+#   # god -P var/bixby-god.pid -c etc/bixby.god
+#
+# god must be run as root!
+#
+# see also: http://godrb.com/
+
+BIXBY_HOME   = ENV["BIXBY_HOME"] || "/opt/bixby"
+BIXBY_CLIENT = File.join(BIXBY_HOME, "bin", "bixby")
+
+God.pid_file_directory = File.join(BIXBY_HOME, "var", "pids")
+
+path = File.join(BIXBY_HOME, "etc", "god.d", "*.god")
+Dir.glob(path).each do |conf|
+  God.load conf
+end

data/etc/god.d/bixby-agent.god

@@ -0,0 +1,71 @@
+
+God.watch do |w|
+  w.dir      = BIXBY_HOME
+  w.name     = "bixby-agent"
+  w.group    = "bixby"
+  w.log      = "#{BIXBY_HOME}/var/god.#{w.name}.log"
+  w.pid_file = "#{BIXBY_HOME}/var/#{w.name}.pid"
+
+  w.interval = 30.seconds
+
+  w.env      = {}
+  w.start    = "#{BIXBY_HOME}/bin/bixby-agent start"
+  w.stop     = "#{BIXBY_HOME}/bin/bixby-agent stop"
+
+  w.start_grace = 10.seconds
+  w.restart_grace = 10.seconds
+
+  # other scripts may drop privs
+  # w.uid = USER
+  # w.gid = GROUP
+
+  w.behavior(:clean_pid_file)
+
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+
+    # failsafe
+    on.condition(:tries) do |c|
+      c.times = 8
+      c.within = 2.minutes
+      c.transition = :start
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits)
+  end
+
+  # restart if memory gets too high
+  w.transition(:up, :restart) do |on|
+    on.condition(:memory_usage) do |c|
+      c.above = 250.megabytes
+      c.times = 2
+    end
+  end
+
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 5.minute
+      c.transition = :unmonitored
+      c.retry_in = 10.minutes
+      c.retry_times = 5
+      c.retry_within = 2.hours
+    end
+  end
+
+end

data/lib/bixby-agent.rb

@@ -0,0 +1,16 @@
+
+# Set BIXBY_HOME when in dev environment
+path = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+if !ENV["BIXBY_HOME"] && File.directory?(File.join(path, ".git")) &&
+    File.basename($0) == "bixby-agent" then
+
+  ENV["BIXBY_HOME"] = path
+end
+
+require "bixby-common"
+require "bixby-client"
+
+require "bixby-agent/agent"
+require "bixby-agent/version"
+
+Bixby::Agent.setup_env()

data/lib/bixby-agent/agent.rb

@@ -0,0 +1,98 @@
+
+require "uri"
+require "rbconfig"
+
+require "bixby-agent/config_exception"
+require "bixby-agent/agent/handshake"
+require "bixby-agent/agent/shell_exec"
+require "bixby-agent/agent/config"
+
+module Bixby
+
+class << self
+  attr_accessor :agent
+end
+
+class Agent
+
+  DEFAULT_ROOT_DIR = "/opt/bixby"
+
+  include Bixby::Log
+  include Config
+  include Handshake
+  include ShellExec
+
+  attr_accessor :manager_uri, :uuid, :mac_address,
+                :access_key, :secret_key, :client
+
+  def self.create(root_dir=nil, use_config = true)
+
+    agent = load_config(root_dir) if use_config
+    if agent.nil? then
+      # create a new one if unable to load
+      agent = new()
+    end
+
+    # pass config to some modules
+    Bixby.agent = agent
+    return agent if agent.new?
+
+    Bixby.manager_uri = agent.manager_uri
+    Bixby.client = Bixby::Client.new(agent.access_key, agent.secret_key)
+    return agent
+  end
+
+  def initialize()
+    #uri, tenant = nil, password = nil, root_dir = nil
+    Bixby::Log.setup_logger()
+    @new = true
+
+    @uuid = create_uuid()
+    @mac_address = get_mac_address()
+    create_keypair()
+  end
+  private_class_method :new
+
+  # Setup the environment for shelling out. Makes sure the correct Ruby
+  # version is on the path and that bixby-agent will be loaded by default
+  def self.setup_env
+    # make sure the correct ruby version is on the path
+    c = begin; ::RbConfig::CONFIG; rescue NameError; ::Config::CONFIG; end
+    ruby_dir = File.expand_path(c['bindir'])
+
+    shell = Mixlib::ShellOut.new("which ruby")
+    shell.run_command
+    if not $?.success? or File.dirname(shell.stdout.strip) != ruby_dir then
+      ENV["PATH"] = ruby_dir + File::PATH_SEPARATOR + ENV["PATH"]
+    end
+
+    # create RUBYLIB paths
+    paths = []
+    if ENV.include? "RUBYLIB" and not ENV["RUBYLIB"].empty? then
+      paths = ENV["RUBYLIB"].split(/:/)
+    end
+    $:.each { |p|
+      if p =~ %r(/gems/) and not paths.include? p then
+        paths << p
+      end
+    }
+    self_lib = File.expand_path(File.join(File.dirname(__FILE__), '../..', 'lib'))
+    paths << self_lib if not paths.include? self_lib
+
+    ENV["RUBYLIB"] = paths.join(":")
+    ENV["RUBYOPT"] = '-rbixby-client/script'
+  end
+
+  # Get the WebSocket API URI
+  #
+  # @return [String] uri
+  def manager_ws_uri
+    # convert manager uri to websocket
+    uri = URI.parse(manager_uri)
+    uri.scheme = (uri.scheme == "https" ? "wss" : "ws")
+    uri.path = "/wsapi"
+    return uri.to_s
+  end
+
+end # Agent
+end # Bixby

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

@@ -0,0 +1,109 @@
+
+require 'yaml'
+require 'fileutils'
+
+module Bixby
+class Agent
+
+module Config
+
+  KEYS = %w{ manager_uri uuid mac_address access_key secret_key log_level }
+
+  module ClassMethods
+
+    def config_dir
+      Bixby.path("etc")
+    end
+
+    def config_file
+      File.join(config_dir, "bixby.yml")
+    end
+
+    def load_config(root_dir)
+      # make sure BIXBY_HOME is set correctly
+      ENV["BIXBY_HOME"] = File.expand_path(root_dir || ENV["BIXBY_HOME"] || Agent::DEFAULT_ROOT_DIR)
+
+      return nil if not File.exists? config_file
+
+      # load it!
+      begin
+        config = YAML.load_file(config_file)
+        if not config.kind_of? Hash or config.empty? then
+          bad_config("corrupted file contents")
+        end
+
+        log_level = config["log_level"]
+        log_level = log_level.strip.downcase if log_level.kind_of? String
+        Bixby::Log.setup_logger(:level => log_level)
+
+        agent = Agent.allocate
+        KEYS.each do |k|
+          m = "#{k}=".to_sym
+          agent.send(m, config[k]) if agent.respond_to? m
+        end
+        agent.new = false
+
+        return agent
+
+      rescue Exception => ex
+        if ex.kind_of? SystemExit then
+          raise ex
+        end
+        bad_config(ex) if ex.message != "exit"
+      end
+    end
+
+    def bad_config(ex = nil)
+      # TODO should force a reinstall/handshake?
+      $stderr.puts "error loading config from #{config_file}"
+      $stderr.puts "(#{ex})" if ex
+      $stderr.puts "exiting"
+      exit 1
+    end
+
+  end # ClassMethods
+
+  def self.included(clazz)
+    clazz.extend(ClassMethods)
+  end
+
+  def new=(val)
+    @new = val
+  end
+
+  def new?
+    @new
+  end
+
+  def config_dir
+    self.class.config_dir
+  end
+
+  def config_file
+    self.class.config_file
+  end
+
+  def init_config_dir
+    return if File.exists? config_dir
+    begin
+      FileUtils.mkdir_p(config_dir)
+    rescue Exception => ex
+      raise IOError.new(ex.message)
+    end
+  end
+
+  def save_config
+    init_config_dir()
+    config = {}
+    KEYS.each do |k|
+      m = k.to_sym
+      config[k] = self.send(m) if self.respond_to? m
+    end
+    config["log_level"] = Logging::Logger.root.level
+    File.open(config_file, 'w') { |out| out.write YAML.dump(config) }
+  end
+
+end # Config
+
+end # Agent
+end # Bixby

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

@@ -0,0 +1,73 @@
+
+require "openssl"
+require "base64"
+
+module Bixby
+class Agent
+
+module Crypto
+
+  # create crypto keypair and save in config folder
+  def create_keypair
+    init_config_dir()
+    pair = OpenSSL::PKey::RSA.generate(2048)
+    File.open(private_key_file, 'w') { |out| out.write(pair.to_s) }
+  end
+
+  def private_key_file
+    File.join(self.config_dir, "id_rsa")
+  end
+
+  def keypair
+    @keypair ||= OpenSSL::PKey::RSA.new(File.read(private_key_file))
+  end
+
+  def public_key
+    @public_key ||= keypair.public_key
+  end
+
+  def private_key
+    keypair
+  end
+
+  def server_key_file
+    File.join(self.config_dir, "server.pub")
+  end
+
+  def have_server_key?
+    File.exists? server_key_file
+  end
+
+  def server_key
+    @server_key ||= OpenSSL::PKey::RSA.new(File.read(server_key_file))
+  end
+
+  def crypto_enabled?
+    b = ENV["BIXBY_NOCRYPTO"]
+    !(b and %w{1 true yes}.include? b)
+  end
+
+  # Encrypt data using the server's public key
+  #
+  # @param [String] data    data to encrypt
+  #
+  # @return [String] Base64 result
+  def encrypt_for_server(data)
+    Bixby::CryptoUtil.encrypt(data, self.uuid, server_key, keypair)
+  end
+
+  # Decrypt data that was encrypted with our public key
+  #
+  # @param [String] data    Base64 encoded data
+  #
+  # @return [String] unencrypted data
+  def decrypt_from_server(data)
+    data = StringIO.new(data, 'rb')
+    uuid = data.readline.strip # TODO throwaway the uuid for now
+    Bixby::CryptoUtil.decrypt(data, keypair, server_key)
+  end
+
+end # Crypto
+
+end # Agent
+end # Bixby