executer_result
_executer_send_delta (executer_job_t * job)
{
// The opaque pointer is to signature
rs_signature_t *signature = job->signature;
rs_job_t *deltajob;
char *realpath;
executer_rs inrs;
executer_rs outrs;
rs_result result;
rs_buffers_t rsbuf;
utils_debug ("Sending delta data");
deltajob = rs_delta_begin (signature);
_executer_real_path (job->file, &realpath);
int file2 = open (realpath, O_RDONLY);
inrs.type = _EXECUTER_FILE;
inrs.sock = file2;
inrs.size = RS_DEFAULT_BLOCK_LEN;
inrs.buf = malloc (inrs.size);
outrs.type = _EXECUTER_SOCKET;
outrs.sock = job->peer_sock;
outrs.size = _EXECUTER_DEFAULT_OUT;
outrs.buf = malloc (outrs.size);
if (rs_build_hash_table (signature) != RS_DONE)
{
utils_error ("Error building hash table");
return EXECUTER_ERROR;
}
result =
rs_job_drive (deltajob, &rsbuf, _executer_in_callback, &inrs,
_executer_out_callback, &outrs);
// Free the memory
free (realpath);
rs_job_free (deltajob);
free (inrs.buf);
free (outrs.buf);
// Send finish to the socket
if (!_executer_send_finish (job->peer_sock))
{
utils_error ("Error sending finish message: %s", strerror (errno));
return EXECUTER_ERROR;
}
if (result != RS_DONE)
{
utils_error ("Error calculating delta");
return EXECUTER_ERROR;
}
else
{
// Ok, send the stat
job->next_operation = _executer_send_stat;
// Ok, the delta is send, no need more process
return EXECUTER_RUNNING;
}
}
void* scheduler_code(void* data) {
printf("scheduler_thread running\n");
signal(SIGUSR2, cleanup_scheduler);
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGUSR2);
scheduler_data* param = (scheduler_data*) data;
buffer* buf = param->buffer;
sem_t *sem_buffer_empty = param->sem_buffer_empty;
sem_t *sem_buffer_full = param->sem_buffer_full;
pthread_mutex_t *buffer_mutex = param->buffer_mutex;
char debug_str[100];
sprintf(debug_str, "config policy: %d\n", param->policy);
utils_debug(debug_str);
while (true) {
sigprocmask(SIG_UNBLOCK, &set, NULL);
sem_wait(sem_buffer_empty); // only remove if buffer is not empty
sigprocmask(SIG_BLOCK, &set, NULL);
//block_signals();
pthread_mutex_lock(buffer_mutex);
printf("On Scheduler: New Request\n");
buffer_node* node = buf->first->next;
buffer_node* parent = buf->first;
buffer_node* best = NULL;
buffer_node* parentbest = NULL;
if (param->policy == FIFO_POLICY) {
best = node;
parentbest = parent;
} else {
while (node != NULL) {
//printf("on buffer iteration: request type %s\n", node->request->type == STATIC_PAGE ? "STATIC_PAGE" : "DYNAMIC_SCRIPT" );
if ((param->policy == STATIC_POLICY && node->request->type == STATIC_PAGE) ||
(param->policy == DYNAMIC_POLICY && node->request->type == DYNAMIC_SCRIPT)) {
parentbest = parent;
best = node;
break;
} else if(best == NULL) {
parentbest = parent;
best = node;
}
if (node->next != NULL) {
parent = parent->next;
node = node->next;
} else {
break;
}
}
}
printf("On Scheduler: Found request\n");
printf("On Scheduler: request type %s\n", best->request->type == STATIC_PAGE ? "STATIC_PAGE" : "DYNAMIC_SCRIPT" );
printf("On Scheduler: work with name: %s\n\n", best->request->name);
parentbest->next = best->next;
buf->cur_size--;
pthread_mutex_unlock(buffer_mutex);
sem_post(sem_buffer_full);
//sleep(1);
if (best->request->type == DYNAMIC_SCRIPT) {
utils_debug("New dynamic script: ");
printf("%s\n", best->request->name);
int script_allowed = 0;
int u;
for (u = 0; u < param->n_scripts; u++) {
if (!strcmp(param->scripts[u], best->request->name)) {
script_allowed = 1;
}
}
if (!script_allowed) {
printf("%s\n", best->request->name);
utils_debug("This script is not allowed.\n");
// TODO Michel este script nao pode ser corrido, que se faz
char error[] = "Script not allowed.<br>";
http_send_header(best->request->socket, "text/html");
send(best->request->socket, error, strlen(error), 0);
close(best->request->socket);
continue;
}
}
int i;
for (i = 0; i < param->n_threads; i++) {
pthread_mutex_lock(¶m->thread_locks[i]);
if (param->thread_ready[i] == 1) {
param->requests[i] = best->request;
param->thread_ready[i] = 0;
pthread_mutex_unlock(¶m->thread_locks[i]);
pthread_cond_broadcast(&(param->wait_for_work[i]));
break;
}
pthread_mutex_unlock(¶m->thread_locks[i]);
}
if (i >= param->n_threads) {
printf("No worker available.\n"); // This might happen if the workers are slow, because when the request is delivered to a worker we remove the request from the buffer, leaving space for more requests, but no thread available.
char error[] = "<!DOCTYPE html>\n <head></head>\n <body> <h2>Server error. No processing units available. </h2> </body>\n\n";
send(best->request->socket, error, strlen(error), 0);
close(best->request->socket);
} else {
printf("Delivered work to worker %d\n\n", i);
}
}
}
executer_result
_executer_receive_file (executer_job_t * job)
{
FILE *file;
char *temppath;
int operation;
bool protocol_error = false;
int tempfile;
utils_debug ("Receiving file data");
tempfile = _executer_create_temp (job->realpath, &temppath);
if (tempfile == 0)
{
utils_error ("Error creating temp file for file '%s': %s",
job->realpath, strerror (errno));
return EXECUTER_ERROR;
}
job->tempfile = temppath;
// Receive a whole file
file = fopen (job->tempfile, "w");
if (file == 0)
{
utils_error ("Error creating file '%s': %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
do
{
//Read the operation
size_t leido;
size_t size;
char *buf;
leido =
_executer_read_buffer (job->peer_sock, &operation,
sizeof (operation));
if (leido != sizeof (operation))
{
protocol_error = true;
break;
}
if (operation == _EXECUTER_PART)
{
int ret;
leido =
_executer_read_buffer (job->peer_sock, &size, sizeof (size));
if (leido != sizeof (size))
{
utils_error
("Error receiving next size of block, espected bytes: %i bytes received: %i",
sizeof (size), leido);
protocol_error = true;
break;
}
buf = malloc (size);
leido = _executer_read_buffer (job->peer_sock, buf, size);
if (leido != size)
{
utils_error
("Error receiving file data: bytes expected: %i bytes received: %i",
size, leido);
protocol_error = true;
break;
}
ret = fwrite (buf, 1, size, file);
free (buf);
if (ret != size)
{
utils_error ("Error writing file: %s", strerror (errno));
protocol_error = true;
break;
}
}
}
while (operation == _EXECUTER_PART);
fclose (file);
if (protocol_error)
{
utils_error ("Error receiving whole file, canceling job");
return EXECUTER_ERROR;
}
job->next_operation = _executer_receive_stat;
return EXECUTER_RUNNING;
}
executer_result
_executer_recive_delta (executer_job_t * job)
{
char *temppath;
rs_buffers_t rsbuf;
executer_rs inrs;
executer_rs outrs;
int result;
utils_debug ("Receving delta.");
int tempfile = _executer_create_temp (job->realpath, &temppath);
if (tempfile == 0)
{
utils_error ("Error creating temp file for file '%s': %s",
job->realpath, strerror (errno));
return EXECUTER_ERROR;
}
FILE *origfile = fopen (job->realpath, "rb");
if (origfile == NULL)
{
utils_error ("Error opening file '%s': %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
rs_job_t *patchjob = rs_patch_begin (rs_file_copy_cb, origfile);
inrs.sock = job->peer_sock;
inrs.type = _EXECUTER_SOCKET;
inrs.size = _EXECUTER_DEFAULT_OUT;
inrs.buf = malloc (inrs.size);
outrs.sock = tempfile;
outrs.type = _EXECUTER_FILE;
outrs.size = RS_DEFAULT_BLOCK_LEN;
outrs.buf = malloc (outrs.size);
rsbuf.avail_in = 0;
rsbuf.avail_out = 0;
rsbuf.next_in = 0;
rsbuf.next_out = 0;
rsbuf.eof_in = false;
result =
rs_job_drive (patchjob, &rsbuf, _executer_in_callback, &inrs,
_executer_out_callback, &outrs);
if (result != RS_DONE)
{
utils_error ("Error patching file");
return EXECUTER_ERROR;
}
//Check if there are any data
if (rsbuf.avail_out > 0)
{
_executer_in_callback (patchjob, &rsbuf, &inrs);
_executer_out_callback (patchjob, &rsbuf, &outrs);
}
rs_job_free (patchjob);
close (tempfile);
fclose (origfile);
free (outrs.buf);
free (inrs.buf);
job->next_operation = _executer_receive_stat;
job->tempfile = temppath;
return EXECUTER_RUNNING;
}
/*
Load data from storage to UI
*/
void __fastcall TframTag::UpdateView()
{
//TODO: Add your source code here
TComponent * comp;
int i;
PTAG_NAME name = &m_TagName;
// update static information
PRTK_TAG pTag = &m_Tag;
char textname[TAGNAME_TEXT_LENGTH + 1];
char buf[64];
// temporarily disable unapplicable components
tsException->TabVisible = false;
btnWriteDevice->Enabled = (pTag->d.Value.Flags & TF_ReadOnly)? false : true;
// now we update the UI to reflect the tag configuration
/*
0 开关量
1 模拟量
2 高精度模拟量
3 8位整数
4 16位整数
5 32位整数
6 64位整数
7 无符号8位整数
8 无符号16位整数
9 无符号32位整数
10 无符号64位整数
11 日期
*/
cmbType->OnChange = NULL;
switch(get_value_type(pTag->s.Flags)){
case dt_bool:
cmbType->ItemIndex = 0;
break;
case dt_real4:
cmbType->ItemIndex = 1;
break;
case dt_real8:
cmbType->ItemIndex = 2;
break;
case dt_int8:
cmbType->ItemIndex = 3;
break;
case dt_int16:
cmbType->ItemIndex = 4;
break;
case dt_int32:
cmbType->ItemIndex = 5;
break;
case dt_int64:
cmbType->ItemIndex = 6;
break;
case dt_uint8:
cmbType->ItemIndex = 7;
break;
case dt_uint16:
cmbType->ItemIndex = 8;
break;
case dt_uint32:
cmbType->ItemIndex = 9;
break;
case dt_uint64:
cmbType->ItemIndex = 10;
break;
case dt_date:
cmbType->ItemIndex = 11;
break;
default:
cmbType->ItemIndex = 12;
break;
}
cmbType->OnChange = cmbTypeChange;
{
cmbDevice->Ctl3D = false;
CDeviceItems * ditems;
AnsiString Url;
Url = (char*)CNodeName(name->node);
Url += ".DEVICES";
ditems = dynamic_cast<CDeviceItems*>(g_DCS.Search(Url));
if(ditems){
if(!ditems->m_iRefreshCount){
ditems->Refresh();
}
}
cmbDevice->Items->Clear();
cmbDevice->Text = "";
if(ditems){
CDeviceItem * ditem;
ditem = dynamic_cast<CDeviceItem*>(ditems->GetFirstChild());
while(ditem){
cmbDevice->Items->Add((char*)CDeviceName(ditem->info.k));
ditem = dynamic_cast<CDeviceItem*>(ditems->GetNextChild(ditem));
}
}
}
{
PRTK_GROUP pgrp;
RTK_CURSOR hgrp;
hgrp = open_group_f(&name->node, &name->sname.group);
pgrp = (PRTK_GROUP)cursor_get_item(hgrp);
if(pgrp){
if(pgrp->period > 50){
tmrUpdater->Interval = pgrp->period;
}
}
close_handle(hgrp);
}
edtTagName->Text = (char *)CTagName(name->sname.tag);
edtCName->Text = pTag->s.Description;
edtAddr->Text = pTag->s.Address;
cmbDevice->Text = (char*)CDeviceName(pTag->s.Device);
#define cc(name) \
do{ if(pTag->s.Flags & TF_##name){\
chk##name->Checked = true;\
}else{\
chk##name->Checked = false;\
}\
}while(0)
cc(HiHi);
cc(Lo);
cc(Hi);
cc(LoLo);
cc(On2Off);
cc(Off2On);
cc(Rate);
cc(SaveToHistory);
cc(Step);
/*
// cutoff is obsolete
#define dd(name) chk##name->Checked = pTag->s.CutOffMask & TF_##name ? true : false;
dd(HiHi);
dd(Lo);
dd(Hi);
dd(LoLo);
dd(On2Off);
dd(Off2On);
*/
if(pTag->s.Flags & TF_System){
cmbDevice->Enabled = false;
edtAddr->ReadOnly = true;
cmbType->Enabled = false;
cmbDevice->Color = clScrollBar;
edtAddr->Color = clScrollBar;
cmbType->Color = clScrollBar;
}else{
cmbDevice->Enabled = true;
edtAddr->ReadOnly = false;
cmbType->Enabled = true;
cmbType->Color = clWindow;
cmbDevice->Color = clWindow;
edtAddr->Color = clWindow;
}
switch(get_value_type(pTag->s.Flags)){
case dt_real4:
case dt_real8:
case dt_int64:
case dt_uint64:
#define aa(f) sprintf(buf, "%g", pTag->s.flt##f);edt##f->Text = buf;
aa(HiHi);
aa(Hi);
aa(Lo);
aa(LoLo);
aa(AlarmDeadband);
aa(MaxValue);
aa(MinValue);
aa(Rate);
edtEU->Text = pTag->s.AnalogMsg.EU;
tsAnalog->TabVisible = true;
tsLogical->TabVisible = false;
break;
case dt_int8:
case dt_int16:
case dt_int32:
case dt_uint8:
case dt_uint16:
case dt_uint32:
aa(AlarmDeadband);
aa(Rate);
#undef aa
#define aa(v, name) \
sprintf(buf, "%d", pTag->s.v);\
edt##name->Text = buf;
aa(u_hihi.i, HiHi);
aa(u_hi.i, Hi);
aa(u_lo.i, Lo);
aa(u_lolo.i, LoLo);
aa(u_max.i, MaxValue);
aa(u_min.i, MinValue);
edtEU->Text = pTag->s.AnalogMsg.EU;
tsAnalog->TabVisible = true;
tsLogical->TabVisible = false;
break;
case dt_date:
tsArchive->TabVisible = true;
tsAnalog->TabVisible = false;
tsLogical->TabVisible = false;
break;
case dt_bool:
edtOnMessage->Text = pTag->s.SwitchMsg.OnMsg;
edtOffMessage->Text = pTag->s.SwitchMsg.OffMsg;
tsLogical->TabVisible = true;
tsAnalog->TabVisible = false;
default:
assert(0);
break;
}
tsAnalog->Visible = tsAnalog->TabVisible;
tsLogical->Visible = tsLogical->TabVisible;
tsException->Visible = tsException->TabVisible;
tsArchive->Visible = tsArchive->TabVisible;
edtAlarmRank->Text = pTag->s.AlarmRank;
edtAlarmRank2->Text = pTag->s.AlarmRank;
chkCompressing->Checked = true;
edtCompMax->Enabled = chkCompressing->Checked;
edtCompDev->Enabled = chkCompressing->Checked;
edtCompDevPercent->Enabled = chkCompressing->Checked;
edtCompMax->Text = IntToStr(pTag->s.CompMax);
edtCompDev->Text = FloatToStr(pTag->s.CompDev);
__r8 span = _getSpan(pTag);
if(span > 1e-5){
edtCompDevPercent->Text = FloatToStr(pTag->s.CompDev / span * 100);
}
TAG_NAME ctn;
ZeroMemory(&ctn, sizeof(ctn));
ctn.sname = pTag->s.CutOffTagName;
tagname_to_text(&ctn, textname, sizeof(textname));
// debugging output
{
char nn[128];
*nn=0;
#define __check_field__(field,name) \
if(pTag->d.Value.Flags & TF_##field) {\
if(*nn) {\
strcat(nn,"+");\
strcat(nn,#name);\
}else{\
strcpy(nn,#name);\
}\
}
__check_field__(HiHi,h2)
__check_field__(Hi,h)
__check_field__(LoLo,l2)
__check_field__(Lo,l)
__check_field__(Rate,r)
__check_field__(On2Off,off)
__check_field__(Off2On,on)
__check_field__(Alarm,alarm)
__check_field__(Expired,expired)
__check_field__(SharpChange,sharp)
__check_field__(ReadOnly,read)
__check_field__(Translated,trans)
__check_field__(ConfigOk,ok)
__check_field__(Valid,valid)
utils_debug("%s flags=0x%08x,%s\n", textname, pTag->d.Value.Flags, nn);
#undef __check_field__
}
// pg->Clear();
}
void CPacketMan::request_packets(RECEIVE_ITEM * h)
{
char packet_buffer[MAX_PACKET_SIZE];
PRTK_PACKET packet;
__u16 *rsids;
__uint items;
int j, i;
packet = (PRTK_PACKET)packet_buffer;
ZeroMemory(packet, sizeof(RTK_PACKET));
items = h->unreceived_fragments;
if(items > 10){
items = 10;
}
packet->version = RTK_VERSION;
packet->src.host= g_ThisNode->key;
packet->dest = h->header->src;
packet->guid.create();
packet->total_frag = 1;
packet->data_size = sizeof(__u32)*items
+ sizeof(RTK_GUID);
/*
packet->packet_size = packet->data_size + sizeof(*packet) -
sizeof(packet->data);
*/
packet->packet_type = PT_RequestFragment;
*((PRTK_GUID)packet->data) = h->header->guid;
rsids = (__u16*)(packet->data + sizeof(RTK_GUID));
#ifdef RESEND_DEBUG
char dbg_msg[1024], *dbg_p;
dbg_msg[0] = 0;
dbg_p = dbg_msg;
dbg_p += sprintf(
dbg_p, "_P: Need %d of %d, grp %d, SOURCE=%s:%d, type=%08x",
items,
h->header->total_frag,
h->header->grp_id,
(char *)CHostName(h->header->src.host),
h->header->src.port,
h->header->packet_type
);
#endif
*rsids = h->header->grp_id;
rsids++;
j = 0;
for(i=0; i<h->header->total_frag; i++){
if(!h->bitmap[i]){
*rsids = i;
#ifdef RESEND_DEBUG
dbg_p += sprintf(dbg_p, "%d ", *rsids);
#endif
j++;
assert(j<=h->unreceived_fragments);
if(j >= items){
break;
}
rsids++;
}
}
if(h->unreceived_fragments <= 10){
assert(j == h->unreceived_fragments);
}
#ifdef RESEND_DEBUG
utils_debug("%s\n", dbg_msg);
#endif
SendPacket(packet);
}
LIBUTILS_API char * UTILS_API
get_file_versionA(const char * szFile, LARGE_INTEGER * liVersion)
{
char * pVersion=0;
DWORD dwVersionSize, dwHnd;
LARGE_INTEGER _liVersion;
WORD * s;
VS_FIXEDFILEINFO * pBlock;
UINT dwBytes;
if(!liVersion){
liVersion=&_liVersion;
}
memset(liVersion,0,sizeof(LARGE_INTEGER));
while(TRUE){
dwHnd = 0;
dwVersionSize=GetFileVersionInfoSize((char *)szFile, &dwHnd);
if(!dwVersionSize){
return g_szVersion;
}
pVersion=(char *)malloc(dwVersionSize*4); // *4: for some bugs
if(!pVersion){
break;
}
my_heapchk();
if( !GetFileVersionInfo((char*)szFile, dwHnd, dwVersionSize, pVersion) ){
break;
};
my_heapchk();
// Structure used to store enumerated languages and code pages.
pBlock=0;
dwBytes = sizeof(pBlock);
// Retrieve file description for language and code page "i".
VerQueryValue(pVersion,"\\",(void**)&pBlock,&dwBytes);
my_heapchk();
if(pBlock){
#if 1
liVersion->HighPart=pBlock->dwFileVersionMS;
liVersion->LowPart=pBlock->dwFileVersionLS;
#else
liVersion->HighPart=pBlock->dwProductVersionMS;
liVersion->LowPart=pBlock->dwProductVersionLS;
#endif
}
break;
};
#ifdef __profile__
time_mark(&t2);
utils_debug("get_file_version costs %.3f ms.\n", time_diff(&t2,&t1)*1000);
#endif
s = (WORD*)liVersion;
sprintf(g_szVersion, "%d.%d.%d.%d",s[3],s[2],s[1],s[0]);
my_heapchk();
if(pVersion){
free(pVersion);
}
return g_szVersion;
}
