refactor zen command return value handling (#487)

- Improvement: Use consistent language for command line argument parsing errors
- Improvement: Changed zen command parsing errors to output help first and error last to make it easier to spot the error
- Improvement: Refactor zen command return codes to conform to valid Linux range (0-255)

        kSuccess     = 0,
        kOtherError  = 1,
        kBadInput    = 2,

        kOutOfMemory = 16,
        kOutOfDisk   = 17,

        kAssertError = 70,
        
        kHttpOtherClientError = 80,
        kHttpCantConnectError = 81,
        kHttpNotFound         = 66,  // NotFound(404)
        kHttpUnauthorized     = 77,  // Unauthorized(401),
        kHttpSLLError         = 82,
        kHttpForbidden        = 83,  // Forbidden(403)
        kHttpTimeout          = 84,  // RequestTimeout(408)
        kHttpConflict         = 85,  // Conflict(409)
        kHttpNoHost           = 86,
        
        kHttpOtherServerError	   = 90,
        kHttpInternalServerError = 91,  // InternalServerError(500)
        kHttpServiceUnavailable  = 69,  // ServiceUnavailable(503)
        kHttpBadGateway          = 92,  // BadGateway(502)
        kHttpGatewayTimeout      = 93,  // GatewayTimeout(504)

1 files changed, 36 insertions, 50 deletions

diff --git a/src/zen/cmds/up_cmd.cpp b/src/zen/cmds/up_cmd.cpp
index 8deb6c70e..a219677df 100644
--- a/src/zen/cmds/up_cmd.cpp
+++ b/src/zen/cmds/up_cmd.cpp
@@ -31,7 +31,7 @@ UpCommand::UpCommand()
 
 UpCommand::~UpCommand() = default;
 
-int
+void
 UpCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 {
 	using namespace std::literals;
@@ -40,12 +40,12 @@ UpCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 	if (!ParseOptions(argc, argv))
 	{
-		return 0;
+		return;
 	}
 
 	if (m_ShowConsole && m_ShowLog)
 	{
-		throw OptionParseException("--show-console can not be used in combination with --show-log");
+		throw OptionParseException("'--show-console' conficts with '--show-log'", m_Options.help());
 	}
 
 	{
@@ -73,7 +73,7 @@ UpCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 							RunningEntries[0].DesiredPort,
 							RunningEntries[0].EffectivePort,
 							RunningEntries[0].Pid);
-				return 0;
+				return;
 			}
 		}
 	}
@@ -99,20 +99,25 @@ UpCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	{
 		if (Server.IsRunning())
 		{
-			ZEN_CONSOLE_ERROR("Zen server launch failed (timed out), terminating");
+			ZEN_CONSOLE_WARN("Zen server launch failed (timed out), terminating");
 			Server.Terminate();
 			if (!m_ShowConsole)
 			{
 				ZEN_CONSOLE("{}", Server.GetLogOutput());
 			}
-			return 111;
+			throw std::runtime_error("Zen server launch failed (timed out), launched process was terminated");
 		}
-		int ReturnCode = Server.Shutdown();
+		int ServerExitCode = Server.Shutdown();
 		if (!m_ShowConsole)
 		{
 			ZEN_CONSOLE("{}", Server.GetLogOutput());
 		}
-		return ReturnCode;
+		if (ServerExitCode != 0)
+		{
+			throw ErrorWithReturnCode(
+				fmt::format("Zen server failed to get to a ready state and exited with return code {}", ServerExitCode),
+				ServerExitCode);
+		}
 	}
 	else
 	{
@@ -125,7 +130,6 @@ UpCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 			ZEN_CONSOLE("Zen server up");
 		}
 	}
-	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -139,14 +143,14 @@ AttachCommand::AttachCommand()
 
 AttachCommand::~AttachCommand() = default;
 
-int
+void
 AttachCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 {
 	ZEN_UNUSED(GlobalOptions);
 
 	if (!ParseOptions(argc, argv))
 	{
-		return 0;
+		return;
 	}
 
 	ZenServerState Instance;
@@ -158,8 +162,7 @@ AttachCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	{
 		if (!IsFile(m_DataDir / ".lock"))
 		{
-			ZEN_CONSOLE("Lock file does not exist in directory '{}'", m_DataDir);
-			return 1;
+			throw std::runtime_error(fmt::format("Lock file does not exist in directory '{}'", m_DataDir));
 		}
 		CbValidateError ValidateResult = CbValidateError::None;
 		if (CbObject LockFileObject =
@@ -170,33 +173,29 @@ AttachCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 			std::string	 Reason;
 			if (!ValidateLockFileInfo(Info, Reason))
 			{
-				ZEN_CONSOLE_ERROR("Lock file in directory '{}' is not valid. Reason: '{}'", m_DataDir, Reason);
-				return 1;
+				throw std::runtime_error(fmt::format("Lock file in directory '{}' is not valid. Reason: '{}'", m_DataDir, Reason));
 			}
 			Entry = Instance.LookupByEffectivePort(Info.EffectiveListenPort);
 		}
 		else
 		{
-			ZEN_CONSOLE_ERROR("Lock file in directory '{}' is not valid. Reason: '{}'", m_DataDir, ToString(ValidateResult));
-			return 1;
+			throw std::runtime_error(
+				fmt::format("Lock file in directory '{}' is malformed. Reason: '{}'", m_DataDir, ToString(ValidateResult)));
 		}
 	}
 
 	if (!Entry)
 	{
-		ZEN_CONSOLE_ERROR("No zen server instance to add sponsor process to");
-		return 1;
+		throw std::runtime_error("No zen server instance to add sponsor process to");
 	}
 
 	// Sponsor processes are checked every second, so 2 second wait time should be enough
 	if (!Entry->AddSponsorProcess(m_OwnerPid, 2000))
 	{
-		ZEN_CONSOLE_ERROR("Unable to add sponsor process to running zen server instance");
-		return 1;
+		throw std::runtime_error("Unable to add sponsor process to running zen server instance");
 	}
 
 	ZEN_CONSOLE("Added sponsor process {} to running instance {} on port {}", m_OwnerPid, Entry->Pid.load(), m_Port);
-	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -211,14 +210,14 @@ DownCommand::DownCommand()
 
 DownCommand::~DownCommand() = default;
 
-int
+void
 DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 {
 	ZEN_UNUSED(GlobalOptions);
 
 	if (!ParseOptions(argc, argv))
 	{
-		return 0;
+		return;
 	}
 
 	// Discover executing instances
@@ -236,8 +235,7 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	{
 		if (!IsFile(m_DataDir / ".lock"))
 		{
-			ZEN_CONSOLE_ERROR("Lock file does not exist in directory '{}'", m_DataDir);
-			return 1;
+			throw std::runtime_error(fmt::format("Lock file does not exist in directory '{}'", m_DataDir));
 		}
 		CbValidateError ValidateResult = CbValidateError::None;
 		if (CbObject LockFileObject =
@@ -248,15 +246,14 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 			std::string	 Reason;
 			if (!ValidateLockFileInfo(Info, Reason))
 			{
-				ZEN_CONSOLE_ERROR("Lock file in directory '{}' is not valid. Reason: '{}'", m_DataDir, Reason);
-				return 1;
+				throw std::runtime_error(fmt::format("Lock file in directory '{}' is not valid. Reason: '{}'", m_DataDir, Reason));
 			}
 			Entry = Instance.LookupByEffectivePort(Info.EffectiveListenPort);
 		}
 		else
 		{
-			ZEN_CONSOLE_ERROR("Lock file in directory '{}' is not valid. Reason: '{}'", m_DataDir, ToString(ValidateResult));
-			return 1;
+			throw std::runtime_error(
+				fmt::format("Lock file in directory '{}' is malformed. Reason: '{}'", m_DataDir, ToString(ValidateResult)));
 		}
 	}
 
@@ -282,7 +279,7 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 					if (Server.WaitUntilExited(100, Ec) && !Ec)
 					{
 						ZEN_CONSOLE("shutdown complete");
-						return 0;
+						return;
 					}
 					else if (Ec)
 					{
@@ -318,12 +315,12 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 			if (Entry == nullptr)
 			{
 				ZEN_CONSOLE("Shutdown complete");
-				return 0;
+				return;
 			}
 			if (Entry->Pid.load() != ServerProcessPid)
 			{
 				ZEN_CONSOLE("Shutdown complete");
-				return 0;
+				return;
 			}
 			Sleep(100);
 		}
@@ -337,21 +334,12 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		if (std::error_code Ec = FindProcess(ServerExePath, RunningProcess); !Ec, /*IncludeSelf*/ false)
 		{
 			ZEN_CONSOLE_WARN("Attempting hard terminate of zen process with pid ({})", RunningProcess.Pid());
-			try
-			{
-				if (RunningProcess.Terminate(0))
-				{
-					ZEN_CONSOLE("Terminate complete");
-					return 0;
-				}
-				ZEN_CONSOLE_ERROR("Failed to terminate server, still running");
-				return 1;
-			}
-			catch (const std::exception& Ex)
+			if (RunningProcess.Terminate(0))
 			{
-				ZEN_CONSOLE_ERROR("Failed to terminate server: '{}'", Ex.what());
-				return 1;
+				ZEN_CONSOLE("Terminate complete");
+				return;
 			}
+			throw std::runtime_error("Failed to terminate server, still running");
 		}
 		else
 		{
@@ -360,13 +348,11 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	}
 	else if (Entry)
 	{
-		ZEN_CONSOLE_ERROR("Failed to shutdown of server on port {}, use --force to hard terminate process",
-						  Entry->DesiredListenPort.load());
-		return 1;
+		throw std::runtime_error(
+			fmt::format("Failed to shutdown of server on port {}, use --force to hard terminate process", Entry->DesiredListenPort.load()));
 	}
 
 	ZEN_CONSOLE("No zen server to bring down");
-	return 0;
 }
 
 }  // namespace zen