RTDB_API RTK_CURSOR PMC_API open_tag(
RTK_CURSOR node,
PCSHORT_TAG_NAME tag
)
{
RTK_CURSOR hGroup;
RTK_CURSOR hTag;
hGroup = open_group(node, &tag->group);
hTag = open_tag_g(hGroup, &tag->tag);
close_handle(hGroup);
return hTag;
}
RTDB_API PRTK_TAG PMC_API query_tag_g(
RTK_CURSOR group,
PCTAG_KEY tag
)
{
assert(is_hgroup(group));
RTK_CURSOR hTag;
hTag = open_tag_g(group, tag);
RTK_TAG * pTag = (RTK_TAG *)cursor_get_item(hTag);
close_handle(hTag);
return pTag;
}
RTDB_API RTK_CURSOR PMC_API create_tag(
RTK_CURSOR group,
PCTAG_KEY tag,
PCSTATIC_TAG_DATA sd
)
{
RTK_CURSOR handle;
RTK_GROUP * grp;
RTK_TAG t;
handle = open_tag_g(group, tag);
if(handle){
return handle;
}
if(g_dwTags >= g_dwMaxTags){
rtk_set_last_error(RTDB_HARD_CONSTRAINTS);
return 0;
}
grp = (RTK_GROUP*)cursor_get_item(group);
if(!grp){
return 0;
}
ZeroMemory(&t, sizeof(t));
t.key = *tag;
make_unified_key(t.key);
t.s = *sd;
t.node = grp->node;
t.group = grp->key;
handle = (RTK_CURSOR)_HTAG::create((TAG_TABLE*)grp->itemtable, t.key, t);
RTK_TAG * pTag = (RTK_TAG*)cursor_get_item(handle);
if(pTag){
ZeroMemory(&pTag->d, sizeof(pTag->d));
set_value_type(pTag->d.Value.Flags, get_value_type(pTag->s.Flags));
RtkInitializeListHead(&pTag->d.DeviceLink);
RtkInitializeListHead(&pTag->d.RefreshLink);
FIRE_EVENT(OnAddTag, (pTag));
g_dwTags++;
}
return handle;
}
__uint _on_queried_data(PCRTK_PACKET p)
{
RTK_CURSOR hNode, hTag, hGroup;
RTK_TAG *pTag;
TAG_NAME name;
TAG_NAME missing[MAX_MISSING_PERMITED];
__uint nMissing;
QUERY_DATA_ENTRY *t;
__uint tagcount, retcount, i;
t = (QUERY_DATA_ENTRY *)p->data;
tagcount = p->data_size / sizeof(*t);
if(p->data_size % sizeof(QUERY_DATA_ENTRY)){
return 0;
}
retcount = 0;
if(!lock_rtdb(__false, 100)){
return 0;
}
memset(&name, 0, sizeof(name));
host_to_node(&p->src.host, &name.node);
hNode = open_node(&name.node);
hTag = hGroup = 0;
if(!hNode){
unlock_rtdb();
if(g_Worker){
g_Worker->inform_load(&name, 1);
}
return 0;
}
nMissing = 0;
for(i=0; i<tagcount; i++){
hGroup = open_group(hNode, &t[i].name.group);
if(hGroup){
hTag = open_tag_g(hGroup, &t[i].name.tag);
if(hTag){
pTag = (RTK_TAG*)cursor_get_item(hTag);
pTag->d.Value = t[i].value;
mark_fresh(pTag);
close_handle(hTag);
retcount++;
}else{
if(g_Worker){
name.sname = t[i].name;
missing[nMissing] = name;
nMissing++;
}
}
close_handle(hGroup);
}else{
if(g_Worker){
missing[nMissing].node = name.node;
missing[nMissing].sname.group = t[i].name.group;
memset(&missing[nMissing].sname.tag, 0, sizeof(TAG_KEY));
nMissing++;
}
}
}
close_handle(hNode);
unlock_rtdb();
if(g_Worker && nMissing){
g_Worker->inform_load(missing, nMissing);
}
return retcount;
}
PROXY_API __uint PMC_API update_changed_data(
PCRTK_PACKET packet,
__bool bThisIsAServer
)
{
CHANGED_DATA_ENTRY * t;
CHANGED_DATA * cd;
__uint i, nMissing;
RTK_CURSOR hNode, hGroup, hTag;
TAG_NAME name;
PRTK_TAG pTag;
__uint retcount = 0;
TAG_NAME missing[MAX_MISSING_PERMITED];
if(packet->data_size <= sizeof(CHANGED_DATA)){
return 0;
}
cd = (CHANGED_DATA*)packet->data;
t = (CHANGED_DATA_ENTRY*)&cd[1];
if(packet->data_size != cd->count * sizeof(CHANGED_DATA_ENTRY)
+ sizeof(CHANGED_DATA)
){
return 0;
}
#if 0
for(i=0; i<cd->count; i++){
utils_debug("%s.%s.%s=%f\n",
(char*)CHostName(packet->src.host),
(char*)CGroupName(cd->group),
(char*)CTagName(t[i].name),
t[i].value.Value.fltValue
);
}
#endif
memset(&name, 0, sizeof(name));
host_to_node(&packet->src.host, &name.node);
name.sname.group = cd->group;
if(!lock_rtdb(__false, 100)){
return 0;
}
if(bThisIsAServer){
if(!(packet->src.host == g_ThisNode->key)){
unlock_rtdb();
return 0;
}
hNode = HNODE_LOCAL_MACHINE;
}else{
hNode = open_node(&name.node);
}
if(!hNode){
unlock_rtdb();
return 0;
}
hGroup = open_group(hNode, &cd->group);
if(!hGroup){
if(!bThisIsAServer){
close_handle(hNode);
}
unlock_rtdb();
if(g_Worker){
g_Worker->inform_load(&name, 1);
}
// 2003/5/27, in current implementation all following
// tags are guaranteed to be in the same group, so there
// is no need to proceed.
return 0;
}
nMissing = 0;
for(i=0; i<cd->count; i++){
hTag = open_tag_g(hGroup, &t[i].name);
if(hTag){
pTag = (PRTK_TAG)cursor_get_item(hTag);
pTag->d.Value = t[i].value;
// pTag->d.Value.Flags = t[i].value.Flags;
mark_fresh(pTag);
close_handle(hTag);
retcount++;
}else{
if(g_Worker && nMissing < MAX_MISSING_PERMITED){
name.sname.tag = t[i].name;
missing[nMissing] = name;
nMissing++;
}
}
}
close_handle(hGroup);
if(!bThisIsAServer){
close_handle(hNode);
}
unlock_rtdb();
if(nMissing && g_Worker){
if(nMissing > 16){
memset(&missing[0].sname.tag, 0, sizeof(TAG_KEY));
g_Worker->inform_load(missing, 1);
}else{
g_Worker->inform_load(missing, nMissing);
}
}
return retcount;
}
