scout_agent 3.0.0

data/lib/scout_agent/assignment/queue.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby -wKU
+
+# require standard libraries
+require "io/wait"
+
+module ScoutAgent
+  class Assignment
+    class Queue < Assignment
+      ERRORS = [ [ :missing_db,
+                   "Queue database could not be loaded." ],
+                 [ :missing_id,
+                   "You must pass a mission ID or delivery type." ],
+                 [ :invalid_id,
+                   "You must pass a mission ID or " +
+                   "'report', 'hint', 'alert', or 'error'." ],
+                 [ :missing_fields,
+                   "You must provide fields to queue." ],
+                 [ :invalid_fields,
+                   "You must pass valid JSON for the fields." ],
+                 [ :invalid_report_fields,
+                   "Field data must be a Hash to pass to the server." ],
+                 [ :missing_plugin_id_field,
+                   "A plugin_id field is required by the server." ],
+                 [ :invalid_plugin_id_field,
+                   "The plugin_id field must be a positive integer." ],
+                 [ :failed_to_queue_message,
+                   "Your message could not be queued at this time." ] ]
+      
+      def execute
+        log = ScoutAgent.prepare_wire_tap(:queue, :skip_stdout)
+
+        status_database(log)
+        status("Queuing message", :queue)
+        at_my_exit do
+          clear_status(:queue)
+        end
+        
+        unless db = Database.load(:queue, log)
+          abort_with_error(:missing_db)
+        end
+        
+        log.info("Validating message for queuing.")
+        unless id = Array(other_args).shift
+          abort_with_error(:missing_id)
+        end
+        unless id =~ /\A(?:report|hint|alert|error|\d*[1-9])\z/
+          abort_with_error(:invalid_id)
+        end
+        
+        fields = ARGF.read unless ARGV.empty? and not $stdin.ready?
+        if fields.nil? or fields.empty?
+          abort_with_error(:missing_fields)
+        end
+        bytes = fields.size
+        begin
+          fields = JSON.parse(fields.to_s)
+        rescue JSON::ParserError
+          abort_with_error(:invalid_fields)
+        end
+        
+        if %w[report hint alert error].include? id
+          unless fields.is_a? Hash
+            abort_with_error(:invalid_report_fields)
+          end
+          unless fields.include? "plugin_id"
+            abort_with_error(:missing_plugin_id_field)
+          end
+          unless fields["plugin_id"].to_s =~ /\A\d*[1-9]\z/
+            abort_with_error(:invalid_plugin_id_field)
+          end
+          log.info("Message is a valid #{id} (#{bytes} bytes).")
+        else
+          log.info("Message is valid (#{bytes} bytes).")
+        end
+        
+        log.info("Queuing message.")
+        unless db.enqueue(id, fields)
+          abort_with_error(:failed_to_queue_message)
+        end
+        
+        db.maintain
+        
+        log.info("Messages queued successfully.")
+      end
+      
+      private
+      
+      def abort_with_error(error_name)
+        error = ERRORS.assoc(error_name)
+        warn error.last
+        exit(ERRORS.index(error) + 1)
+      end
+    end
+  end
+end

data/lib/scout_agent/assignment/reset.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  class Assignment
+    class Reset < Assignment
+      def execute
+        agent = IDCard.new(:lifeline)
+        if agent.pid_file.exist?
+          abort_with_agent_running
+        end
+        
+        puts "Reset Your Agent"
+        puts "================"
+        puts
+        
+        print <<-END_WARNING.trim.to_question
+        This is a dangerous operation that will remove configuration
+        and data files.  Are you absolutely sure you wish to remove
+        this data (yes/no)?
+        END_WARNING
+        unless gets.to_s.strip.downcase == "yes"
+          abort_with_cancel
+        end
+        
+        puts
+        puts "Resetting..."
+        if not Plan.config_file.exist?
+          puts <<-END_CONFIG_FILE
+          Identification file '#{Plan.config_file}' doesn't exist.  Skipped.
+          END_CONFIG_FILE
+        else
+          begin
+            Plan.config_file.unlink
+            puts "Identification file '#{Plan.config_file}' removed."
+          rescue Errno::EACCES  # don't have permission
+            abort_with_insufficient_permissions(Plan.config_file)
+          end
+        end
+        %w[db_dir pid_dir log_dir].each do |path|
+          dir = Plan.send(path)
+          if not dir.exist?
+            puts "Directory '#{dir}' doesn't exist.  Skipped."
+          else
+            begin
+              dir.rmtree
+              puts "Directory '#{dir}' removed."
+            rescue Errno::EACCES  # don't have permission
+              abort_with_insufficient_permissions(dir)
+            end
+          end
+        end
+        puts "Done."
+        puts
+        
+        puts <<-END_START_INSTRUCTIONS.trim
+        This agent is reset.  You can prepare it for use again
+        at anytime with:
+        
+            sudo #{$PROGRAM_NAME} identify
+        
+        END_START_INSTRUCTIONS
+      end
+      
+      private
+      
+      def abort_with_agent_running
+        abort <<-END_AGENT_RUNNING.trim
+        You cannot reset while the agent is running.  Please stop
+        it first with the following command:
+        
+            sudo #{$PROGRAM_NAME} stop
+        
+        END_AGENT_RUNNING
+      end
+      
+      def abort_with_cancel
+        abort "Reset cancelled.  No data was removed."
+      end
+      
+      def abort_with_insufficient_permissions(path)
+        abort <<-END_PRIVILEGES.trim
+        I don't have enough privileges to remove '#{path}'.
+        Try running this program again with super user privileges:
+        
+            sudo #{$PROGRAM_NAME} reset
+        
+        END_PRIVILEGES
+      end
+    end
+  end
+end

data/lib/scout_agent/assignment/snapshot.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  class Assignment
+    class Snapshot < Assignment
+      def execute
+        log = ScoutAgent.prepare_wire_tap(:snapshot, :skip_stdout)
+        
+        unless db = Database.load(:snapshots, log)
+          abort_with_missing_db
+        end
+        
+        open(__FILE__) do |this_file|
+          unless this_file.flock(File::LOCK_EX | File::LOCK_NB)
+            exit  # snapshot in progress
+          end
+        
+          log.info("Building snapshot.")
+          status_database(log)
+          status("Building snapshot", :snapshot)
+          at_my_exit do
+            clear_status(:snapshot)
+          end
+
+          commands = db.current_commands
+        
+          if commands.empty?
+            if db.have_commands?
+              abort_with_too_recent
+            else
+              log.warn("No commands were found.")
+              abort_with_no_commands
+            end
+          end
+        
+          snapshot_started = Time.now
+          commands.each do |command|
+            log.info("Running `#{command[:code]}`.")
+            command_started = Time.now
+            output          = nil
+            begin
+              Timeout.timeout(command[:timeout]) do
+                output      = `sh -c #{shell_escape command[:code]} 2>&1`
+              end
+            rescue Timeout::Error
+              log.error("`#{command[:code]}` took too long to run.")
+              output        = "Error:  This command took too long to run"
+            end
+            exit_status     = $?.exitstatus
+            run_time        = Time.now - command_started
+            db.complete_run( command,
+                             output,
+                             exit_status,
+                             snapshot_started,
+                             run_time )
+            log.debug( "`#{command[:code]}` exited (#{exit_status}) in " +
+                       "#{run_time} seconds." )
+          end
+        
+          db.maintain
+          
+          log.info("Snapshot complete.")
+          this_file.flock(File::LOCK_UN)
+        end
+      end
+      
+      private
+
+      # Escape +str+ to make it useable in a shell as one "word".
+      def shell_escape(str)
+        str.to_s.gsub( /(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/, '\\'   ).
+                 gsub( /\n/,                                "'\n'" ).
+                 sub(  /^$/,                                "''"   )
+      end
+      
+      def abort_with_missing_db
+        warn "Snapshots database could not be loaded."
+        exit 1
+      end
+      
+      def abort_with_too_recent
+        warn "A snapshot was recently taken."
+        exit 2
+      end
+      
+      def abort_with_no_commands
+        warn "No snapshot commands have been received from the server."
+        exit 3
+      end
+    end
+  end
+end

data/lib/scout_agent/assignment/start.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  class Assignment
+    class Start < Assignment
+      choose_user  true
+      choose_group true
+      
+      def execute
+        unless Plan.pid_dir.exist?
+          unless Plan.build_pid_dir(group.gid)
+            abort_with_missing_pid_dir
+          end
+        end
+        
+        unless switch_group_and_user
+          abort_with_wrong_group_or_user
+        end
+        
+        unless test_server_connection(:quiet)
+          abort_with_cannot_connect
+        end
+        
+        unless Plan.valid?            and
+               Plan.pid_dir.exist?    and
+               Plan.pid_dir.readable? and
+               Plan.pid_dir.writable?
+          abort_with_missing_resources
+        end
+        
+        running_mode = Plan.run_as_daemon? ? " as a daemon" : ""
+        puts "Starting #{ScoutAgent.proper_agent_name}#{running_mode}..."
+        card = IDCard.new(:lifeline)
+        unless card.authorize { not Plan.run_as_daemon? or daemonize }
+          other_process = card.pid
+          if other_process and other_process != Process.pid
+            abort_with_other_process_running(other_process)
+          else
+            abort_with_failure_to_daemonize
+          end
+        end
+        
+        log = ScoutAgent.prepare_wire_tap(:lifeline)
+        log.info("Loading monitors.")
+        
+        lifelines = %w[master communication].map { |agent|
+          Lifeline.new(agent, log)
+        }
+        %w[TERM INT].each do |signal|
+          trap(signal) do 
+            lifelines.each { |line| line.terminate }
+            Process.waitall
+          end
+        end
+        lifelines.each { |line| line.launch_and_monitor }
+        
+        lifelines.each { |line| line.join }
+      end
+      
+      private
+      
+      def daemonize
+        exit!(0) if fork
+        Process.setsid
+        exit!(0) if fork
+        Dir.chdir("/")
+        File.umask(0000)
+        $stdin.reopen("/dev/null")
+        $stdout.reopen("/dev/null", "w")
+        $stderr.reopen("/dev/null", "w")
+        true
+      rescue Exception # if anything goes wrong
+        false
+      end
+      
+      def switch_group_and_user
+        if Process.euid != user.uid or Process.egid != group.egid
+          Process.initgroups(user.name, group.gid)  # prepare groups
+          Process::GID.change_privilege(group.gid)  # switch group
+          Process::UID.change_privilege(user.uid)   # switch user
+        end
+        true
+      rescue Errno::EPERM  # we don't have permission to make the change
+        false
+      end
+      
+      def abort_with_missing_pid_dir
+        abort <<-END_PID_DIR.trim
+        Unable to prepare PID file storage.  Please start the daemon
+        with super user privileges, which it will relenquish after
+        setup:
+        
+            sudo #{$PROGRAM_NAME} start
+        
+        END_PID_DIR
+      end
+      
+      def abort_with_cannot_connect
+        abort <<-END_CANNOT_CONNECT.trim
+        Unable to load a plan from the server at:
+        
+            #{Plan.server_url}
+        
+        If that URL looks correct and you are not having network
+        connectivity issues, please verify that the agent_key
+        setting is correct in:
+        
+            #{Plan.config_file}
+        
+        END_CANNOT_CONNECT
+      end
+
+      def abort_with_wrong_group_or_user
+        abort <<-END_GROUP_USER.trim
+        Unable to switch to the selected user and group.  Please
+        start the daemon with super user privileges, which it will
+        relenquish after setup:
+        
+            sudo #{$PROGRAM_NAME} start
+        
+        END_GROUP_USER
+      end
+      
+      def abort_with_missing_resources
+        abort <<-END_RESOURCES.trim
+        Some resources needed to complete the startup process are
+        not available.  Please make sure you have setup the daemon
+        with this command:
+    
+            sudo #{$PROGRAM_NAME} identify
+    
+        and that you have started the daemon with super user
+        privileges using this command:
+        
+            sudo #{$PROGRAM_NAME} start
+        
+        END_RESOURCES
+      end
+      
+      def abort_with_other_process_running(pid)
+        abort "The daemon is already running with the process ID of #{pid}."
+      end
+      
+      def abort_with_failure_to_daemonize
+        abort "Unable to daemonize this process."
+      end
+    end
+  end
+end

data/lib/scout_agent/assignment/status.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  class Assignment
+    class Status < Assignment
+      def execute
+        unless db = status_database
+          abort_with_missing_db
+        end
+        
+        puts "Status"
+        puts "======"
+        puts
+        statuses = db.current_statuses
+        if statuses.empty?
+          puts "#{ScoutAgent.proper_agent_name} is not currently running."
+        else
+          puts "#{ScoutAgent.proper_agent_name} is running:"
+          puts
+          columns = [
+            %w[Process       name],
+            %w[PID           pid],
+            %w[Current\ Task status],
+            %w[Last\ Updated last_updated_at]
+          ].map { |title, data| [title] + statuses.map { |row| row[data] } }
+          sizes   = columns.map { |column| 
+                      column.map { |field| field.to_s.size }.max }
+          format  = sizes.map { |size| "%-#{size}s" }.join(" ")
+          puts format % columns.map { |column| column.first }
+          puts format % sizes.map { |size| "-" * size }
+          columns.first[1..-1].
+                  zip(*columns[1..-1].map { |c| c[1..-1] }) do |row|
+            puts format % row
+          end
+        end
+      end
+      
+      def abort_with_missing_db
+        warn "Statuses database could not be loaded."
+        exit 1
+      end
+    end
+  end
+end