void workerHandlingWorkersMenu(Worker *workers, int *workerCount) {
int op;
do {
workerHandlingWorkersMenuPrint();
readInt(&op, MENU_OPT_MIN, MENU_OPT_MAX, MENU_MSG_OPT);
switch (op) {
case 0: //exit
break;
case 1:
cleanScreen();
listAllWorkers(workers, workerCount);
break;
case 2:
cleanScreen();
editWorker(workers, workerCount);
break;
case 3:
cleanScreen();
removeWorker(workers, workerCount);
break;
default:
printf(MENU_MSG_OPT_INVALID);
}
} while (op != 0);
}
static void destroyWorker(Ejs *ejs, EjsWorker *worker)
{
if (!worker->inside) {
removeWorker(ejs, worker);
mprAssert(worker->pair);
mprFree(worker->pair->ejs);
worker->pair = 0;
}
ejsFreeVar(ejs, (EjsVar*) worker, -1);
}
void LoadBalancer::serverRemoved(ServerSocket *s) {
log() << "Server removed socket " << s;
if (SocketReceiver *conn = dynamic_cast<SocketReceiver *>(s)) {
if (pid_t peer = conn->peerPid()) {
removeWorker(peer);
log() << "Kill process " << peer;
kill(peer, SIGKILL);
}
} else {
log() << "Not a receiver";
}
}
/*
Called when destroying ejs
*/
PUBLIC void ejsRemoveWorkers(Ejs *ejs)
{
EjsWorker *worker;
int next;
for (next = 0; (worker = mprGetNextItem(ejs->workers, &next)) != NULL; ) {
#if UNUSED
worker->ejs = 0;
#else
removeWorker(worker);
#endif
}
ejs->workers = 0;
}
void TaskScheduler::waitUntilComplete(const Task* task)
{
if(task->isCanceled())
return;
{
Lock lock(mCompleteMutex);
while(!task->isComplete())
{
addWorker();
mTaskCompleteCond.wait(lock);
removeWorker();
}
}
}
static void manageWorker(EjsWorker *worker, int flags)
{
if (flags & MPR_MANAGE_MARK) {
ejsManagePot(worker, flags);
mprMark(worker->name);
mprMark(worker->ejs);
mprMark(worker->event);
mprMark(worker->pair);
mprMark(worker->scriptFile);
mprMark(worker->scriptLiteral);
} else if (flags & MPR_MANAGE_FREE) {
if (!worker->inside) {
removeWorker(worker);
}
if (worker->pair) {
if (worker->pair->pair) {
worker->pair->pair = 0;
}
worker->pair = 0;
}
}
}
void PipelineManager::removeWorkerEvent(Jzon::Node* params, Jzon::Object &outputNode)
{
int id;
if(!params) {
outputNode.Add("error", "Error removing worker. Invalid JSON format...");
return;
}
if (!params->Has("id")) {
outputNode.Add("error", "Error removing worker. Invalid JSON format...");
return;
}
id = params->Get("id").ToInt();
if (!removeWorker(id)) {
outputNode.Add("error", "Error removing worker. Internal error...");
return;
}
outputNode.Add("error", Jzon::null);
}
/*
Process a message sent from postMessage. This may run inside the worker or outside in the parent depending on the
direction of the message. But it ALWAYS runs in the appropriate thread for the interpreter.
*/
static int doMessage(Message *msg, MprEvent *mprEvent)
{
Ejs *ejs;
EjsObj *event, *frame;
EjsWorker *worker;
EjsFunction *callback;
EjsObj *argv[1];
worker = msg->worker;
worker->gotMessage = 1;
ejs = worker->ejs;
assert(!ejs->exception);
event = 0;
ejsBlockGC(ejs);
callback = ejsGetProperty(ejs, worker, msg->callbackSlot);
switch (msg->callbackSlot) {
case ES_Worker_onerror:
event = ejsCreateObj(ejs, ESV(ErrorEvent), 0);
break;
case ES_Worker_onclose:
case ES_Worker_onmessage:
event = ejsCreateObj(ejs, ESV(Event), 0);
break;
default:
assert(msg->callbackSlot == 0);
return 0;
}
worker->event = event;
if (msg->data) {
ejsSetProperty(ejs, event, ES_Event_data, ejsCreateStringFromAsc(ejs, msg->data));
}
if (msg->message) {
ejsSetProperty(ejs, event, ES_ErrorEvent_message, msg->message);
}
if (msg->stack) {
ejsSetProperty(ejs, event, ES_ErrorEvent_stack, msg->stack);
if ((frame = ejsGetProperty(ejs, msg->stack, 0)) != 0 && !ejsIs(ejs, frame, Void)) {
ejsSetProperty(ejs, event, ES_ErrorEvent_filename, ejsGetPropertyByName(ejs, frame, EN("filename")));
ejsSetProperty(ejs, event, ES_ErrorEvent_lineno, ejsGetPropertyByName(ejs, frame, EN("lineno")));
}
}
assert(!ejs->exception);
if (callback == 0 || ejsIs(ejs, callback, Null)) {
if (msg->callbackSlot == ES_Worker_onmessage) {
mprTrace(6, "Discard message as no onmessage handler defined for worker");
} else if (msg->callbackSlot == ES_Worker_onerror) {
if (ejsIs(ejs, msg->message, String)) {
ejsThrowError(ejs, "Exception in Worker: %@", ejsToString(ejs, msg->message));
} else {
ejsThrowError(ejs, "Exception in Worker: %s", ejsGetErrorMsg(worker->pair->ejs, 1));
}
} else {
/* Ignore onclose message */
}
} else if (!ejsIsFunction(ejs, callback)) {
ejsThrowTypeError(ejs, "Worker callback %s is not a function", msg->callback);
} else {
assert(!ejs->exception);
argv[0] = event;
ejsRunFunction(ejs, callback, worker, 1, argv);
}
if (msg->callbackSlot == ES_Worker_onclose) {
assert(!worker->inside);
worker->state = EJS_WORKER_COMPLETE;
mprTrace(5, "Worker.doMessage: complete");
/* Worker and insider interpreter are now eligible for garbage collection */
removeWorker(worker);
}
mprSignalDispatcher(ejs->dispatcher);
worker->event = 0;
return 0;
}
void LoadBalancer::processFinished(int pid, int wstatus) {
log() << "End of PID " << pid << ", status " << wstatus;
removeWorker(pid);
}
/*
* Process a message sent from postMessage. This may run inside the worker or outside in the parent depending on the
* direction of the message. But it ALWAYS runs in the appropriate thread for the interpreter.
*/
static void doMessage(Message *msg, MprEvent *mprEvent)
{
Ejs *ejs;
EjsVar *event;
EjsWorker *worker;
EjsFunction *callback;
EjsVar *argv[1];
worker = msg->worker;
ejs = worker->ejs;
callback = (EjsFunction*) ejsGetProperty(ejs, (EjsVar*) worker, msg->callbackSlot);
switch (msg->callbackSlot) {
case ES_ejs_sys_Worker_onclose:
event = ejsCreateVar(ejs, ejs->eventType, 0);
break;
case ES_ejs_sys_Worker_onerror:
event = ejsCreateVar(ejs, ejs->errorEventType, 0);
break;
case ES_ejs_sys_Worker_onmessage:
event = ejsCreateVar(ejs, ejs->eventType, 0);
break;
default:
mprAssert(msg->callbackSlot == 0);
mprFree(mprEvent);
return;
}
if (msg->data) {
ejsSetProperty(ejs, event, ES_ejs_events_Event_data, (EjsVar*) ejsCreateStringAndFree(ejs, msg->data));
}
if (msg->message) {
ejsSetProperty(ejs, event, ES_ejs_events_ErrorEvent_message, (EjsVar*) ejsCreateStringAndFree(ejs, msg->message));
}
if (msg->filename) {
ejsSetProperty(ejs, event, ES_ejs_events_ErrorEvent_filename, (EjsVar*) ejsCreateStringAndFree(ejs, msg->filename));
ejsSetProperty(ejs, event, ES_ejs_events_ErrorEvent_lineno, (EjsVar*) ejsCreateNumber(ejs, msg->lineNumber));
}
if (msg->stack) {
ejsSetProperty(ejs, event, ES_ejs_events_ErrorEvent_stack, (EjsVar*) ejsCreateStringAndFree(ejs, msg->stack));
}
if (callback == 0 || (EjsVar*) callback == ejs->nullValue) {
if (msg->callbackSlot == ES_ejs_sys_Worker_onmessage) {
mprLog(ejs, 1, "Discard message as no onmessage handler defined for worker");
} else if (msg->callbackSlot == ES_ejs_sys_Worker_onerror) {
ejsThrowError(ejs, "Exception in Worker: %s", ejsGetErrorMsg(worker->pair->ejs, 1));
} else {
/* Ignore onclose message */
}
} else if (!ejsIsFunction(callback)) {
ejsThrowTypeError(ejs, "Worker callback %s is not a function", msg->callback);
} else {
argv[0] = event;
ejsRunFunction(ejs, callback, (EjsVar*) worker, 1, argv);
}
if (msg->callbackSlot == ES_ejs_sys_Worker_onclose) {
mprAssert(!worker->inside);
worker->state = EJS_WORKER_COMPLETE;
removeWorker(ejs, worker);
/*
* Now that the inside worker is complete, the outside worker does not need to be protected from GC
*/
worker->obj.var.permanent = 0;
}
mprFree(msg);
mprFree(mprEvent);
}
