linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9eb83d3d3fe17f3fcf789a4308138e4e470ffe3a
sics/scriptcontext.c
zolliker 68ec926a8b - introduce script context
2008-01-18 07:55:58 +00:00

1459 lines
38 KiB
C
Raw Blame History

#include <strings.h>
#include <tcl.h>
#include <time.h>
#include <math.h>
#include "sics.h"
#include "sicsobj.h"
#include "initializer.h"
#include "commandlog.h"
#include "hipadaba.h"
#include "sicshipadaba.h"
#include "dynstring.h"
#include "ascon.h"
#include "errormsg.h"
/** \file
* \brief script context implementation (Sct)
*/
/** \brief the maximum hdb path length */
#define MAX_HDB_PATH 1024
typedef enum {
sct_send_keyword,
sct_result_keyword,
sct_command_keyword,
sct_path_keyword,
sct_update_keyword,
sct_take_keyword,
sct_complete_keyword,
sct_chain_keyword,
sct_next_keyword,
sct_steplist_keyword,
sct_no_keyword
} SctKeyword;
/* keywords must have the same order as SctKeyword */
static char *sctKeywords[]={
"send",
"result",
"command",
"path",
"update",
"take",
"complete",
"chain",
"next",
"steplist",
NULL
};
static char *reset_type="";
typedef struct SctList SctList;
typedef struct SctChain {
struct SctChain *next;
char *command;
SctList *scriptList;
pHdb relatedNode;
ErrMsg *msg;
int doit;
char *dynamic;
} SctChain;
/* define SctChainList and their functions */
#define MC_NAME(T) SctChain##T
#include "mclist.c"
typedef enum {set_type, timed_type, manual_type, no_type} SctScriptListType;
static char *slTypes[]={"set", "timed", "manual", NULL};
struct SctList {
struct SctList *next;
char *name;
SctChain *beginScript;
SctChain *endScript;
SctScriptListType type;
int dirty;
double interval;
double lastPeriod;
SctChain *lastScript;
SctChainList chains;
};
/* define SctListList and their functions */
#define MC_NAME(T) SctList##T
#include "mclist.c"
typedef struct Sct Sct;
typedef struct SctParData {
struct SctParData *next;
Sct *sct;
SctChain *scriptChain;
int pending, inprogress;
int refCnt;
hdbValue target;
SCStore conCtx;
} SctParData;
typedef struct SctObjectName {
struct SctObjectName *next;
char *name;
} SctObjectName;
/* define SctObjectNameList and their functions */
#define MC_NAME(T) SctObjectName##T
#include "mclist.c"
struct Sct {
pObjectDescriptor desc;
char *name;
SctListList scriptLists;
SctObjectNameList names; /* created with the "object" command, needed for kill only */
AsconPtr ascon;
pHdb currentNode;
SctParData *foundData;
char *cmd;
char *result;
char *nextScript;
SctChain *runningChain;
SCStore debugConn;
char *debugCommand;
int sent;
SctKeyword operation;
int killTask;
int killObj;
int verbose;
int taskSteps;
};
static Sct *sct = NULL;
static void SctFreeParData(void *d) {
SctParData *data=d;
data->refCnt--;
if (data->refCnt == 0) {
if (data->conCtx) SCStoreFree(data->conCtx);
free(data);
}
}
pHdb SctFindObjNode(char *name) {
CommandList *cmd;
pDummy obj;
cmd = FindCommand(pServ->pSics, name);
if (cmd == NULL) return NULL;
obj = (void *)cmd->pData;
if (obj == NULL || obj->pDescriptor->parNode==NULL) return NULL;
return obj->pDescriptor->parNode;
}
/** \brief find the node with the relative path relpath
* \param node the root node (where to start)
* \param relpath an absolute or relative path
* \param parentPtr a pointer to the found parent (may be NULL if not used)
* \param nodePtr a pointer to the found node
* \return the name of the node
*
* An abolute path starts with a slash, a relative path equal to "."
* means that the input node is returned. A syntax like "..", "../down"
* is also allowed, but the double dots must appear at the start of the path.
*
* This routine may also be used in order to find the parent node of
* a node not yet existing. In this case the nodePtr will point
* to a NULL pointer on return, and a pointer to the last element
* in the path is returned.
*
* Nodes anchored in the sics object list are also found when
* the path starts with "/sics/"
*/
char *SctFindNode(pHdb node, char *relpath, pHdb *parentPtr, pHdb *nodePtr) {
char *path;
char buffer[MAX_HDB_PATH];
pHdb root = NULL;
char *name;
char *slash;
if (strlen(relpath) >= sizeof(buffer)) {
*nodePtr = NULL;
return NULL; /* relpath too long */
}
strcpy(buffer, relpath);
path = buffer;
if (path[0] == '/') {
if (strncmp(path, "/sics/", 6) == 0) {
/* sics object case */
slash = strchr(path+6, '/');
if (slash != NULL) {
*slash = '\0';
}
node = SctFindObjNode(path);
if (node == NULL) goto notFound;
if (slash == NULL) goto nodeFound;
path = slash+1;
/* root node is sics object, path is relative to it */
} else {
/* absolute path */
node = GetHipadabaRoot();
/* strip off first slash, root node is sics root */
path++;
}
} else if (path[0] == '.') {
if (path[1] == '\0') {
/* this path */
goto nodeFound;
}
/* upper node */
while (strncmp(path, "..", 2) == 0 && node != NULL) {
node = node->mama;
if (path[2] == '\0') goto nodeFound;
path += 3;
}
if (node == NULL) goto notFound;
}
/* now go down in path */
while (node != NULL) {
root = node;
slash = strchr(path, '/');
if (slash != NULL) *slash='\0';
for (node = root->child; node != NULL; node = node->next) {
if (strcasecmp(node->name, path) == 0) {
if (slash == NULL) goto nodeFound;
path = slash + 1;
break;
}
}
}
if (slash == NULL) {
if (parentPtr != NULL) {
*parentPtr = root;
}
*nodePtr = NULL;
/* the returned name must be taken from the end of relpath, as path is no longer valid */
name = relpath + (path - buffer);
goto finish;
}
notFound:
node = NULL;
nodeFound:
*nodePtr = node;
if (node) {
if (parentPtr != NULL) {
*parentPtr = node->mama;
}
name = node->name;
} else {
if (parentPtr != NULL) {
*parentPtr = NULL;
}
name = NULL;
}
finish:
return name;
}
/** \brief get the absolute path of a node anchored in the
* Hipadaba root or in a sics object
* \param nodeArg the input node
* \param path the result
* \param pathlen length of the result
* \return 1 on success, 0 on failure
*/
int SctGetPath(pHdb nodeArg, char *path, size_t pathlen) {
pHdb node, root;
int len, pos, l;
static char *sics="/sics";
/* determine path length and root node */
root = nodeArg;
len = 0;
for (node = nodeArg; node != NULL; node = node->mama) {
len += strlen(node->name) + 1;
if (len >= pathlen) return 0; /* buffer overflow (may be recursize path?) */
root = node;
}
/* check root and add prefix */
path[0]='\0';
if (root != GetHipadabaRoot()) { /* not anchored in root */
if (!FindCommand(pServ->pSics, root->name)) {
/* not a sicsobject, give up */
path[0]='\0';
return 0;
}
/* sics object case */
l = strlen(sics);
len += l;
if (len >= pathlen) return 0;
strncpy(path, sics, l);
}
/* build the path backwards */
path[len]='\0';
pos = len;
for (node = nodeArg; node != NULL; node = node->mama) {
len = strlen(node->name);
pos -= len;
assert(pos>0);
strncpy(path+pos, node->name, len);
pos--;
path[pos]='/';
}
return 1;
}
static int UpdateNode(SConnection *con, ErrMsgList *e, pHdb node, int argc, char *argv[]) {
hdbValue newValue;
static char errtxt[512];
char *str;
int status;
if (!cloneHdbValue(&node->value, &newValue)) {
ErrPutMsg(e, NULL, "no memory");
return 0;
}
str = ConcatArgs(argc, argv);
if (str == NULL) {
ErrPutMsg(e, NULL, "no memory");
return 0;
}
if (!readHdbValue(&newValue, str, errtxt, sizeof errtxt)) {
ErrPutMsg(e, errtxt, "conversion failure");
return 0;
}
free(str);
status = UpdateHipadabaPar(node, newValue, con);
ReleaseHdbValue(&newValue);
return status;
}
static int SctFindKeyword(char *name, char *keywords[]) {
int i;
for (i=0; keywords[i]!=NULL; i++) {
if (strcasecmp(name, keywords[i]) == 0) return i;
}
return i;
}
static SctChain *SctMakeChain(char *command) {
SctChain *sc;
sc = calloc(1, sizeof(*sc));
if (sc == NULL) return NULL;
sc->doit = 0;
sc->dynamic = NULL;
sc->command = command;
sc->scriptList = NULL;
sc->msg = NULL;
return sc;
}
static void SctSetListDirty(SctList *sl) {
if (!sl->dirty) {
sl->dirty = 1;
if (sl->beginScript) {
sl->beginScript->doit = 1;
}
}
}
static void SctSetDirty(SctChain *sc) {
SctSetListDirty(sc->scriptList);
sc->doit = 1;
}
static int SctUpdateCallback(void *user, void *conn, pHdb node, hdbValue value) {
SctParData *data = user;
SConnection *con;
char path[MAX_HDB_PATH];
pDynString str;
if (data->inprogress) {
if (data->sct->operation == sct_complete_keyword) {
data->inprogress = 0;
SctGetPath(node, path, sizeof path);
con = SCStorePush(data->conCtx);
str = formatValue(value, node);
SCPrintf(con, eStatus, "%s = %s", path,
GetCharArray(str));
DeleteDynString(str);
SCStorePop(data->conCtx);
}
}
return 1;
}
static int SctSetCallback(void *user, void *conn, pHdb node, hdbValue value) {
SctParData *data = user;
SConnection *oldCon;
char path[MAX_HDB_PATH];
pDynString str;
if (data->scriptChain) {
if (data->pending) {
SctGetPath(node, path, sizeof path);
oldCon = SCStorePush(data->conCtx);
str = formatValue(value, node);
SCPrintf(oldCon, eStatus, "target of %s changed to %s", path,
GetCharArray(str));
DeleteDynString(str);
SCStorePop(data->conCtx);
}
data->conCtx = SCSave(conn, data->conCtx);
data->pending = 1;
SctSetDirty(data->scriptChain);
copyHdbValue(&value, &data->target);
return 0;
}
return 1;
}
static int SctReadCallback(void *user, void *conn, pHdb node, hdbValue value) {
SctParData *data = user;
data->sct->foundData = data;
if (data->sct->operation == sct_take_keyword && data->pending) {
data->pending = 0;
data->inprogress = 1;
return 0;
}
return 1;
}
static int SctExec(SConnection *con, SicsInterp *sics, void *object, int argc, char *argv[]) {
SctKeyword keyword;
SctList *sl;
SctChain *sc;
pHdb node;
hdbValue newValue;
pDynString result;
char *args;
char path[MAX_HDB_PATH];
SConnection *dcon;
if (sct == NULL) {
SCPrintf(con, eError, "ERROR: %s may be called only in proper context", argv[0]);
return 0;
};
if (argc < 2) {
SCPrintf(con, eInError, "ERROR: missing %s subcommand", argv[0]);
goto quit;
};
if (sct->verbose != 0) {
args = ConcatArgs(argc, argv);
dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "commnd: %s", args);
SCStorePop(sct->debugConn);
free(args);
args = NULL;
}
keyword = SctFindKeyword(argv[1], sctKeywords);
sct->operation = keyword;
switch (keyword) {
case sct_send_keyword:
if (argc < 4) {
SCPrintf(con, eInError, "ERROR: should be: %s send <cmd> <script ...>", argv[0]);
goto quit;
}
if (sct->cmd != NULL || sct->nextScript != NULL) {
SCPrintf(con, eInError, "ERROR: %s busy", argv[0]);
sct->taskSteps = 0;
goto quit;
}
if (sct->ascon == 0) {
SCPrintf(con, eInError, "ERROR: %s has no connection", argv[0]);
goto quit;
}
sct->cmd = strdup(argv[2]);
if (sct->verbose != 0) {
dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "send : %s", sct->cmd);
SCStorePop(sct->debugConn);
}
AsconWrite(sct->ascon, sct->cmd, 0);
sct->nextScript = ConcatArgs(argc-3, argv+3);
if (sct->result) free(sct->result);
sct->result = NULL;
break;
case sct_result_keyword:
if (!sct->result) {
SCPrintf(con, eInError, "ERROR: no result available");
goto quit;
}
SCWrite(con, sct->result, eValue);
goto success;
case sct_command_keyword:
if (!sct->cmd) {
SCPrintf(con, eInError, "ERROR: no command available");
goto quit;
}
SCWrite(con, sct->cmd, eValue);
goto success;
case sct_path_keyword:
if (SctGetPath(sct->currentNode, path, sizeof path)) {
SCWrite(con, path, eValue);
} else {
SCWrite(con, "ERROR: node not anchored or path name too long", eInError);
}
goto success;
case sct_complete_keyword:
/* fall through */
case sct_update_keyword:
if (argc < 4) {
SCPrintf(con, eInError, "ERROR: should be: %s %s <par> <value>", argv[0], argv[1]);
goto quit;
}
SctFindNode(sct->currentNode, argv[2], NULL, &node);
if (node == NULL) {
goto missingPar;
}
return UpdateNode(con, AsconGetErrList(sct->ascon), node, argc-3, argv+3);
case sct_take_keyword:
if (argc < 3) {
SCPrintf(con, eInError, "ERROR: should be: %s take <par>", argv[0]);
goto quit;
}
SctFindNode(sct->currentNode, argv[2], NULL, &node);
if (node == NULL) {
goto missingPar;
}
memset(&newValue,0,sizeof(hdbValue));
sct->foundData = NULL;
GetHipadabaPar(node, &newValue, con);
if (sct->foundData) {
cloneHdbValue(&sct->foundData->target, &newValue);
}
result = formatValue(newValue, node);
ReleaseHdbValue(&newValue);
if (result == NULL) goto noMemory;
if (sct->verbose != 0) {
dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "result: %s", GetCharArray(result));
SCStorePop(sct->debugConn);
}
SCWrite(con, GetCharArray(result), eValue);
DeleteDynString(result);
goto success;
case sct_steplist_keyword:
if (argc != 3) {
SCPrintf(con, eInError, "ERROR: should be: %s stepList <list>", argv[0]);
goto quit;
}
for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
if (strcasecmp(sl->name, argv[2]) == 0) {
SctSetListDirty(sl);
goto success;
}
}
goto missingScriptList;
case sct_chain_keyword:
if (argc < 4) {
SCPrintf(con, eInError, "ERROR: should be: %s chain <name> <script>", argv[0]);
goto quit;
}
for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
for (sc = sl->chains.head; sc != NULL; sc = sc->next) { /* don't touch the list pos */
if (sc->dynamic && strcasecmp(argv[2], sc->dynamic) == 0) {
if (sc->command) free(sc->command);
sc->command = ConcatArgs(argc - 3, argv + 3);
goto success;
}
}
}
SCPrintf(con, eInError, "ERROR: dynamic script %s not found", argv[2]);
goto quit;
case sct_next_keyword:
if (argc < 3) {
SCPrintf(con, eInError, "ERROR: should be: %s next <script>", argv[0]);
goto quit;
}
sc = sct->runningChain;
if (sc == NULL || sc->dynamic == NULL) goto notDynamic;
if (sc->command) free(sc->command);
sc->command = ConcatArgs(argc - 2, argv + 2);
sc->doit = 1;
break;
case sct_no_keyword:
SCPrintf(con, eInError, "ERROR: %s %s: unknown keyword", argv[0], argv[1]);
goto quit;
default:
SCPrintf(con, eInError, "ERROR: %s %s: untreated keyword", argv[0], argv[1]);
goto quit;
}
/* no OK message needed, as this command will never be called from a client */
success:
sct->operation = sct_no_keyword;
return 1;
noMemory:
SCWrite(con, "ERROR: no memory", eInError);
goto quit;
missingPar:
SCPrintf(con, eInError, "ERROR: parameter %s not found", argv[2]);
goto quit;
notDynamic:
SCPrintf(con, eInError, "ERROR: script is not dynamic");
goto quit;
missingScriptList:
SCPrintf(con, eInError, "ERROR: script list %s not found", argv[2]);
goto quit;
quit:
sct->operation = sct_no_keyword;
return 0;
}
static int SctWrapper(SConnection *con, SicsInterp *sics, void *object, int argc, char *argv[]) {
Sct *sct;
SctParData *data;
hdbValue val;
char *mode;
pDynString dyn;
pHdb node;
ErrMsg *msg;
typedef enum {
target_keywd,
no_keywd
} Keyword;
/* keywds must have the same order as Keyword */
static char *keywds[]={
"-t", /* show state and target value */
NULL
};
Keyword keywd;
if (argc < 2) {
return InvokeSICSOBJ(con, sics, object, argc, argv);
};
keywd = SctFindKeyword(argv[1], keywds);
sct = ((pSICSOBJ)object)->pPrivate;
switch (keywd) {
case no_keywd: return InvokeSICSOBJ(con, sics, object, argc, argv);
case target_keywd:
if (argc < 3) {
SCWrite(con, "ERROR: missing par", eInError);
return 0;
}
SctFindNode(sct->currentNode, argv[2], NULL, &node);
if (node == NULL) {
SCPrintf(con, eInError, "ERROR: %s %s not found", argv[0], argv[2]);
return 0;
}
sct->foundData = NULL;
GetHipadabaPar(node, &val, con);
data = sct->foundData;
if (data) {
if (data->pending) {
if (data->inprogress) {
mode = "inprogress pending";
} else {
mode = "pending";
}
cloneHdbValue(&data->target, &val);
} else {
if (data->inprogress) {
mode = "inprogress";
cloneHdbValue(&data->target, &val);
} else {
mode = "idle";
}
}
if (data->scriptChain && data->scriptChain->msg) {
msg = data->scriptChain->msg;
if (msg->data) {
SCPrintf(con, eInError, "ERROR:\n%s (%s)\n", msg->text, msg->data);
} else {
SCPrintf(con, eInError, "ERROR:\n%s\n", msg->text);
}
}
} else {
mode = "rdonly";
}
dyn = formatValue(val, node);
ReleaseHdbValue(&val);
SCPrintf(con, eValue, "%s %s", mode, GetCharArray(dyn));
DeleteDynString(dyn);
break;
default:
SCPrintf(con, eInError, "ERROR: %s %s: untreated keyword", argv[0], argv[1]);
return 0;
}
return 1;
}
static char *SctChainCmd(char *cmd) {
static char buf[512];
if (sct->runningChain && strcmp(sct->runningChain->command, cmd) != 0) {
snprintf(buf, sizeof buf, "chain: %s\ncmd : %s\n", sct->runningChain->command, cmd);
} else {
snprintf(buf, sizeof buf, "cmd : %s\n", cmd);
}
return buf;
}
static char *SctCall(char *command) {
char *error;
Tcl_Interp *pTcl = InterpGetTcl(pServ->pSics);
int ret, l;
ErrMsg *msg;
SConnection *dcon;
if (sct->verbose != 0) {
dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eInError, "script: %s\n", command);
SCStorePop(sct->debugConn);
}
l = strlen(command);
ret = Tcl_EvalEx(pTcl, command, l, 0);
error = (char *)Tcl_GetStringResult(pTcl);
if (ret != TCL_OK && error[0]!='\0') {
msg = ErrPutMsg(AsconGetErrList(sct->ascon), NULL,
"%serror: %s", SctChainCmd(command), error);
if (sct->runningChain) {
sct->runningChain->msg = msg;
}
return error;
}
return NULL;
}
static char *SctCallChain(SctChain *sc) {
sct->runningChain = sc;
sct->currentNode = sc->relatedNode;
sc->msg = NULL;
return SctCall(sc->command);
}
static void SctCallNext(void) {
char *cmd = sct->nextScript;
sct->nextScript = NULL;
if (SctCall(cmd) != NULL) {
if (sct->cmd) {
free(sct->cmd);
sct->cmd = NULL;
}
}
free(cmd);
}
static int SctTask(void *object) {
AsconStatus status;
char *response;
double period;
SctList *sl;
SctChain *sc;
SConnection *dcon = NULL;
if (sct) {
WriteToCommandLog("SCT>", "forbidden command (like wait) called in script");
goto quit;
}
sct = object;
if (sct->killObj) {
sct->taskSteps = 0;
sct = NULL;
return 0;
}
if (!sct->ascon) { /* no connection */
goto quit;
}
if (sct->taskSteps == 0) {
goto quit;
}
recycle:
status = AsconTask(sct->ascon);
if (status == AsconFailure) {
/* decide what to do on failure */
} else if (status != AsconReady) {
goto quit;
}
if (sct->taskSteps > 0) {
if (sct->taskSteps == 0) {
goto quit;
}
sct->taskSteps--;
}
response = AsconRead(sct->ascon);
if (response != NULL) {
if (sct->verbose != 0) {
if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "answer: %s", response);
}
if (sct->cmd) free(sct->cmd);
sct->cmd = NULL;
if (sct->sent) {
sct->sent = 0;
if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "response> %s", response);
free(sct->debugCommand);
sct->debugCommand = NULL;
goto recycle;
} else if (sct->nextScript) {
sct->result = strdup(response);
}
}
if (sct->debugCommand) {
if (sct->sent) {
if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "state %d", status);
goto quit;
}
sct->sent = 1;
if (sct->verbose != 0) {
if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
SCPrintf(dcon, eWarning, "sent : %s", sct->debugCommand);
}
AsconWrite(sct->ascon, sct->debugCommand, 0);
goto recycle;
}
if (sct->nextScript) {
SctCallNext();
goto recycle;
}
for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
if (sl->type == set_type) {
if (sl->dirty) {
if (sl->beginScript && sl->beginScript->doit) {
sl->beginScript->doit = 0;
SctCallChain(sl->beginScript);
goto recycle;
}
sc = SctChainThis(&sl->chains);
if (sc != NULL) {
SctChainNext(&sl->chains);
SctCallChain(sc);
goto recycle;
}
/* look for pending scripts */
for (sc = SctChainFirst(&sl->chains); sc != NULL; sc = SctChainNext(&sl->chains)) {
if (sc->doit) break;
}
if (sc != NULL) {
SctChainNext(&sl->chains);
if (sl->type == set_type || sc->dynamic) sc->doit = 0;
SctCallChain(sc);
goto recycle; /* there are still pending scripts */
}
sl->dirty = 0;
SctChainFirst(&sl->chains);
if (sl->endScript) {
SctCallChain(sl->endScript);
goto recycle;
}
/* go to next scriptlist */
}
} else {
if (sl->type == timed_type) {
if (!sl->dirty) {
period = floor(DoubleTime() / sl->interval);
if (period != sl->lastPeriod) {
sl->lastPeriod = period;
SctSetListDirty(sl);
}
}
}
if (sl->dirty) {
if (sl->beginScript && sl->beginScript->doit) {
SctCallChain(sl->beginScript);
goto recycle;
}
sc = SctChainThis(&sl->chains);
if (sc != NULL) {
if (SctChainNext(&sl->chains) == NULL || sl->type == manual_type) {
sl->dirty = 0;
}
SctCallChain(sc);
goto recycle;
}
SctChainFirst(&sl->chains);
}
/* go to next scriptlist */
}
}
quit:
if (sct->debugConn) {
SCStorePop(sct->debugConn);
}
sct = NULL;
return 1;
}
static void SctKillChain(SctChain *sc) {
if (sc->command) free(sc->command);
if (sc->dynamic) free(sc->dynamic);
free(sc);
}
static void SctKillSL(SctList *sl) {
if (sl->name) free(sl->name);
if (sl->beginScript) SctKillChain(sl->beginScript);
if (sl->endScript) SctKillChain(sl->endScript);
SctChainDelete(&sl->chains, SctKillChain);
free(sl);
}
static void SctObjectNameKill(SctObjectName *onam) {
RemoveCommand(pServ->pSics, onam->name);
free(onam->name);
free(onam);
}
static void SctKill(Sct *sct) {
SctObjectNameDelete(&sct->names, SctObjectNameKill);
SctListDelete(&sct->scriptLists, SctKillSL);
if (sct->ascon) AsconKill(sct->ascon);
if (sct->name) free(sct->name);
if (sct->cmd) free(sct->cmd);
if (sct->result) free(sct->result);
if (sct->nextScript) free(sct->nextScript);
if (sct->debugCommand) free(sct->debugCommand);
if (sct->debugConn) SCStoreFree(sct->debugConn);
if (sct->desc) DeleteDescriptor(sct->desc);
free(sct);
}
/* kill sct only after SctKillTask _and_ SctKillObj were invoked */
static void SctKillTask(void *object) {
Sct *sct = object;
if (sct->killObj) {
SctKill(sct);
} else {
sct->killTask = 1;
}
}
static void SctKillObj(void *object) {
Sct *sct = object;
if (sct->killTask) {
SctKill(sct);
} else {
sct->killObj = 1;
}
}
int SctAddNode2Script(Sct *sct, SctChain *sc, pHdb node, SConnection *con) {
hdbValue val;
char path[MAX_HDB_PATH];
memset(&val,0,sizeof(hdbValue));
GetHipadabaPar(node, &val, con);
ReleaseHdbValue(&val);
if (!sct->foundData) {
SctGetPath(node, path, sizeof path);
SCPrintf(con, eError, "ERROR: %s has no script context data", path);
return 0;
}
if (sc->scriptList->type == set_type) {
sct->foundData->scriptChain = sc;
}
return 1;
}
static int SctAction(SConnection *con, SicsInterp *sics, void *object, int argc, char *argv[]) {
Sct *sct = object;
SctList *sl, *slItem;
SctChain *sc;
int type = 0, priv = -1;
SctParData *data;
pHdb node, parent;
pHdbCallback cb;
char *fmt;
char *name;
char path[MAX_HDB_PATH];
pSICSOBJ sicsobj;
int i;
ErrMsgList *list;
ErrMsg *msg;
time_t age;
char timetext[8];
double interval;
SctObjectName *objname;
hdbValue val;
typedef enum {
connect_keyword,
object_keyword,
make_keyword,
path_keyword,
addscript_keyword,
addmultiscript_keyword,
addnode_keyword,
dynscript_keyword,
scriptlist_keyword,
beginscript_keyword,
endscript_keyword,
interval_keyword,
debug_keyword,
send_keyword,
error_keyword,
no_keyword
} Keyword;
/* keywords must have the same order as Keyword */
static char *keywords[]={
"connect",
"object",
"make",
"path",
"addscript",
"addmultiscript",
"addnode",
"dynscript",
"scriptlist",
"beginscript",
"endscript",
"interval",
"debug",
"send",
"error",
NULL
};
Keyword keyword;
assert(sct);
if (argc < 2) {
SCPrintf(con, eError, "ERROR: missing %s subcommand", argv[0]);
goto quit;
};
keyword = SctFindKeyword(argv[1], keywords);
sct->operation = keyword;
switch (keyword) {
case object_keyword:
if (argc < 5) {
SCPrintf(con, eError, "ERROR: should be %s object <name> <priv> <type> [<fmt>]", argv[0]);
goto quit;
}
sicsobj = MakeSICSOBJ(argv[2], "SctSicsObject");
if (!sicsobj) goto noMemory;
sicsobj->pPrivate = sct;
sct->currentNode = sicsobj->pDes->parNode;
sicsobj->KillPrivate = NULL;
/*
sicsobj->pDes->saveStatus = SctSave;
dynamic?
*/
if (!AddCommand(pServ->pSics, argv[2], SctWrapper, KillSICSOBJ, sicsobj)) {
SCPrintf(con, eError, "%s already exists", argv[2]);
goto quit;
}
objname = calloc(1, sizeof(*objname));
objname->name = strdup(argv[2]);
SctObjectNameAdd(&sct->names, objname);
/* fall through */
case make_keyword:
if (argc < 5) {
SCPrintf(con, eError, "ERROR: should be %s make <par> <priv> <type> [<fmt>]", argv[0]);
goto quit;
}
fmt = NULL;
priv = decodeSICSPriv(argv[3]);
if (strcasecmp(argv[4], "int") == 0) {
type = HIPINT;
} else if (strcasecmp(argv[4], "float") == 0) {
type = HIPFLOAT;
if (argc == 6) {
fmt = argv[5];
} else {
fmt = "%.5g";
}
} else if (strcasecmp(argv[4], "text") == 0) {
type = HIPTEXT;
} else if (strcasecmp(argv[4], "none") == 0) {
type = HIPNONE;
} else {
SCWrite(con,
"ERROR: invalid type requested: none, int, float, text supported", eError);
goto quit;
}
if (keyword == make_keyword) { /* make parameter case */
name = SctFindNode(sct->currentNode, argv[2], &parent, &node);
if (node != NULL) goto nodeExists;
if (name == NULL) goto quit;
if (type != HIPNONE){
val = makeHdbValue(type,0);
node = MakeSICSHdbPar(name, priv, val);
ReleaseHdbValue(&val);
} else {
node = MakeHipadabaNode(name, type, 0);
}
if (node == NULL) goto noMemory;
AddHipadabaChild(parent, node, con);
} else { /* make object case */
name = argv[2];
node = sct->currentNode;
}
data = calloc(1, sizeof(*data));
if (node == NULL || data == NULL) goto noMemory;
data->pending = 0;
data->inprogress = 0;
data->sct = sct;
data->scriptChain = NULL;
data->conCtx = NULL;
data->refCnt = 3; /* insert 3 times */
cloneHdbValue(&node->value, &data->target);
if (fmt) {
SetHdbProperty(node, "fmt", fmt);
}
cb = MakeHipadabaCallback(SctUpdateCallback, data, SctFreeParData, -1, sct);
if (cb == NULL) goto noMemory;
AppendHipadabaCallback(node, HCBUPDATE, cb);
cb = MakeHipadabaCallback(SctSetCallback, data, SctFreeParData, -1, sct);
if (cb == NULL) goto noMemory;
AppendHipadabaCallback(node, HCBSET, cb);
cb = MakeHipadabaCallback(SctReadCallback, data, SctFreeParData, -1, sct);
if (cb == NULL) goto noMemory;
AppendHipadabaCallback(node, HCBREAD, cb);
break;
case dynscript_keyword:
if (argc < 4) {
SCPrintf(con, eError, "ERROR: should be %s %s <list> <name>", argv[0], argv[1]);
goto quit;
}
/* fall through */
case addmultiscript_keyword:
case addscript_keyword:
if (argc < 5) {
SCPrintf(con, eError, "ERROR: should be %s %s <list> <par> <script ...>", argv[0], argv[1]);
goto quit;
}
if (keyword == dynscript_keyword) {
node = NULL;
} else {
SctFindNode(sct->currentNode, argv[3], &parent, &node);
if (node == NULL) {
name = argv[3];
goto nodeNotFound;
}
}
for (sl = SctListFirst(&sct->scriptLists); sl != NULL; sl = SctListNext(&sct->scriptLists)) {
if (strcasecmp(sl->name, argv[2]) == 0) {
if (keyword == dynscript_keyword) {
if (sl->type == set_type) {
SCPrintf(con, eError, "ERROR: dynscripts may not be added to a set type list");
goto quit;
}
node = sct->currentNode;
}
if (argc == 4) { /* take last script */
sc = SctChainThis(&sl->chains);
if (sc == NULL) {
SCPrintf(con, eError, "ERROR: script list is empty");
goto quit;
}
} else {
sc = SctMakeChain(ConcatArgs(argc-4, argv+4));
if (sc == NULL) goto noMemory;
if (node) {
sc->relatedNode = node;
} else {
sc->relatedNode = sct->currentNode;
}
sc->scriptList = sl;
if (keyword == dynscript_keyword) {
sc->dynamic = strdup(argv[3]);
}
SctChainAdd(&sl->chains, sc);
}
sct->foundData = NULL;
if (node && keyword == addscript_keyword) {
if (!SctAddNode2Script(sct, sc, node, con)) goto quit;
}
if (sl->type != set_type) {
sc->doit = 1;
}
/* the current script chain and script list is stored in the position of the Lists,
this is important for the addnode command */
goto success;
}
}
goto missingScriptList;
case addnode_keyword:
if (argc != 3) {
SCPrintf(con, eError, "ERROR: should be %s %s <par>", argv[0], argv[1]);
goto quit;
}
sl = SctListThis(&sct->scriptLists);
if (sl == NULL) {
sc = NULL;
} else {
sc = SctChainThis(&sl->chains);
}
if (sc == NULL) {
SCPrintf(con, eError, "ERROR: no script was specified");
goto quit;
}
SctFindNode(sct->currentNode, argv[2], &parent, &node);
if (node == NULL) {
name = argv[2];
goto nodeNotFound;
}
if (!SctAddNode2Script(sct, sc, node, con)) goto quit;
goto success;
case scriptlist_keyword:
if (argc < 4) {
type == no_type;
} else {
type = SctFindKeyword(argv[2], slTypes);
}
if (type == no_type) {
SCPrintf(con, eError, "ERROR: should be %s scriptList [set|timed|manual] <list>", argv[0]);
goto quit;
}
for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
if (strcasecmp(sl->name, argv[2]) == 0) goto scriptListExists;
}
sl = calloc(1, sizeof(*sl));
if (sl == NULL) goto noMemory;
sl->name = strdup(argv[3]);
sl->type = type;
sl->beginScript = NULL;
sl->endScript = NULL;
sl->lastPeriod = 0.0;
sl->lastScript = NULL;
sl->chains.head = NULL;
sl->interval = 1e-6;
sl->dirty = (type == timed_type);
SctListAdd(&sct->scriptLists, sl);
break;
case interval_keyword:
if (argc < 3) {
SCPrintf(con, eError, "ERROR: should be %s interval <list> [<value>]", argv[0]);
goto quit;
}
for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
if (strcasecmp(sl->name, argv[2]) == 0) break;
}
if (sl == NULL) goto scriptListNotFound;
if (argc > 3) {
interval = atof(argv[3]);
if (interval < 1e-6) {
sl->interval = 1e-6;
interval = 0;
} else {
sl->interval = interval;
}
} else {
interval = sl->interval;
if (interval <= 1.001e-6) {
interval = 0;
}
}
SCPrintf(con, eValue, "%s %s = %.5g (sec)", argv[0], argv[1], sl->interval);
return 1;
case beginscript_keyword:
case endscript_keyword:
if (argc < 4) {
SCPrintf(con, eError, "ERROR: should be %s %s <list> <script>", argv[0], argv[1]);
goto quit;
}
for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
if (strcasecmp(sl->name, argv[2]) == 0) break;
}
if (sl == NULL) goto scriptListNotFound;
sc = SctMakeChain(ConcatArgs(argc-3, argv+3));
sc->relatedNode = sct->currentNode;
sc->scriptList = sl;
if (keyword == beginscript_keyword) {
sl->beginScript = sc;
} else {
sl->endScript = sc;
}
break;
case connect_keyword:
if (argc < 3) {
SCPrintf(con, eError, "ERROR: should be %s connect <protocol> <host:port> ...", argv[0]);
goto quit;
}
if (sct->ascon) AsconKill(sct->ascon);
sct->ascon = AsconMake(con, argc - 2, argv + 2);
if (!sct->ascon) goto quit;
break;
case path_keyword:
if (argc > 3) {
SCPrintf(con, eError, "ERROR: should be %s path [<path>]", argv[0]);
goto quit;
}
if (argc == 3) {
SctFindNode(sct->currentNode, argv[2], &parent, &node);
if (node == NULL) {
name = argv[2];
goto nodeNotFound;
}
}
if (!SctGetPath(sct->currentNode, path, sizeof path)) {
SCWrite(con, "ERROR: node not anchored or path name too long", eError);
goto quit;
}
SCWrite(con, path, eValue);
goto success;
case debug_keyword:
if (argc < 2) {
SCPrintf(con, eError, "ERROR: should be %s debug [0 | <steps>]", argv[0]);
goto quit;
}
if (argc < 3) {
i = 1;
} else {
i = atoi(argv[2]);
}
if (i != 0) {
sct->taskSteps = i;
sct->debugConn = SCSave(con, sct->debugConn);
sct->verbose = 1;
while (sct->taskSteps > 0) {
SctTask(sct);
}
return 1;
} else {
sct->taskSteps = -1;
sct->verbose = 0;
}
break;
case error_keyword:
list = AsconGetErrList(sct->ascon);
for (msg = ErrMsgFirst(list); msg != NULL; msg = msg->next) {
age = time(NULL) - msg->last;
if (age < 3600) {
snprintf(timetext, sizeof timetext, "%2ldm%2.2lds", age/60, age % 60);
} else if (age < 99*3600) {
age = age / 60;
snprintf(timetext, sizeof timetext, "%2ldh%2.2ldm", age/60, age % 60);
} else {
snprintf(timetext, sizeof timetext, "%5ldh", age/(24*3600));
}
if (msg->data) {
SCPrintf(con, eError, "--- %s ago, cnt %5d %s", timetext, msg->cnt, msg->data);
} else {
SCPrintf(con, eError, "--- %s ago, cnt %5d", timetext, msg->cnt, msg->data);
}
SCWrite(con, msg->text, eError);
}
return 1;
case send_keyword:
if (argc < 3) {
SCPrintf(con, eError, "ERROR: should be %s send <command>", argv[0]);
goto quit;
}
if (sct->debugCommand != NULL) {
SCPrintf(con, eError, "ERROR: busy");
goto quit;
}
sct->sent = 0;
sct->debugConn = SCSave(con, sct->debugConn);
sct->debugCommand = ConcatArgs(argc - 2, argv + 2);
goto success;
case no_keyword:
SCPrintf(con, eError, "ERROR: %s %s: unknown keyword", argv[0], argv[1]);
goto quit;
default:
SCPrintf(con, eError, "ERROR: %s %s: untreated keyword", argv[0], argv[1]);
goto quit;
}
SCSendOK(con);
success:
sct->operation = sct_no_keyword;
return 1;
noMemory:
SCWrite(con, "ERROR: no memory", eError);
goto quit;
missingScriptList:
SCPrintf(con, eError, "ERROR: script list %s not found", argv[2]);
goto quit;
scriptListExists:
SCWrite(con, "ERROR: script list exists", eError);
goto quit;
nodeExists:
SCPrintf(con, eError, "ERROR: node %s exists", argv[2]);
goto quit;
nodeNotFound:
SCPrintf(con, eError, "ERROR: node %s not found", name);
goto quit;
scriptListNotFound:
SCPrintf(con, eError, "ERROR: script list %s not found", argv[2]);
goto quit;
quit:
sct->operation = sct_no_keyword;
return 0;
}
static int SctInit(SConnection *con, int argc, char *argv[], int dynamic) {
/* syntax: makeobject <name> sct */
if (sct) {
SCPrintf(con, eError, "ERROR: script context busy");
return 0;
}
if (argc != 3) {
SCPrintf(con, eError, "ERROR: should be: makeobject <name> sct");
return 0;
}
sct = calloc(1,sizeof(*sct));
assert(sct);
sct->desc = CreateDescriptor("sct");
assert(sct->desc);
sct->scriptLists.head = NULL;
sct->cmd = NULL;
sct->result = NULL;
sct->nextScript = NULL;
sct->runningChain = NULL;
sct->debugConn = NULL;
sct->debugCommand = NULL;
sct->verbose = 0;
sct->taskSteps = -1;
sct->name = strdup(argv[1]);
if (!AddCommand(pServ->pSics, argv[1], SctAction, SctKillObj, sct)) {
SCPrintf(con, eError, "%s already exists", argv[1]);
SctKill(sct);
goto quit;
}
TaskRegister(pServ->pTasker, SctTask, NULL, SctKillTask, sct, 0);
sct->killObj = 0;
sct->killTask = 0;
sct = NULL;
return 1;
quit:
sct = NULL;
return 0;
}
/** \brief the startup routine */
void SctStartup(void) {
MakeDriver("sct", SctInit, 0, "Script Context Driver");
AddCmd("sct", SctExec);
}
Reference in New Issue View Git Blame Copy Permalink