From 78507ed66eb987e22785d63c44b342bd6b2037e9 Mon Sep 17 00:00:00 2001 From: Bryan Roe Date: Wed, 13 Jan 2021 11:13:37 -0800 Subject: [PATCH] 1. Updated self-update logging to include current commit hash value 2. Updated child_process.waitExit() to throw an exception on empty set condition 3. Updated ILibChain_Continue() to exit while() loop on empty set 4. Updated agent-installer to better handle error conditions for updatervalue and meshservicename --- meshcore/agentcore.c | 172 ++++++++++++++----------- microscript/ILibDuktape_ChildProcess.c | 23 +++- microscript/ILibDuktape_Polyfills.c | 2 +- microstack/ILibParsers.c | 25 +++- microstack/ILibParsers.h | 12 +- modules/agent-installer.js | 24 +++- 6 files changed, 164 insertions(+), 94 deletions(-) diff --git a/meshcore/agentcore.c b/meshcore/agentcore.c index fda2578..59e2aeb 100644 --- a/meshcore/agentcore.c +++ b/meshcore/agentcore.c @@ -2574,6 +2574,14 @@ void MeshServer_selfupdate_continue(MeshAgentHostContainer *agent) if (agent->performSelfUpdate == 0) { agent->performSelfUpdate = 999; } // Never allow this value to be zero. #endif + + if (duk_peval_string(agent->meshCoreCtx, "process.versions.commitHash") == 0) + { + ILIBLOGMESSAGEX("SelfUpdate -> Current Version: %s", duk_safe_to_string(agent->meshCoreCtx, -1)); + } + duk_pop(agent->meshCoreCtx); // ... + + if (duk_peval_string_noresult(agent->meshCoreCtx, "require('service-manager').manager.getService('meshagentDiagnostic').start();") == 0) { if (agent->logUpdate != 0) @@ -2610,7 +2618,15 @@ void MeshServer_selfupdate_continue(MeshAgentHostContainer *agent) } else { - ILIBLOGMESSAGEX("SelfUpdate -> UpdaterVersion_ERROR: %s", duk_safe_to_string(agent->meshCoreCtx, -1)); + char *err = (char*)duk_safe_to_string(agent->meshCoreCtx, -1); + ILIBLOGMESSAGEX("SelfUpdate -> UpdaterVersion_ERROR: %s", err); + if (duk_ctx_is_alive(agent->meshCoreCtx)) + { + duk_push_sprintf(agent->meshCoreCtx, "require('MeshAgent').SendCommand({ action: 'sessions', type : 'msg', value : { 1: { value: 'Self-Update -> ABORT: %s', icon : 3 } } });", err); + duk_eval_noresult(agent->meshCoreCtx); + } + duk_pop(agent->meshCoreCtx); // ... + return; } duk_pop(agent->meshCoreCtx); // ... #endif @@ -2660,12 +2676,7 @@ void MeshServer_selfupdate_continue(MeshAgentHostContainer *agent) #endif // Everything looks good, lets perform the update - if (agent->logUpdate != 0) - { - char tmp[255]; - sprintf_s(tmp, sizeof(tmp), "SelfUpdate -> Stopping Chain (%d)", agent->performSelfUpdate); - ILIBLOGMESSSAGE(tmp); - } + ILIBLOGMESSAGEX("SelfUpdate -> Stopping Chain (%d)", agent->performSelfUpdate); ILibStopChain(agent->chain); } duk_ret_t MeshServer_selfupdate_unzip_complete(duk_context *ctx) @@ -3265,6 +3276,7 @@ void MeshServer_ProcessCommand(ILibWebClient_StateObject WebStateObject, MeshAge case MeshCommand_AgentUpdateBlock: { // Write the mesh agent block to file + int retryCount = 0; #ifdef WIN32 char* updateFilePath = MeshAgent_MakeAbsolutePath(agent->exePath, ".update.exe"); #else @@ -3272,7 +3284,7 @@ void MeshServer_ProcessCommand(ILibWebClient_StateObject WebStateObject, MeshAge #endif // We have to try to write until it works, fopen sometimes fails - while (util_appendfile(updateFilePath, cmd + 4, cmdLen - 4) == 0) + while (util_appendfile(updateFilePath, cmd + 4, cmdLen - 4) == 0 && ++retryCount < 4) { #ifdef WIN32 Sleep(100); @@ -3281,11 +3293,21 @@ void MeshServer_ProcessCommand(ILibWebClient_StateObject WebStateObject, MeshAge #endif } - // Confirm we got a mesh agent update block - ((unsigned short*)ILibScratchPad2)[0] = htons(MeshCommand_AgentUpdateBlock); // MeshCommand_AgentHash (14), SHA384 hash of the agent executable - ((unsigned short*)ILibScratchPad2)[1] = htons(requestid); // Request id - ILibWebClient_WebSocket_Send(WebStateObject, ILibWebClient_WebSocket_DataType_BINARY, ILibScratchPad2, 4, ILibAsyncSocket_MemoryOwnership_USER, ILibWebClient_WebSocket_FragmentFlag_Complete); - + if (retryCount < 4) + { + // Confirm we got a mesh agent update block + ((unsigned short*)ILibScratchPad2)[0] = htons(MeshCommand_AgentUpdateBlock); // MeshCommand_AgentHash (14), SHA384 hash of the agent executable + ((unsigned short*)ILibScratchPad2)[1] = htons(requestid); // Request id + ILibWebClient_WebSocket_Send(WebStateObject, ILibWebClient_WebSocket_DataType_BINARY, ILibScratchPad2, 4, ILibAsyncSocket_MemoryOwnership_USER, ILibWebClient_WebSocket_FragmentFlag_Complete); + } + else + { + if (duk_ctx_is_alive(agent->meshCoreCtx)) + { + // Update Failed, so update the server with an agent message explaining what happened, then abort the update by not sending an ACK + duk_eval_string_noresult(agent->meshCoreCtx, "require('MeshAgent').SendCommand({ action: 'sessions', type : 'msg', value : { 1: { value: 'Self-Update FAILED. Write Error while writing update block', icon : 3 } } });"); + } + } break; } } @@ -3552,6 +3574,8 @@ void MeshServer_ConnectEx_NetworkError(void *j) ILibMemory_Free(j); if (agent->controlChannelDebug != 0) { ILIBLOGMESSAGEX("Network Timeout Occurred..."); } + agent->serverConnectionState = 0; // We are cancelling connection request + printf("Network Timeout occurred...\n"); ILibWebClient_CancelRequest(request); @@ -5734,48 +5758,48 @@ int MeshAgent_Start(MeshAgentHostContainer *agentHost, int paramLen, char **para agentHost->chain = NULL; // Mesh agent has exited, set the chain to NULL // Close the database - if (agentHost->masterDb != NULL) + if (agentHost->masterDb != NULL) { if (agentHost->performSelfUpdate != 0) { if (agentHost->JSRunningAsService == 0) { - duk_context *ctxx = ILibDuktape_ScriptContainer_InitializeJavaScriptEngine_minimal(); - duk_size_t jsonLen; - char *json = NULL; + duk_context *ctxx = ILibDuktape_ScriptContainer_InitializeJavaScriptEngine_minimal(); + duk_size_t jsonLen; + char *json = NULL; - ILibDuktape_SimpleDataStore_raw_GetCachedValues_Array(ctxx, agentHost->masterDb); // [array] - if (duk_get_length(ctxx, -1) > 0) + ILibDuktape_SimpleDataStore_raw_GetCachedValues_Array(ctxx, agentHost->masterDb); // [array] + if (duk_get_length(ctxx, -1) > 0) + { + duk_json_encode(ctxx, -1); // [json] + json = (char*)duk_get_lstring(ctxx, -1, &jsonLen); + + startParms = (char*)ILibMemory_SmartAllocateEx(jsonLen + 1, ILibBase64EncodeLength(jsonLen + 1)); + unsigned char* tmp = (unsigned char*)ILibMemory_Extra(startParms); + memcpy_s(startParms, jsonLen + 1, json, jsonLen); + Duktape_SafeDestroyHeap(ctxx); + + if (jsonLen > INT32_MAX) { - duk_json_encode(ctxx, -1); // [json] - json = (char*)duk_get_lstring(ctxx, -1, &jsonLen); - - startParms = (char*)ILibMemory_SmartAllocateEx(jsonLen + 1, ILibBase64EncodeLength(jsonLen + 1)); - unsigned char* tmp = (unsigned char*)ILibMemory_Extra(startParms); - memcpy_s(startParms, jsonLen + 1, json, jsonLen); - Duktape_SafeDestroyHeap(ctxx); - - if (jsonLen > INT32_MAX) - { - ILibMemory_Free(startParms); - startParms = NULL; - if (agentHost->logUpdate != 0) { ILIBLOGMESSAGEX(" Service Parameters => ERROR"); } - } - else - { - ILibBase64Encode((unsigned char*)startParms, (int)jsonLen, &tmp); - if (agentHost->logUpdate != 0) { ILIBLOGMESSAGEX(" Service Parameters => %s", startParms); } - } + ILibMemory_Free(startParms); + startParms = NULL; + if (agentHost->logUpdate != 0) { ILIBLOGMESSAGEX(" Service Parameters => ERROR"); } } else { - if (agentHost->logUpdate != 0) { ILIBLOGMESSAGEX(" Service Parameters => NONE"); } + ILibBase64Encode((unsigned char*)startParms, (int)jsonLen, &tmp); + if (agentHost->logUpdate != 0) { ILIBLOGMESSAGEX(" Service Parameters => %s", startParms); } } + } + else + { + if (agentHost->logUpdate != 0) { ILIBLOGMESSAGEX(" Service Parameters => NONE"); } + } } else { #ifdef WIN32 - if(strcmp(agentHost->meshServiceName, "Mesh Agent") !=0) + if (strcmp(agentHost->meshServiceName, "Mesh Agent") != 0) #else if (strcmp(agentHost->meshServiceName, "meshagent") != 0) #endif @@ -5818,7 +5842,7 @@ int MeshAgent_Start(MeshAgentHostContainer *agentHost, int paramLen, char **para if (!CreateProcessW(NULL, ILibUTF8ToWide(ILibScratchPad, -1), NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &info, &processInfo)) { // We triedI to execute a bad executable... not good. Lets try to recover. - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> FAILED..."); } + ILIBLOGMESSSAGE("SelfUpdate -> FAILED..."); if (updateFilePath != NULL && agentHost->exePath != NULL) { while (util_CopyFile(agentHost->exePath, updateFilePath, FALSE) == FALSE) Sleep(5000); @@ -5833,7 +5857,7 @@ int MeshAgent_Start(MeshAgentHostContainer *agentHost, int paramLen, char **para { CloseHandle(processInfo.hProcess); CloseHandle(processInfo.hThread); - } + } #else if (agentHost->JSRunningAsService != 0) { @@ -5849,41 +5873,41 @@ int MeshAgent_Start(MeshAgentHostContainer *agentHost, int paramLen, char **para if (system(ILibScratchPad)) {} switch (agentHost->platformType) { - case MeshAgent_Posix_PlatformTypes_BSD: - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [restarting service]"); } - sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "service %s onerestart", agentHost->meshServiceName); // Restart the service - ignore_result(system(ILibScratchPad)); - break; - case MeshAgent_Posix_PlatformTypes_LAUNCHD: - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [kickstarting service]"); } - sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "launchctl kickstart -k system/%s", agentHost->meshServiceName); // Restart the service - ignore_result(system(ILibScratchPad)); - break; - case MeshAgent_Posix_PlatformTypes_SYSTEMD: - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [SYSTEMD should auto-restart]"); } - exit(1); - break; - case MeshAgent_Posix_PlatformTypes_PROCD: - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [PROCD should auto-restart]"); } - exit(1); - break; - case MeshAgent_Posix_PlatformTypes_INITD: - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... Calling Service restart (INITD)"); } - sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "service %s restart", agentHost->meshServiceName); // Restart the service - ignore_result(MeshAgent_System(ILibScratchPad)); - break; - case MeshAgent_Posix_PlatformTypes_INIT_UPSTART: - if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... Calling initctl restart (UPSTART)"); } - sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "initctl restart %s", agentHost->meshServiceName); // Restart the service - ignore_result(MeshAgent_System(ILibScratchPad)); - break; - default: - break; + case MeshAgent_Posix_PlatformTypes_BSD: + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [restarting service]"); } + sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "service %s onerestart", agentHost->meshServiceName); // Restart the service + ignore_result(system(ILibScratchPad)); + break; + case MeshAgent_Posix_PlatformTypes_LAUNCHD: + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [kickstarting service]"); } + sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "launchctl kickstart -k system/%s", agentHost->meshServiceName); // Restart the service + ignore_result(system(ILibScratchPad)); + break; + case MeshAgent_Posix_PlatformTypes_SYSTEMD: + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [SYSTEMD should auto-restart]"); } + exit(1); + break; + case MeshAgent_Posix_PlatformTypes_PROCD: + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... [PROCD should auto-restart]"); } + exit(1); + break; + case MeshAgent_Posix_PlatformTypes_INITD: + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... Calling Service restart (INITD)"); } + sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "service %s restart", agentHost->meshServiceName); // Restart the service + ignore_result(MeshAgent_System(ILibScratchPad)); + break; + case MeshAgent_Posix_PlatformTypes_INIT_UPSTART: + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Complete... Calling initctl restart (UPSTART)"); } + sprintf_s(ILibScratchPad, sizeof(ILibScratchPad), "initctl restart %s", agentHost->meshServiceName); // Restart the service + ignore_result(MeshAgent_System(ILibScratchPad)); + break; + default: + break; } } else { - if (agentHost->logUpdate != 0) + if (agentHost->logUpdate != 0) { ILIBLOGMESSSAGE("SelfUpdate -> Service Check... [NO]"); ILIBLOGMESSSAGE("SelfUpdate -> Manual Mode (COMPLETE)"); @@ -5908,7 +5932,7 @@ int MeshAgent_Start(MeshAgentHostContainer *agentHost, int paramLen, char **para } if (startParms != NULL) { ILibMemory_Free(startParms); } - + #ifndef MICROSTACK_NOTLS util_openssl_uninit(); #endif diff --git a/microscript/ILibDuktape_ChildProcess.c b/microscript/ILibDuktape_ChildProcess.c index f122cfe..dd6af39 100644 --- a/microscript/ILibDuktape_ChildProcess.c +++ b/microscript/ILibDuktape_ChildProcess.c @@ -187,6 +187,8 @@ duk_ret_t ILibDuktape_ChildProcess_Kill(duk_context *ctx) } duk_ret_t ILibDuktape_ChildProcess_waitExit(duk_context *ctx) { + ILibChain_Continue_Result continueResult; + int ret = 0; int timeout = duk_is_number(ctx, 0) ? duk_require_int(ctx, 0) : -1; void *chain = Duktape_GetChain(ctx); if (ILibIsChainBeingDestroyed(chain)) @@ -210,15 +212,26 @@ duk_ret_t ILibDuktape_ChildProcess_waitExit(duk_context *ctx) HANDLE handles[] = { NULL, NULL, NULL, NULL, NULL }; ILibProcessPipe_Process p = Duktape_GetPointerProperty(ctx, -1, ILibDuktape_ChildProcess_Process); ILibProcessPipe_Process_GetWaitHandles(p, &(handles[0]), &(handles[1]), &(handles[2]), &(handles[3])); - ILibChain_Continue(chain, (ILibChain_Link**)mods, 2, timeout, (HANDLE**)handles); + continueResult = ILibChain_Continue(chain, (ILibChain_Link**)mods, 2, timeout, (HANDLE**)handles); #else - ILibChain_Continue(chain, (ILibChain_Link**)mods, 3, timeout); + continueResult = ILibChain_Continue(chain, (ILibChain_Link**)mods, 3, timeout); #endif - if (ILibIsChainBeingDestroyed(chain) != 0) + switch (continueResult) { - return(ILibDuktape_Error(ctx, "waitExit() aborted because thread is exiting")); + case ILibChain_Continue_Result_ERROR_INVALID_STATE: + ret = ILibDuktape_Error(ctx, "waitExit() already in progress"); + break; + case ILibChain_Continue_Result_ERROR_CHAIN_EXITING: + ret = ILibDuktape_Error(ctx, "waitExit() aborted because thread is exiting"); + break; + case ILibChain_Continue_Result_ERROR_EMPTY_SET: + ret = ILibDuktape_Error(ctx, "waitExit() cannot wait on empty set"); + break; + default: + ret = 0; + break; } - return(0); + return(ret); } duk_ret_t ILibDuktape_ChildProcess_SpawnedProcess_Finalizer(duk_context *ctx) { diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index cd16607..93448db 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2352,7 +2352,7 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) duk_peval_string_noresult(ctx, "addCompressedModule('util-language', Buffer.from('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', 'base64'));"); // agent-instaler: Refer to modules/agent-installer.js - duk_peval_string_noresult(ctx, "addCompressedModule('agent-installer', Buffer.from('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', 'base64'));"); + duk_peval_string_noresult(ctx, "addCompressedModule('agent-installer', Buffer.from('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', 'base64'));"); // file-search: Refer to modules/file-search.js duk_peval_string_noresult(ctx, "addCompressedModule('file-search', Buffer.from('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', 'base64'));"); diff --git a/microstack/ILibParsers.c b/microstack/ILibParsers.c index b6b601d..38cf9f9 100644 --- a/microstack/ILibParsers.c +++ b/microstack/ILibParsers.c @@ -2322,11 +2322,12 @@ ILibChain_ContinuationStates ILibChain_GetContinuationState(void *chain) return(((ILibBaseChain*)chain)->continuationState); } #ifdef WIN32 -ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, int moduleCount, int maxTimeout, HANDLE **handles) +ILibExportMethod ILibChain_Continue_Result ILibChain_Continue(void *Chain, ILibChain_Link **modules, int moduleCount, int maxTimeout, HANDLE **handles) #else -ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, int moduleCount, int maxTimeout) +ILibExportMethod ILibChain_Continue_Result ILibChain_Continue(void *Chain, ILibChain_Link **modules, int moduleCount, int maxTimeout) #endif { + ILibChain_Continue_Result ret = ILibChain_Continue_Result_EXIT; ILibBaseChain *chain = (ILibBaseChain*)Chain; ILibChain_Link_Hook *nodeHook; ILibBaseChain *root = (ILibBaseChain*)chain; @@ -2341,7 +2342,7 @@ ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, ILibLinkedListNode tmpNode; memset(&tmpNode, 0, sizeof(tmpNode)); - if (root->continuationState != ILibChain_ContinuationState_INACTIVE && root->continuationState != ILibChain_ContinuationState_END_CONTINUE) { return; } + if (root->continuationState != ILibChain_ContinuationState_INACTIVE && root->continuationState != ILibChain_ContinuationState_END_CONTINUE) { return(ILibChain_Continue_Result_ERROR_INVALID_STATE); } root->continuationState = ILibChain_ContinuationState_CONTINUE; currentNode = root->node; @@ -2361,6 +2362,7 @@ ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, if (tv.tv_sec > (startTime.tv_sec + maxTimeout / 1000)) { root->continuationState = ILibChain_ContinuationState_END_CONTINUE; + ret = ILibChain_Continue_Result_TIMEOUT; break; } } @@ -2368,7 +2370,7 @@ ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, FD_ZERO(&readset); FD_ZERO(&errorset); FD_ZERO(&writeset); - tv.tv_sec = maxTimeout < 0 ? UPNP_MAX_WAIT : maxTimeout/1000; + tv.tv_sec = maxTimeout < 0 ? UPNP_MAX_WAIT : maxTimeout / 1000; tv.tv_usec = 0; // @@ -2395,9 +2397,9 @@ ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, //_CrtCheckMemory(); #endif #endif - } - ++mX; } + ++mX; + } tv.tv_sec = chain->selectTimeout / 1000; tv.tv_usec = 1000 * (chain->selectTimeout % 1000); @@ -2432,7 +2434,15 @@ ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, chain->currentWaitTimeout = 0; ILibChain_SetupWindowsWaitObject(chain->WaitHandles, &x, &tv, &(chain->currentWaitTimeout), &readset, &writeset, &errorset, chain->auxSelectHandles, handles); - slct = ILibChain_WindowsSelect(chain, &readset, &writeset, &errorset, chain->WaitHandles, x, chain->currentWaitTimeout); + if (x == 0) + { + ret = ILibChain_Continue_Result_ERROR_EMPTY_SET; + slct = -1; + } + else + { + slct = ILibChain_WindowsSelect(chain, &readset, &writeset, &errorset, chain->WaitHandles, x, chain->currentWaitTimeout); + } #else slct = select(FD_SETSIZE, &readset, &writeset, &errorset, &tv); #endif @@ -2501,6 +2511,7 @@ ILibExportMethod void ILibChain_Continue(void *Chain, ILibChain_Link **modules, root->currentHandle = currentHandle; root->currentInfo = currentInfo; #endif + return(root->TerminateFlag != 0 ? ILibChain_Continue_Result_ERROR_CHAIN_EXITING : ret); } ILibExportMethod void ILibChain_EndContinue(void *chain) diff --git a/microstack/ILibParsers.h b/microstack/ILibParsers.h index fce9a57..40dc3ce 100644 --- a/microstack/ILibParsers.h +++ b/microstack/ILibParsers.h @@ -389,6 +389,14 @@ int ILibIsRunningOnChainThread(void* chain); ILibChain_ContinuationState_CONTINUE = 1, ILibChain_ContinuationState_END_CONTINUE = 2 }ILibChain_ContinuationStates; + typedef enum ILibChain_Continue_Result + { + ILibChain_Continue_Result_EXIT = 0, + ILibChain_Continue_Result_TIMEOUT = 1, + ILibChain_Continue_Result_ERROR_INVALID_STATE = 10, + ILibChain_Continue_Result_ERROR_CHAIN_EXITING = 11, + ILibChain_Continue_Result_ERROR_EMPTY_SET = 12, + }ILibChain_Continue_Result; typedef void(*ILibChain_PreSelect)(void* object, fd_set *readset, fd_set *writeset, fd_set *errorset, int* blocktime); typedef void(*ILibChain_PostSelect)(void* object, int slct, fd_set *readset, fd_set *writeset, fd_set *errorset); @@ -1104,9 +1112,9 @@ int ILibIsRunningOnChainThread(void* chain); ILibExportMethod void ILibStartChain(void *chain); ILibExportMethod void ILibStopChain(void *chain); #ifdef WIN32 - ILibExportMethod void ILibChain_Continue(void *chain, ILibChain_Link **modules, int moduleCount, int maxTimeout, HANDLE **handles); + ILibExportMethod ILibChain_Continue_Result ILibChain_Continue(void *chain, ILibChain_Link **modules, int moduleCount, int maxTimeout, HANDLE **handles); #else - ILibExportMethod void ILibChain_Continue(void *chain, ILibChain_Link **modules, int moduleCount, int maxTimeout); + ILibExportMethod ILibChain_Continue_Result ILibChain_Continue(void *chain, ILibChain_Link **modules, int moduleCount, int maxTimeout); #endif ILibExportMethod void ILibChain_EndContinue(void *chain); ILibChain_ContinuationStates ILibChain_GetContinuationState(void *chain); diff --git a/modules/agent-installer.js b/modules/agent-installer.js index 4be2bbb..d4ea0d2 100644 --- a/modules/agent-installer.js +++ b/modules/agent-installer.js @@ -698,6 +698,7 @@ function sys_update(isservice, b64) if (child.stdout.str.trim() == '' && b64 == null) { child.stdout.str = 'Mesh Agent'; } if (child.stdout.str.trim() != '') { + if (child.stdout.str.trim().split('\n').length > 1) { child.stdout.str = 'Mesh Agent'; } try { service = require('service-manager').manager.getService(child.stdout.str.trim()) @@ -789,18 +790,31 @@ function sys_update(isservice, b64) function agent_updaterVersion(updatePath) { + var ret = 0; if (updatePath == null) { updatePath = process.execPath; } - var child = require('child_process').execFile(updatePath, [updatePath.split(process.platform == 'win32' ? '\\' : '/').pop(), '-updaterversion']); - child.stdout.str = ''; child.stdout.on('data', function (c) { this.str += c.toString(); }); - child.waitExit(); - if(child.stdout.str.trim() == '') + var child; + + try + { + child = require('child_process').execFile(updatePath, [updatePath.split(process.platform == 'win32' ? '\\' : '/').pop(), '-updaterversion']); + } + catch(x) { return (0); } + child.stdout.str = ''; child.stdout.on('data', function (c) { this.str += c.toString(); }); + child.waitExit(); + + if(child.stdout.str.trim() == '') + { + ret = 0; + } else { - return (parseInt(child.stdout.str)); + ret = parseInt(child.stdout.str); + if (isNaN(ret)) { ret = 0; } } + return (ret); } function win_consoleUpdate()