Merge branch 'dev'

Author: spaulaus

CMakeLists.txt

@@ -109,7 +109,7 @@ if (NOT ${CORE_ONLY})
 
 	if (USE_SETUP) 
 		include_directories(Setup/include)
-		add_subdirectory(Setup/source)
+		add_subdirectory(Setup)
 	endif()
 
 	add_subdirectory(Poll)

Core/include/Display.h

@@ -14,7 +14,7 @@ namespace Display {
   std::string ErrorStr(const std::string &str = "[ERROR]");
   std::string InfoStr(const std::string &str);
   std::string OkayStr(const std::string &str = "[OK]");
-  std::string WarningStr(const std::string &str);
+  std::string WarningStr(const std::string &str = "[WARNING]");
 
   void LeaderPrint(const std::string &str);
   bool StatusPrint(bool errorStatus);

Core/include/Unpacker.hpp

@@ -25,6 +25,8 @@ class Unpacker{
 
 	TFile *root_file;
 	TTree *root_tree;
+	
+	std::string message_head; /// Prefix used for text output.
 
 	/** Clear all events in the raw event. WARNING! This method will delete all events in the
 	 * event list. This could cause seg faults if the events are used elsewhere.
@@ -87,6 +89,8 @@ class Unpacker{
 	/// Set the width of events in pixie16 clock ticks.
 	unsigned int SetEventWidth(unsigned int width_){ return (event_width = width_); }
 
+	void SetMsgPrefix(std::string prefix_){ message_head = prefix_; }
+	
 	/** ReadSpill is responsible for constructing a list of pixie16 events from
 	 * a raw data spill. This method performs sanity checks on the spill and
 	 * calls ReadBuffer in order to construct the event list.
@@ -96,15 +100,23 @@ class Unpacker{
 	/// Return the syntax string for this program.
 	virtual void SyntaxStr(const char *name_, std::string prefix_=""){ std::cout << prefix_ << "SYNTAX: " << std::string(name_) << " <options> <input>\n"; }
 
-	/// Print a help dialogue.
-	virtual void Help(std::string prefix_=""){}
+	/// Print a command line help dialogue for recognized command line arguments.
+	virtual void ArgHelp(std::string prefix_=""){}
+	
+	/// Print an in-terminal help dialogue for recognized commands.
+	virtual void CmdHelp(std::string prefix_=""){}
 
 	/// Scan input arguments and set class variables.
 	virtual bool SetArgs(std::deque<std::string> &args_, std::string &filename_){ return true; }
 
 	/// Print a status message.
 	virtual void PrintStatus(std::string prefix_=""){}
 
+	/** Search for an input command and perform the desired action. Return
+	  * true if the command is valid and false otherwise.
+	  */
+	virtual bool CommandControl(std::string cmd_, const std::vector<std::string> &args_){ return false; }
+
 	/// Empty the raw event and the event list.
 	void Close();
 };

Core/source/CTerminal.cpp

@@ -292,7 +292,6 @@ void signalResize(int ignore_) {
 	SIGNAL_RESIZE = true;
 }
 
-
 // Setup the interrupt signal intercept
 void setup_signal_handlers(){ 
 	// Handle segmentation faults press (SIGSEGV)
@@ -319,6 +318,14 @@ void setup_signal_handlers(){
 	//Handle resize signal
 	signal(SIGWINCH, signalResize);
 }
+
+void unset_signal_handlers(){
+	signal(SIGSEGV, SIG_DFL);
+	signal(SIGINT, SIG_DFL);
+	signal(SIGTSTP, SIG_DFL);
+	signal(SIGWINCH, SIG_DFL);
+}
+
 void Terminal::resize_() {
 	//end session and then refresh to get new window sizes.
 	endwin();
@@ -989,4 +996,6 @@ void Terminal::Close(){
 		init = false;
 	}
 	logFile.close();
+	
+	unset_signal_handlers();
 }

Core/source/ScanMain.cpp

@@ -11,8 +11,12 @@
 #include "poll2_socket.h"
 #include "CTerminal.h"
 
-#define SCAN_VERSION "1.2.00"
-#define SCAN_DATE "Oct. 1st, 2015"
+#define SCAN_VERSION "1.2.01"
+#define SCAN_DATE "Oct. 2nd, 2015"
+
+// Maximum size of the shared memory buffer
+static const unsigned int maxShmSizeL = 4052; // in pixie words (4050 + 2 header words)
+static const unsigned int maxShmSize  = maxShmSizeL * 4; // in bytes
 
 std::string prefix, extension;
 
@@ -27,7 +31,6 @@ bool force_overwrite;
 bool shm_mode;
 
 bool kill_all = false;
-bool scan_running = false;
 bool run_ctrl_exit = false;
 
 Server poll_server;
@@ -49,6 +52,22 @@ Terminal *term_;
 
 std::string sys_message_head = std::string(PROG_NAME) + ": ";
 
+unsigned int split_str(std::string str_, std::vector<std::string> &args, char delimiter_=' '){
+	args.clear();
+	std::string temp = "";
+	unsigned int count = 0;
+	for(unsigned int i = 0; i < str_.size(); i++){
+		if(str_[i] == delimiter_ || i == str_.size()-1){
+			if(i == str_.size()-1){ temp += str_[i]; }
+			args.push_back(temp);
+			temp = "";
+			count++;
+		}
+		else{ temp += str_[i]; }		
+	}
+	return count;
+}
+
 void start_run_control(Unpacker *core_){
 	if(debug_mode){
 		pldHead.SetDebugMode();
@@ -62,46 +81,56 @@ void start_run_control(Unpacker *core_){
 	// Now we're ready to read the first data buffer
 	if(shm_mode){
 		std::cout << std::endl;
-		unsigned int data[250000];
-		unsigned int shm_data[10002]; // Array to store the temporary shm data (~40 kB)
+		unsigned int data[250000]; // Array for storing spill data. Larger than any RevF spill should be.
+		unsigned int shm_data[maxShmSizeL]; // Array to store the temporary shm data (~16 kB)
 		int dummy;
 		int previous_chunk;
 		int current_chunk;
 		int total_chunks;
-		int nBytes;
-		unsigned int nTotalBytes;
+		int nWords;
+		unsigned int nTotalWords;
 
+		bool full_spill = false;
+		
 		while(true){
+			if(kill_all == true){ 
+				break;
+			}
+
+			int select_dummy;
 			previous_chunk = 0;
 			current_chunk = 0;
 			total_chunks = -1;
-			nTotalBytes = 0;
+			nTotalWords = 0;
+			full_spill = true;
+
+			std::stringstream status;
+			if(!poll_server.Select(dummy)){
+				status << "\033[0;33m" << "[IDLE]" << "\033[0m" << " Waiting for a spill...";
+				term_->SetStatus(status.str());
+				continue; 
+			}
 
+			if(!poll_server.Select(select_dummy)){ continue; } // Server timeout
+		
+			// Get the spill
 			while(current_chunk != total_chunks){
-				if(kill_all == true){ 
-					run_ctrl_exit = true;
-					return;
-				}
-
-				std::stringstream status;
-				if(!poll_server.Select(dummy)){
-					status << "\033[0;33m" << "[IDLE]" << "\033[0m" << " Waiting for a spill...";
-					term_->SetStatus(status.str());
-					continue; 
-				}
+				if(!poll_server.Select(select_dummy)){ // Server timeout
+					std::cout << sys_message_head << "Network timeout before recv full spill!\n";
+					full_spill = false;
+					break;
+				} 
 
-				nBytes = poll_server.RecvMessage((char*)shm_data, 40008); // Read from the socket
+				nWords = poll_server.RecvMessage((char*)shm_data, maxShmSize) / 4; // Read from the socket
 				if(strcmp((char*)shm_data, "$CLOSE_FILE") == 0 || strcmp((char*)shm_data, "$OPEN_FILE") == 0 || strcmp((char*)shm_data, "$KILL_SOCKET") == 0){ continue; } // Poll2 network flags
 				// Did not read enough bytes
-				else if(nBytes < 8){
+				else if(nWords < 2){
 					continue;
 				}
-				status << "\033[0;32m" << "[RECV] " << "\033[0m" << nBytes;
-				term_->SetStatus(status.str());
 
-				if(debug_mode){ std::cout << "debug: Received " << nBytes << " bytes from the network\n"; }
+				if(debug_mode){ std::cout << "debug: Received " << nWords << " words from the network\n"; }
 				memcpy((char *)&current_chunk, &shm_data[0], 4);
-				memcpy((char *)&total_chunks, &shm_data[4], 4);
+				memcpy((char *)&total_chunks, &shm_data[1], 4);
 
 				if(previous_chunk == -1 && current_chunk != 1){ // Started reading in the middle of a spill, ignore the rest of it
 					if(debug_mode){ std::cout << "debug: Skipping chunk " << current_chunk << " of " << total_chunks << std::endl; }
@@ -115,24 +144,29 @@ void start_run_control(Unpacker *core_){
 				previous_chunk = current_chunk;
 
 				// Copy the shm spill chunk into the data array
-				if(nTotalBytes + 2 + nBytes <= 1000000){ // This spill chunk will fit into the data buffer
-					memcpy(&data[nTotalBytes], &shm_data[8], nBytes - 8);
-					nTotalBytes += (nBytes - 8);				
+				if(nTotalWords + 2 + nWords <= 250000){ // This spill chunk will fit into the data buffer
+					memcpy(&data[nTotalWords], &shm_data[2], (nWords - 2)*4);
+					nTotalWords += (nWords - 2);				
 				}
 				else{ 
-					if(debug_mode){ std::cout << "debug: Abnormally full spill buffer with " << nTotalBytes + 2 + nBytes << " bytes!\n"; }
+					if(debug_mode){ std::cout << "debug: Abnormally full spill buffer with " << nTotalWords + 2 + nWords << " words!\n"; }
 					break; 
 				}
 			}
+
+			status << "\033[0;32m" << "[RECV] " << "\033[0m" << nTotalWords << " words";
+			term_->SetStatus(status.str());
 
-			if(debug_mode){ std::cout << "debug: Retrieved spill of " << nTotalBytes << " bytes (" << nTotalBytes/4 << " words)\n"; }
-			if(!dry_run_mode){ 
+			if(debug_mode){ std::cout << "debug: Retrieved spill of " << nTotalWords << " words (" << nTotalWords*4 << " bytes)\n"; }
+			if(!dry_run_mode && full_spill){ 
 				int word1 = 2, word2 = 9999;
-				memcpy(&data[nTotalBytes], (char *)&word1, 4);
-				memcpy(&data[nTotalBytes+4], (char *)&word2, 4);
-				core_->ReadSpill(data, nTotalBytes/4 + 2, is_verbose); 
+				memcpy(&data[nTotalWords], (char *)&word1, 4);
+				memcpy(&data[nTotalWords+1], (char *)&word2, 4);
+				core_->ReadSpill(data, nTotalWords + 2, is_verbose); 
 			}
-			num_spills_recvd++;
+			
+			if(!full_spill){ std::cout << sys_message_head << "Not processing spill fragment!\n"; }
+			else{ num_spills_recvd++; }
 		}
 	}
 	else if(file_format == 0){
@@ -208,27 +242,86 @@ void start_run_control(Unpacker *core_){
 	run_ctrl_exit = true;
 }
 
-void start_cmd_control(){
+void start_cmd_control(Unpacker *pack_){
+	if(!pack_){ return; }
+
 	std::string cmd = "", arg;
 
-	bool cmd_ready = true;
-	
 	while(true){
 		cmd = term_->GetCommand();
-		if(cmd == "CTRL_D"){ cmd = "quit"; }
-		else if(cmd == "CTRL_C"){ continue; }		
+		if(cmd == "_SIGSEGV_"){
+			std::cout << "\033[0;31m[SEGMENTATION FAULT]\033[0m\n";
+			exit(EXIT_FAILURE);
+		}
+		else if(cmd == "CTRL_D"){ 
+			std::cout << sys_message_head << "Received EOF (ctrl-d) signal. Exiting...\n";
+			cmd = "quit"; 
+		}
+		else if(cmd == "CTRL_C"){ 
+			std::cout << sys_message_head << "Warning! Received SIGINT (ctrl-c) signal.\n";
+			continue; 
+		}
+		else if(cmd == "CTRL_Z"){ 
+			std::cout << sys_message_head << "Warning! Received SIGTSTP (ctrl-z) signal.\n";
+			continue; 
+		}
 		term_->flush();
 
-		if(cmd_ready){
-			if(cmd == "quit" || cmd == "exit"){
-				if(scan_running){ std::cout << sys_message_head << "Warning! Cannot quit while scan is running\n"; }
-				else{
-					kill_all = true;
-					while(!run_ctrl_exit){ sleep(1); }
-					break;
-				}
+		if(cmd == ""){ continue; }
+		
+		size_t index = cmd.find(" ");
+		if(index != std::string::npos){
+			arg = cmd.substr(index+1, cmd.size()-index); // Get the argument from the full input string
+			cmd = cmd.substr(0, index); // Get the command from the full input string
+		}
+		else{ arg = ""; }
+
+		std::vector<std::string> arguments;
+		split_str(arg, arguments);
+		
+		if(cmd == "quit" || cmd == "exit"){
+			kill_all = true;
+			while(!run_ctrl_exit){ sleep(1); }
+			break;
+		}
+		else if(cmd == "version" || cmd == "v"){
+			std::cout << "  " << PROG_NAME << "      v" << SCAN_VERSION << " (" << SCAN_DATE << ")\n";
+			std::cout << "  Poll2 Socket  v" << POLL2_SOCKET_VERSION << " (" << POLL2_SOCKET_DATE << ")\n"; 
+			std::cout << "  HRIBF Buffers v" << HRIBF_BUFFERS_VERSION << " (" << HRIBF_BUFFERS_DATE << ")\n"; 
+			std::cout << "  CTerminal     v" << CTERMINAL_VERSION << " (" << CTERMINAL_DATE << ")\n";
+		}
+		else if(cmd == "help" || cmd == "h"){
+			std::cout << "  Help:\n";
+			std::cout << "   debug       - Toggle debug mode flag (default=false)\n";
+			std::cout << "   quiet       - Toggle quiet mode flag (default=false)\n";
+			std::cout << "   quit        - Close the program\n";
+			std::cout << "   help (h)    - Display this dialogue\n";
+			std::cout << "   version (v) - Display Poll2 version information\n";
+			pack_->CmdHelp("   ");
+		}
+		else if(cmd == "debug"){ // Toggle debug mode
+			if(debug_mode){
+				std::cout << sys_message_head << "Toggling debug mode OFF\n";
+				debug_mode = false;
 			}
-			else{ std::cout << sys_message_head << "Unknown command '" << cmd << "'\n"; }
+			else{
+				std::cout << sys_message_head << "Toggling debug mode ON\n";
+				debug_mode = true;
+			}
+			pack_->SetDebugMode(debug_mode);
+		}
+		else if(cmd == "quiet"){ // Toggle quiet mode
+			if(!is_verbose){
+				std::cout << sys_message_head << "Toggling quiet mode OFF\n";
+				is_verbose = true;
+			}
+			else{
+				std::cout << sys_message_head << "Toggling quiet mode ON\n";
+				is_verbose = false;
+			}
+		}
+		else if(!pack_->CommandControl(cmd, arguments)){ // Unrecognized command. Send it to Unpacker.
+			std::cout << sys_message_head << "Unknown command '" << cmd << "'\n";
 		}
 	}		
 }
@@ -266,7 +359,7 @@ void help(char *name_, Unpacker *core_){
 	std::cout << "   --quiet    - Toggle off verbosity flag\n";
 	std::cout << "   --dry-run  - Extract spills from file, but do no processing\n";
 	std::cout << "   --fast-fwd [word] - Skip ahead to a specified word in the file (start of file at zero)\n";
-	core_->Help("   ");
+	core_->ArgHelp("   ");
 }
 
 int main(int argc, char *argv[]){
@@ -277,10 +370,10 @@ int main(int argc, char *argv[]){
 		return 0;
 	}
 	else if(argc >= 2 && (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-v") == 0)){ // Display version information
-		std::cout << " " << PROG_NAME << "-------v" << SCAN_VERSION << " (" << SCAN_DATE << ")\n";
-		std::cout << " |hribf_buffers-v" << HRIBF_BUFFERS_VERSION << " (" << HRIBF_BUFFERS_DATE << ")\n";
-		std::cout << " |CTerminal-----v" << CTERMINAL_VERSION << " (" << CTERMINAL_DATE << ")\n";
-		std::cout << " |poll2_socket--v" << POLL2_SOCKET_VERSION << " (" << POLL2_SOCKET_DATE << ")\n";
+		std::cout << "  " << PROG_NAME << "      v" << SCAN_VERSION << " (" << SCAN_DATE << ")\n";
+		std::cout << "  Poll2 Socket  v" << POLL2_SOCKET_VERSION << " (" << POLL2_SOCKET_DATE << ")\n"; 
+		std::cout << "  HRIBF Buffers v" << HRIBF_BUFFERS_VERSION << " (" << HRIBF_BUFFERS_DATE << ")\n"; 
+		std::cout << "  CTerminal     v" << CTERMINAL_VERSION << " (" << CTERMINAL_DATE << ")\n";
 		return 0;
 	}
 
@@ -302,6 +395,8 @@ int main(int argc, char *argv[]){
 
 	Unpacker *core = GetCore(); // Get a pointer to the main Unpacker object.
 
+	core->SetMsgPrefix(sys_message_head);
+	
 	// Loop through the arg list and extract ScanMain arguments.
 	std::string current_arg;
 	while(!scan_args.empty()){
@@ -480,7 +575,7 @@ int main(int argc, char *argv[]){
 		// Start the command control thread. This needs to be the last thing we do to
 		// initialize, so the user cannot enter commands before setup is complete
 		std::cout << "Starting command thread\n\n";
-		std::thread comctrl(start_cmd_control);
+		std::thread comctrl(start_cmd_control, core);
 
 		// Synchronize the threads and wait for completion
 		comctrl.join();