pwr_tTime wb_orep::modTime() { pwr_tTime t = ohTime(); pwr_tTime rbt = rbTime(); pwr_tTime dbt = dbTime(); if ( time_Acomp( &rbt, &t) == 1) t = rbt; if ( time_Acomp( &dbt, &rbt) == 1) t = dbt; return t; }
/** * Adds a remote class volume. */ void cvolcm_AddClassVolume( pwr_tStatus* sts, gdb_sNode* np, const net_sGvolume* vp) { gdb_sCclassVolume *ccvp, *rp; gdb_sVolume* cvp; gdb_AssumeLocked; pwr_Assert(vp != NULL); ccvp = pool_Alloc(sts, gdbroot->pool, sizeof(*ccvp)); if (ccvp == NULL) return; ccvp->key.nid = vp->nid; ccvp->key.vid = vp->vid; ccvp->time = net_NetTimeToTime(&vp->time); cvp = hash_Search(sts, gdbroot->vid_ht, &vp->vid); if (cvp == NULL) /* This volume doesn't exist locally, but we may create it later on */ ccvp->equalClasses = 0; else { pwr_tTime t = net_NetTimeToTime(&cvp->g.time); ccvp->equalClasses = time_Acomp(&ccvp->time, &t) == 0 ? 1 : 0; } rp = hash_Insert(sts, gdbroot->ccvol_ht, ccvp); if (rp == NULL) { /* This was previously a bugcheck but obviously can occur */ pool_Free(NULL, gdbroot->pool, ccvp); return; } pool_QinsertPred(NULL, gdbroot->pool, &ccvp->ccvol_ll, &np->ccvol_lh); }
int compTime(sKey d1, sKey d2) { if(time_Acomp( &(d1.EventTime), &(d2.EventTime)) < 0 ) { return 1; } return 0; }
static void time_PeriodSec( pwr_tTime *from, pwr_tTime *to, pwr_tTime *center, int sec) { pwr_tStatus sts; pwr_tTime current; sts = time_GetTime( ¤t); to->tv_sec = center->tv_sec + sec/2; to->tv_nsec = center->tv_nsec; if ( time_Acomp( to, ¤t) == 1) *to = current; from->tv_sec = to->tv_sec - sec; from->tv_nsec = to->tv_nsec; }
void subcm_CheckTimeout () { pool_sQlink *cl; sub_sClient *cp; pwr_tTime curtim; pwr_tTime restim; pwr_tDeltaTime tmotim; pwr_tInt32 n; pwr_tInt32 i; gdb_AssumeLocked; gdbroot->db->tmocnt++; /* Statistics */ time_GetTime( &curtim); /* Calculate # of remote object clients to process this time */ n = gdbroot->db->subt_lc; if (n == 0) n = MIN(1, gdbroot->db->subt_lc); for (i=0; i<n; i++) { /* Temporarily remove the first entry from the queue for processing. */ cl = pool_QremoveSucc(NULL, gdbroot->pool, &gdbroot->db->subt_lh); cp = pool_Qitem(cl, sub_sClient, subt_ll); /* Find out if the client has timed out */ if (!cp->old) { /* cp->tmo in 10ths of seconds */ tmotim.tv_sec = cp->tmo / 10; tmotim.tv_nsec = (cp->tmo - tmotim.tv_sec * 10) * 100000000; time_Aadd(&restim, &cp->lastupdate, &tmotim); /* curtim >= tmotim + lastupdate */ if (time_Acomp(&curtim, &restim) >= 0) subc_SetOld(cp); } /* If it was old already */ /* Reinsert the entry last in the queue. */ pool_QinsertPred(NULL, gdbroot->pool, cl, &gdbroot->db->subt_lh); } }
pwr_tTime wb_orep::treeModTime() { pwr_tStatus sts; pwr_tTime t = modTime(); pwr_tTime tchild; wb_orep *after; for ( wb_orep *child = first( &sts); ODD(sts); child = after) { child->ref(); tchild = child->treeModTime(); if ( time_Acomp( &tchild, &t) == 1) t = tchild; after = child->after( &sts); child->unref(); } return t; }
static void scan_nodes () { LstLink(sNode) *nl; pwr_tStatus sts; pwr_tBoolean Old; pwr_tTime LastUpdate, Timeout, CurrentTime; pwr_tDeltaTime Delta; pwr_tBoolean LinkUp; time_GetTime(&CurrentTime); for (nl = LstFir(&node_l); nl != LstEnd(&node_l); nl = LstNex(nl)) { sNode *np = LstObj(nl); pwr_sClass_NodeLinkSup *o = np->o; LinkUp = 0; sts = gdh_GetSubscriptionOldness (o->SubId, &Old, &LastUpdate, NULL); if (ODD(sts)) { /* IF (CurrentTime < LastUpdate + TimeoutTime) THEN LinkUp */ Delta.tv_sec = o->TimeoutTime; Delta.tv_nsec = 0; time_Aadd(&Timeout, &LastUpdate, &Delta); if (time_Acomp(&CurrentTime, &Timeout) < 0) LinkUp = 1; o->SystemStatus = *np->subvalue; } if (o->LinkUp && !LinkUp) { o->LinkUp = 0; o->DownTime = CurrentTime; o->SystemStatus = PWR__NETTIMEOUT; } else if (!o->LinkUp && LinkUp) { o->LinkUp = 1; o->UpTime = CurrentTime; o->UpCount++; } detect(o, 1, np); } }
/** * Adds a remote class volume. */ void cvolcm_AddClassVolume( pwr_tStatus *sts, gdb_sNode *np, const net_sGvolume *vp ) { gdb_sCclassVolume *ccvp; gdb_sVolume *cvp; gdb_AssumeLocked; pwr_Assert(vp != NULL); ccvp = pool_Alloc(sts, gdbroot->pool, sizeof(*ccvp)); if (ccvp == NULL) return; ccvp->key.nid = vp->nid; ccvp->key.vid = vp->vid; ccvp->time = net_NetTimeToTime(&vp->time); cvp = hash_Search(sts, gdbroot->vid_ht, &vp->vid); if (cvp == NULL) /* This volume doesn't exist locally, but we may create it later on */ ccvp->equalClasses = 0; else { pwr_tTime t = net_NetTimeToTime( &cvp->g.time); ccvp->equalClasses = time_Acomp(&ccvp->time, &t) == 0 ? 1 : 0; } ccvp = hash_Insert(sts, gdbroot->ccvol_ht, ccvp); if (ccvp == NULL) errh_Bugcheck(GDH__WEIRD, "adding cached class volume"); pool_QinsertPred(NULL, gdbroot->pool, &ccvp->ccvol_ll, &np->ccvol_lh); }
void wb_build::webgraph( pwr_tOid oid) { pwr_tFileName dest_fname; pwr_tFileName src_fname; pwr_tCmd cmd; pwr_tString80 java_name; pwr_tString80 name; pwr_tTime dest_time, src_time; int check_hierarchy = cdh_ObjidIsNotNull( m_hierarchy); int hierarchy_found = 0; int is_frame, is_applet; char jname[80]; pwr_tStatus fsts; int jexport; int found; pwr_tFileName found_file, file_spec; pwr_tFileName graph_name, dir; char dev[80], type[80]; int version; pwr_tString80 appletsignature = ""; char *s; wb_object o = m_session.object(oid); if ( !o) { m_sts = o.sts(); return; } // Check that no ancestor is a LibHier for ( wb_object p = o.parent(); p.oddSts(); p = p.parent()) { if ( p.cid() == pwr_eClass_LibHier) { m_sts = PWRB__INLIBHIER; return; } if ( check_hierarchy && cdh_ObjidIsEqual( m_hierarchy, p.oid())) hierarchy_found = 1; } if ( check_hierarchy && !hierarchy_found) { m_sts = PWRB__NOBUILT; return; } wb_attribute a = m_session.attribute( oid, "RtBody", "Name"); if ( !a) { m_sts = a.sts(); return; } a.value( java_name); if ( !a) { m_sts = a.sts(); return; } if ( isupper(java_name[0])) { cdh_ToLower( java_name, java_name); java_name[0] = toupper(java_name[0]); // Get the .pwg file for this javaname strcpy( graph_name, cdh_Low(java_name)); sprintf( name, "$pwrp_pop/%s.pwg", graph_name); dcli_translate_filename( name, name); m_sts = dcli_file_time( name, &src_time); if ( evenSts()) { // Search in all pwg files found = 0; strcpy( file_spec, "$pwrp_pop/*.pwg"); for ( fsts = dcli_search_file( file_spec, found_file, DCLI_DIR_SEARCH_INIT); ODD(fsts); fsts = dcli_search_file( file_spec, found_file, DCLI_DIR_SEARCH_NEXT)) { fsts = grow_IsJava( found_file, &is_frame, &is_applet, jname); if ( EVEN(fsts)) continue; if ( is_frame && strcmp( jname, java_name) == 0) { dcli_parse_filename( found_file, dev, dir, graph_name, type, &version); strcpy( name, found_file); found = 1; break; } } dcli_search_file( file_spec, found_file, DCLI_DIR_SEARCH_END); if ( !found) { char msg[200]; sprintf( msg, "Graph for %s not found", java_name); MsgWindow::message('E', msg, msgw_ePop_Yes, oid); m_sts = PWRB__NOBUILT; return; } } m_sts = dcli_file_time( name, &src_time); if ( evenSts()) return; // Check exported java frame jexport = 0; sprintf( dest_fname, "$pwrp_pop/%s.java", java_name); dcli_translate_filename( dest_fname, dest_fname); fsts = dcli_file_time( dest_fname, &dest_time); if ( opt.force || EVEN(fsts) || time_Acomp( &src_time, &dest_time) == 1) jexport = 1; if ( jexport) { if ( !m_wnav) { sprintf( cmd, "Build: WebGraph Unable to export java in this environment %s", java_name); MsgWindow::message('W', cmd, msgw_ePop_No, oid); } else { // Get signature from WebHandler for ( wb_object p = o.parent(); p.oddSts(); p = p.parent()) { if ( p.cid() == pwr_cClass_WebHandler) { wb_attribute a = m_session.attribute( p.oid(), "RtBody", "AppletSignature"); if ( !a) { m_sts = a.sts(); return; } a.value( appletsignature); if ( !a) { m_sts = a.sts(); return; } dcli_trim( appletsignature, appletsignature); break; } } Ge *gectx = m_wnav->ge_new( graph_name, 1); if ( strcmp( appletsignature, "") == 0) strcpy( cmd, "export java"); else sprintf( cmd, "export java /signature=\"%s\"", appletsignature); m_sts = gectx->command( cmd); if ( evenSts()) { msg_GetMsg( m_sts, cmd, sizeof(cmd)); MsgWindow::message('E', cmd, msgw_ePop_Yes, oid); m_sts = PWRB__NOBUILT; delete gectx; return; } delete gectx; sprintf( cmd, "Build: WebGraph Export java %s", java_name); MsgWindow::message('I', cmd, msgw_ePop_No, oid); m_sts = PWRB__SUCCESS; } } } else { // Copy from $pwrp_pop to $pwrp_web strcpy( graph_name, cdh_Low(java_name)); cdh_ToLower( graph_name, graph_name); strcpy( src_fname, "$pwrp_pop/"); strcat( src_fname, graph_name); if ( strstr( src_fname, ".pwg") == 0) strcat( src_fname, ".pwg"); dcli_translate_filename( src_fname, src_fname); m_sts = dcli_file_time( src_fname, &src_time); if ( evenSts()) { m_sts = PWRB__NOBUILT; return; } strcpy( dest_fname, "$pwrp_web/"); strcat( dest_fname, graph_name); if ( strstr( dest_fname, ".pwg") == 0) strcat( dest_fname, ".pwg"); dcli_translate_filename( dest_fname, dest_fname); m_sts = dcli_file_time( dest_fname, &dest_time); if ( opt.force || evenSts() || src_time.tv_sec > dest_time.tv_sec) { sprintf( cmd, "cp %s %s", src_fname, dest_fname); system( cmd); sprintf( cmd, "Build: WebGraph copy $pwrp_pop/%s -> $pwrp_web", graph_name); MsgWindow::message( 'I', cmd, msgw_ePop_No, oid); strcpy( name, graph_name); if (( s = strrchr( name, '.'))) *s = 0; wb_log::log( wlog_eCategory_GeBuild, name, 0); m_sts = PWRB__SUCCESS; } else m_sts = PWRB__NOBUILT; } }
void wb_build::xttgraph( pwr_tOid oid) { pwr_tFileName src_fname, dest_fname; pwr_tCmd cmd; pwr_tString80 action; pwr_tString80 name; pwr_tTime dest_time, src_time; int check_hierarchy = cdh_ObjidIsNotNull( m_hierarchy); int hierarchy_found = 0; int is_frame, is_applet; char java_name[80]; pwr_tStatus fsts; int jexport; char *s; wb_object o = m_session.object(oid); if ( !o) { m_sts = o.sts(); return; } // Check that no ancestor is a LibHier for ( wb_object p = o.parent(); p.oddSts(); p = p.parent()) { if ( p.cid() == pwr_eClass_LibHier) { m_sts = PWRB__INLIBHIER; return; } if ( check_hierarchy && cdh_ObjidIsEqual( m_hierarchy, p.oid())) hierarchy_found = 1; } if ( check_hierarchy && !hierarchy_found) { m_sts = PWRB__NOBUILT; return; } wb_attribute a = m_session.attribute( oid, "RtBody", "Action"); if ( !a) { m_sts = a.sts(); return; } a.value( &action); if ( !a) { m_sts = a.sts(); return; } if ( strstr( action, ".pwg")) { strcpy( src_fname, "$pwrp_pop/"); strcat( src_fname, action); dcli_translate_filename( src_fname, src_fname); m_sts = dcli_file_time( src_fname, &src_time); if ( evenSts()) { m_sts = PWRB__NOBUILT; return; } strcpy( dest_fname, "$pwrp_exe/"); strcat( dest_fname, action); dcli_translate_filename( dest_fname, dest_fname); m_sts = dcli_file_time( dest_fname, &dest_time); if ( opt.force || evenSts() || src_time.tv_sec > dest_time.tv_sec) { sprintf( cmd, "cp %s %s", src_fname, dest_fname); system( cmd); sprintf( cmd, "Build: XttGraph copy $pwrp_pop/%s -> $pwrp_exe", action); MsgWindow::message( 'I', cmd, msgw_ePop_No, oid); strcpy( name, action); if (( s = strrchr( name, '.'))) *s = 0; wb_log::log( wlog_eCategory_GeBuild, name, 0); m_sts = PWRB__SUCCESS; } else m_sts = PWRB__NOBUILT; jexport = 0; fsts = grow_IsJava( src_fname, &is_frame, &is_applet, java_name); if ( EVEN(fsts)) { m_sts = fsts; return; } if ( (is_frame || is_applet) && strcmp( java_name, "") == 0) { // Java name is not yet set, use the default java name strcpy( java_name, action); if ( (s = strchr( java_name, '.')) != 0) *s = 0; java_name[0] = _toupper( java_name[0]); } if ( is_frame) { // Check exported java frame sprintf( dest_fname, "$pwrp_pop/%s.java", java_name); dcli_translate_filename( dest_fname, dest_fname); fsts = dcli_file_time( dest_fname, &dest_time); if ( opt.force || EVEN(fsts) || time_Acomp( &src_time, &dest_time) == 1) jexport = 1; } if ( is_applet) { // Check exported java applet sprintf( dest_fname, "$pwrp_pop/%s_A.java", java_name); dcli_translate_filename( dest_fname, dest_fname); fsts = dcli_file_time( dest_fname, &dest_time); if ( opt.force || EVEN(fsts) || time_Acomp( &src_time, &dest_time) == 1) jexport = 1; } if ( jexport) { if ( !m_wnav) { sprintf( cmd, "Build: XttGraph Unable to export java in this environment %s", action); MsgWindow::message('W', cmd, msgw_ePop_No, oid); } else { Ge *gectx = m_wnav->ge_new( action, 1); strcpy( cmd, "export java"); m_sts = gectx->command( cmd); if ( evenSts()) { msg_GetMsg( m_sts, cmd, sizeof(cmd)); MsgWindow::message('E', cmd, msgw_ePop_Yes, oid); m_sts = PWRB__NOBUILT; delete gectx; return; } sprintf( cmd, "Build: XttGraph Export java %s", action); MsgWindow::message('I', cmd, msgw_ePop_No, oid); delete gectx; m_sts = PWRB__SUCCESS; } } } }
void wb_build::classvolume( pwr_tVid vid) { pwr_tCmd cmd; pwr_tFileName fname; pwr_tObjName name; pwr_tTime wbl_time, dbs_time, h_time; pwr_tStatus fsts; pwr_tStatus sumsts = PWRB__NOBUILT; wb_log::push(); if ( !opt.manual) { // Build all ClassDef classlist( pwr_eClass_ClassDef); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; } wb_log::pull(); if ( vid == 0) { // Build current volume cdh_ToLower( name, m_session.name()); } else { wb_env env = m_session.env(); wb_volume v = env.volume(vid); if ( !v) { m_sts = v.sts(); return; } strcpy( name, v.name()); } // Get time for wb_load file sprintf( fname, "$pwrp_db/%s.wb_load", name); dcli_translate_filename( fname, fname); m_sts = dcli_file_time( fname, &wbl_time); if ( evenSts()) return; // Get time for dbs file sprintf( fname, "$pwrp_load/%s.dbs", name); dcli_translate_filename( fname, fname); fsts = dcli_file_time( fname, &dbs_time); // Get time for classvolumes wb_merep *merep = ((wb_erep *)m_session.env())->merep(); pwr_tTime mtime = pwr_cNTime; pwr_tTime t; pwr_tStatus sts; for ( wb_mvrep *mvrep = merep->volume( &sts); ODD(sts); mvrep = merep->nextVolume( &sts, mvrep->vid())) { if ( m_session.vid() == mvrep->vid()) continue; // Check only system class and manufact class volumes if ( mvrep->vid() > cdh_cSystemClassVolMax && (mvrep->vid() < cdh_cManufactClassVolMin || mvrep->vid() > cdh_cManufactClassVolMax)) continue; mvrep->time( &t); if ( time_Acomp( &t, &mtime) == 1) mtime = t; } // Create new loadfile if ( opt.force || EVEN(fsts) || wbl_time.tv_sec > dbs_time.tv_sec || mtime.tv_sec > dbs_time.tv_sec) { sprintf( cmd, "create snapshot/file=\"$pwrp_db/%s.wb_load\"", name); m_sts = m_wnav->command( cmd); sumsts = m_sts; } else m_sts = sumsts; // Get time for struct file sprintf( fname, "$pwrp_inc/pwr_%sclasses.h", name); dcli_translate_filename( fname, fname); fsts = dcli_file_time( fname, &h_time); // Create new struct file if ( opt.force || EVEN(fsts) || wbl_time.tv_sec > h_time.tv_sec) { sprintf( cmd, "create struct/file=\"$pwrp_db/%s.wb_load\"", name); m_sts = m_wnav->command( cmd); sumsts = m_sts; } else m_sts = sumsts; if ( sumsts != PWRB__NOBUILT) { char msg[80]; sprintf( msg, "Build: Volume %s", name); MsgWindow::message('I', msg, msgw_ePop_No); } }
pwr_tStatus tlog_diff( char *filestr, char *output, char *timestr, int parallell, int attribute, int text, int ttext, int noorder, int exact, char *since_str, char *before_str ) { char saved_filename[80]; char filename[80]; FILE *outfile; int sts; tlog_t_linelist *new_list; tlog_t_linelist *old_list; int new_list_count; int old_list_count; float time; int nr; diff_ctx ctx; char modulestr[80]; char cmd[100]; char new_filename[80]; char old_filename[80]; char wild_filename[80]; char dev[80]; char dir[80]; char file[80]; char type[80]; int version; int first; pwr_tTime file_time; int file_size; int file_version; pwr_tTime before_time; pwr_tTime since_time; int diff_count; unsigned long search_ctx; tlog_get_defaultfilename( filestr, wild_filename, ".tlog", "pwrp_tlog:"); diff_count = 0; first = 1; for(;;) { if ( first) { /* Get the first file */ search_ctx = 0; sts = dir_search_file( &search_ctx, wild_filename, filename); if (EVEN(sts)) return sts; /* At least one file is found */ if ( output != NULL) { /* Open the output file */ outfile = fopen( output, "w"); if ( !outfile ) return TLOG__FILEOPEN; } else outfile = 0; if ( timestr != NULL) { /* Convert to float */ nr = sscanf( timestr, "%f", &time); if ( nr != 1) return TLOG__TIMESYNTAX; } else time = 0.5; if ( before_str != NULL) { sts = tlog_qual_to_time( before_str, &before_time); if (EVEN(sts)) return TLOG__BEFOREQUAL; } if ( since_str != NULL) { sts = tlog_qual_to_time( since_str, &since_time); if (EVEN(sts)) return TLOG__SINCEQUAL; } first = 0; } else { /* Get the next file */ sts = dir_search_file( &search_ctx, wild_filename, filename); if (EVEN(sts)) break; /* fprintf( outfile, ""); */ } sts = dir_get_fileinfo( filename, (pwr_tTime *) &file_time, &file_size, &file_version, NULL); if (EVEN(sts)) return sts; if ( since_str != NULL) { if ( time_Acomp( &file_time, &since_time) < 0) continue; } if ( before_str != NULL) { if ( time_Acomp( &file_time, &before_time) > 0) continue; } sts = dir_parse_filename( filename, dev, dir, file, type, &version); strcpy( saved_filename, "pwrp_stlog:"); strcat( saved_filename, file); strcat( saved_filename, type); /* Read the new file */ new_list_count = 0; sts = tlog_insert_file( filename, &new_list, &new_list_count, new_filename); if ( EVEN(sts)) { if ( outfile) { fprintf( outfile, "\n\n\nNew file: %s\n", new_filename); fprintf( outfile, "%%TLOG-E-NEWOPEN, Unable to open new file\n"); } else { printf( "\n\n\nNew file: %s\n", new_filename); printf( "%%TLOG-E-NEWOPEN, Unable to open new file\n"); } continue; } if ( outfile) fprintf( outfile, "\n\n\nNew file: %s\n", new_filename); else printf( "\n\n\nNew file: %s\n", new_filename); /* Read the old file */ old_list_count = 0; sts = tlog_insert_file( saved_filename, &old_list, &old_list_count, old_filename); if ( EVEN(sts)) { if ( outfile) { fprintf( outfile, "Old file: %s\n", old_filename); fprintf( outfile, "%%TLOG-E-OLDOPEN, Unable to open old file\n"); } else { printf( "Old file: %s\n", old_filename); printf( "%%TLOG-E-OLDOPEN, Unable to open old file\n"); } free( new_list); continue; } if ( outfile) fprintf( outfile, "Old file: %s\n", old_filename); else printf( "Old file: %s\n", old_filename); ctx = calloc( 1, sizeof( *ctx)); ctx->max_difftime = time; ctx->new_list = new_list; ctx->old_list = old_list; ctx->old_list_count = old_list_count; ctx->new_list_count = new_list_count; ctx->outfile = outfile; ctx->parallell = parallell; ctx->attribute = attribute; ctx->text = text; ctx->ttext = ttext; ctx->noorder = noorder; ctx->exact = exact; strcpy( ctx->new_filename, new_filename); strcpy( ctx->old_filename, old_filename); sts = tlog_lists_cmp( ctx); if ( EVEN(sts)) return sts; diff_count++; free( new_list); free( old_list); free( ctx); } if ( outfile) fclose( outfile); sts = dir_search_file_end( &search_ctx); if ( diff_count == 0) if ( outfile) fprintf( outfile, "No files found\n"); else printf( "No files found\n"); return TLOG__SUCCESS; }
int XttTCurve::get_data( pwr_tStatus *sts, pwr_tTime from, pwr_tTime to) { pwr_tDeltaTime trange; int from_idx, to_idx; pwr_tDeltaTime diff; pwr_tFloat32 timerange; int interval; load_data( sts, &arefv[0]); if ( EVEN(*sts)) return 0; // Calculate interval if ( time_Acomp( &from, &tc.last_time) > 0 || time_Acomp( &to, &tc.first_time) < 0) // No samples in this interval return 0; time_Adiff( &diff, &tc.last_time, &tc.first_time); timerange = time_DToFloat( 0, &diff); if ( time_Acomp( &from, &tc.first_time) < 0) { from = tc.first_time; from_idx = 0; } else { time_Adiff( &diff, &from, &tc.first_time); from_idx = time_DToFloat( 0, &diff) * tc.timebuf_samples / timerange; } if ( time_Acomp( &to, &tc.last_time) >= 0) to_idx = tc.timebuf_samples; else { time_Adiff( &diff, &tc.last_time, &to); to_idx = tc.timebuf_samples - time_DToFloat( 0, &diff) * tc.timebuf_samples / timerange; } interval = (to_idx - from_idx) / 1000 + 1; rows = (to_idx - from_idx) / interval; if ( from_idx + rows * interval > tc.timebuf_samples) rows = (tc.timebuf_samples - from_idx) / interval; // Create data for time axis gcd = new GeCurveData( curve_eDataType_DsTrend); gcd->x_data[0] = (double *) calloc( 1, 8 * rows); if ( tc.timeelement_size == 4) { for ( int i = 0; i < rows; i++) gcd->x_data[0][i] = (double) (*((unsigned int *)tc.tbuf + from_idx + i * interval)); } else { for ( int i = 0; i < rows; i++) gcd->x_data[0][i] = (double)(*((unsigned int *)tc.tbuf + 2*from_idx + 2*i*interval)) + (double)1e-9 * (*((unsigned int *)tc.tbuf + 2*from_idx + 2*i*interval + 1)); } strcpy( gcd->x_name, "Time"); gcd->x_axis_type[0] = curve_eAxis_x; strcpy( gcd->x_format[0], "%10t"); for ( int j = 0; j < tc.bufcnt; j++) { strncpy( gcd->y_name[j], tc.name[j], sizeof(gcd->y_name[0])); gcd->rows[j] = rows; gcd->y_data[j] = (double *) calloc( 1, 8 * rows); for ( int i = 0; i < rows; i++) { if ( i >= tc.buf_samples[j]) break; switch ( tc.type[j]) { case pwr_eType_Int64: gcd->y_data[j][i] = *((pwr_tInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_Int32: gcd->y_data[j][i] = *((pwr_tInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_Int16: gcd->y_data[j][i] = *((pwr_tInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_Int8: gcd->y_data[j][i] = *((pwr_tInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_UInt64: gcd->y_data[j][i] = *((pwr_tUInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_UInt32: gcd->y_data[j][i] = *((pwr_tUInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_UInt16: gcd->y_data[j][i] = *((pwr_tUInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_UInt8: gcd->y_data[j][i] = *((pwr_tUInt32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_Float32: gcd->y_data[j][i] = *((pwr_tFloat32 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_Float64: gcd->y_data[j][i] = *((pwr_tFloat64 *)tc.vbuf[j] + from_idx + i*interval); break; case pwr_eType_Boolean: gcd->y_data[j][i] = *((pwr_tBoolean *)tc.vbuf[j] + from_idx + i*interval); break; default: *sts = SEV__CURVETYPE; return 0; } } } gcd->y_axis_type[0] = curve_eAxis_y; gcd->cols = tc.bufcnt; gcd->get_borders(); gcd->get_default_axis(); if ( to.tv_sec != 0 && from.tv_sec != 0) { time_Adiff( &trange, &to, &from); if ( time_DToFloat( 0, &trange) < 600) strcpy( gcd->x_format[0], "%10t"); else strcpy( gcd->x_format[0], "%11t"); } else strcpy( gcd->x_format[0], "%11t"); gcd->select_color( 0); if ( curve) { curve->set_curvedata( gcd); // This will free the old gcd curve->configure_curves(); curve->configure_axes(); curve->redraw(); } *sts = XNAV__SUCCESS; return 1; }
void time_NextPeriod( time_ePeriod period, pwr_tTime *prev_from, pwr_tTime *prev_to, pwr_tTime *from, pwr_tTime *to) { int sts; pwr_tTime current; sts = time_GetTime( ¤t); switch ( period) { case time_ePeriod_OneSecond: case time_ePeriod_LastSecond: *to = *from = *prev_to; to->tv_sec += 1; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 1; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_10Seconds: case time_ePeriod_Last10Seconds: *to = *from = *prev_to; to->tv_sec += 10; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 10; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_OneMinute: case time_ePeriod_LastMinute: *to = *from = *prev_to; to->tv_sec += 60; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 60; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_10Minutes: case time_ePeriod_Last10Minutes: *to = *from = *prev_to; to->tv_sec += 600; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 600; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_OneHour: case time_ePeriod_LastHour: *to = *from = *prev_to; to->tv_sec += 3600; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 3600; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_OneDay: case time_ePeriod_Today: case time_ePeriod_Yesterday: *to = *from = *prev_to; to->tv_sec += ONEDAY; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - ONEDAY; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_OneWeek: case time_ePeriod_ThisWeek: case time_ePeriod_LastWeek: *to = *from = *prev_to; to->tv_sec += 7 * ONEDAY; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 7 * ONEDAY; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_OneMonth: case time_ePeriod_ThisMonth: case time_ePeriod_LastMonth: time_PeriodMonth( prev_to, from, to, 0); to->tv_sec += prev_to->tv_sec - from->tv_sec; *from = *prev_to; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 30 * ONEDAY; from->tv_nsec = current.tv_nsec; } break; case time_ePeriod_OneYear: case time_ePeriod_ThisYear: time_PeriodYear( prev_to, from, to, 0); to->tv_sec += prev_to->tv_sec - from->tv_sec; *from = *prev_to; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - 365 * ONEDAY; from->tv_nsec = current.tv_nsec; } break; break; case time_ePeriod_AllTime: time_Period( period, from, to, 0, 1); break; case time_ePeriod_UserDefined: // Same lenth of intervall as before *to = *from = *prev_to; to->tv_sec += prev_to->tv_sec - prev_from->tv_sec; if ( time_Acomp( ¤t, to) != 1) { *to = current; from->tv_sec = current.tv_sec - (prev_to->tv_sec - prev_from->tv_sec); from->tv_nsec = current.tv_nsec; } break; default: ; } }
pwr_tUInt32 bck_WaitBackup ( void *context, pwr_tBoolean timeout) { pwr_tUInt32 sts; pwr_tObjid objid; pwr_tInt32 c; pwr_tTime t; pwr_tVaxTime tmo; pwr_tVaxTime tmptime; pwr_sClass_Backup_Conf *backup_confp; /* Backup_Conf object pointer */ $DESCRIPTOR (timeunitdsc, "0 0:0:0.1"); /* 0.1 second units */ int cycletime; #ifdef OS_ELN pwr_tInt32 res; pwr_tVaxTime *tmop; #endif #ifdef OS_VMS $DESCRIPTOR (efcname, BCK_EFC_NAME); #endif /* * Initialize */ #ifdef OS_ELN if (!areas_mapped) { BCK_MAP_AREAS; areas_mapped = TRUE; } #endif /* * Find the local Backup_Conf object */ sts = gdh_GetClassList (pwr_cClass_Backup_Conf, &objid); while (ODD (sts)) { sts = gdh_ObjidToPointer (objid, (pwr_tAddress *)&backup_confp); if (ODD (sts)) break; sts = gdh_GetNextObject (objid, &objid); } if (EVEN (sts)) return sts; /* Something wrong, quit */ /* * Pick up argument information */ if (context == NULL) time_GetTime(&t); else { t = *(pwr_tTime *)context; free (context); } #ifdef OS_ELN tmop = NULL; #else timed_out = FALSE; sts = sys$ascefc (BCK_EFC, &efcname, 0, 0); if (EVEN (sts)) lib$signal (sts); /* BUG */ #endif if (timeout) { cycletime = backup_confp->CycleSlow * 2; if (cycletime == 0) cycletime = BCK_DEFAULT_SLOW * 2; #ifdef OS_ELN tmo = eln$time_value (&timeunitdsc); #else sts = sys$bintim (&timeunitdsc, &tmo); if (EVEN (sts)) lib$signal (sts); /* BUG, should not happen */ #endif lib$mult_delta_time ( &cycletime, /* multiplier */ &tmo); /* delta_time (modified) */ sys$gettim (&tmptime); lib$add_times (&tmo, &tmptime, &tmo); /* Make absolute time */ #ifdef OS_ELN tmop = &tmo; #else sts = sys$setimr (BCK_WRITE_DONE, &tmo, &astrtn, 4711, 0); if (EVEN (sts)) lib$signal (sts); /* BUG */ #endif } /* * Loop, and wait for things to happen */ while (TRUE) { #ifdef OS_ELN ker$clear_event (NULL, bck_write_done); ker$wait_any (NULL, &res, tmop, bck_write_done); /* Check for timeout */ if (res == 0) return SS$_TIMEOUT; #else sts = sys$clref (BCK_WRITE_DONE); if (EVEN (sts)) lib$signal (sts); /* BUG */ sts = sys$waitfr (BCK_WRITE_DONE); if (EVEN (sts)) lib$signal (sts); /* BUG */ /* Check for timeout */ if (timed_out) return SS$_TIMEOUT; #endif /* Check if both cycles done */ if (time_Acomp(&backup_confp->ObjTimeSlow, &t) < 0) continue; if (time_Acomp(&backup_confp->ObjTimeFast, &t) < 0) continue; break; } /* Loop */ #ifdef OS_VMS sys$cantim (4711, 0); #endif return 1; /* Done. */ } /* bck_WaitBackup */
void wb_build::webhandler( pwr_tOid oid) { pwr_tTime modtime; pwr_tString80 file_name, name; pwr_tFileName fname; pwr_tTime ftime; pwr_tTime xtthelp_time, html_time; char *s; pwr_tStatus fsts; wb_object o = m_session.object(oid); if ( !o) { m_sts = o.sts(); return; } modtime = o.modTime(); wb_attribute a = m_session.attribute( oid, "RtBody", "FileName"); if ( !a) { m_sts = a.sts(); return; } a.value( &file_name); if ( !a) { m_sts = a.sts(); return; } // Parse the name of the start page if ( (s = strrchr( file_name, '/')) || (s = strrchr( file_name, '<')) || (s = strrchr( file_name, ':'))) strcpy( name, s+1); else strcpy( name, file_name); if ( (s = strrchr( name, '.'))) *s = 0; sprintf( fname, "$pwrp_web/%s_opwin_menu.html", name); dcli_translate_filename( fname, fname); fsts = dcli_file_time( fname, &ftime); m_sts = PWRB__NOBUILT; if ( opt.force || EVEN(fsts) || time_Acomp( &modtime, &ftime) == 1) { // modtime > ftime m_sts = Graph::generate_web( (ldh_tSession *)&m_session); if ( evenSts()) return; char msg[200]; sprintf( msg, "Build: WebHandler Webpage generated %s", fname); MsgWindow::message( 'I', msg, msgw_ePop_No, oid); } // Check if xtthelp should be converted to html dcli_translate_filename( fname, "$pwrp_exe/xtt_help.dat"); fsts = dcli_file_time( fname, &xtthelp_time); if ( EVEN(fsts)) return; dcli_translate_filename( fname, "$pwrp_web/xtt_help_index.html"); fsts = dcli_file_time( fname, &html_time); if ( opt.force || EVEN(fsts) || time_Acomp( &xtthelp_time, &html_time) == 1) { system( "co_convert -d $pwrp_web -t $pwrp_exe/xtt_help.dat"); char msg[200]; sprintf( msg, "Build: WebHandler xtt_help.dat converted to html"); MsgWindow::message( 'I', msg, msgw_ePop_No, oid); m_sts = PWRB__SUCCESS; } // Generate wb history html file pwr_tCmd cmd; strcpy( cmd, "generate history"); m_wnav->command( cmd); }
void time_Period( time_ePeriod period, pwr_tTime *from, pwr_tTime *to, pwr_tTime *center, int daybreak) { int sts; pwr_tTime current; switch ( period) { case time_ePeriod_OneSecond: if ( !center) { time_Period( time_ePeriod_LastSecond, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, 1); break; case time_ePeriod_10Seconds: if ( !center) { time_Period( time_ePeriod_10Seconds, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, 10); break; case time_ePeriod_OneMinute: if ( !center) { time_Period( time_ePeriod_LastMinute, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, 60); break; case time_ePeriod_10Minutes: if ( !center) { time_Period( time_ePeriod_Last10Minutes, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, 600); break; case time_ePeriod_OneHour: if ( !center) { time_Period( time_ePeriod_LastHour, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, 3600); break; case time_ePeriod_OneDay: if ( !center) { time_Period( time_ePeriod_LastHour, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, ONEDAY); break; case time_ePeriod_OneWeek: if ( !center) { time_Period( time_ePeriod_LastWeek, from, to, center, daybreak); return; } time_PeriodSec( from, to, center, 7 * ONEDAY); break; case time_ePeriod_OneMonth: if ( !center) { time_Period( time_ePeriod_LastMonth, from, to, center, daybreak); return; } time_PeriodMonth( center, from, to, 0); int middle = from->tv_sec + (to->tv_sec - from->tv_sec) / 2; int half = middle - from->tv_sec; if ( center->tv_sec >= middle - ONEDAY/2 && center->tv_sec <= middle + ONEDAY/2) return; if ( center->tv_sec < middle) { // Take period from previous month time_PeriodMonth( center, from, to, 1); middle = from->tv_sec + (to->tv_sec - from->tv_sec) / 2; half = middle - from->tv_sec; } to->tv_sec = center->tv_sec + half; from->tv_sec = center->tv_sec - half; sts = time_GetTime( ¤t); if ( time_Acomp( to, ¤t) == 1) { from->tv_sec = current.tv_sec - (to->tv_sec - from->tv_sec); from->tv_nsec = current.tv_sec; *to = current; } break; case time_ePeriod_LastSecond: sts = time_GetTime( to); from->tv_sec = to->tv_sec - 1; from->tv_nsec = to->tv_nsec; break; case time_ePeriod_Last10Seconds: sts = time_GetTime( to); from->tv_sec = to->tv_sec - 10; from->tv_nsec = to->tv_nsec; break; case time_ePeriod_LastMinute: sts = time_GetTime( to); from->tv_sec = to->tv_sec - 60; from->tv_nsec = to->tv_nsec; break; case time_ePeriod_Last10Minutes: sts = time_GetTime( to); from->tv_sec = to->tv_sec - 600; from->tv_nsec = to->tv_nsec; break; case time_ePeriod_LastHour: sts = time_GetTime( to); from->tv_sec = to->tv_sec - 3600; from->tv_nsec = to->tv_nsec; break; case time_ePeriod_Today: sts = time_GetTime( from); *to = *from; time_PreviousDayBreak( from, from); if ( daybreak) { to->tv_sec += ONEDAY; time_PreviousDayBreak( to, to); } break; case time_ePeriod_Yesterday: sts = time_GetTime( to); time_PreviousDayBreak( to, to); from->tv_sec = to->tv_sec - ONEDAY; from->tv_nsec = 0; break; case time_ePeriod_ThisWeek: sts = time_GetTime( ¤t); sts = time_PeriodPreviousWeek( ¤t, 0, from); *to = current; if ( daybreak) { to->tv_sec += ONEDAY; time_PreviousDayBreak( to, to); } break; case time_ePeriod_LastWeek: sts = time_GetTime( ¤t); sts = time_PeriodPreviousWeek( ¤t, from, to); break; case time_ePeriod_ThisMonth: sts = time_GetTime( ¤t); sts = time_PeriodMonth( ¤t, 0, from, 1); *to = current; if ( daybreak) { to->tv_sec += ONEDAY; time_PreviousDayBreak( to, to); } break; case time_ePeriod_LastMonth: sts = time_GetTime( ¤t); sts = time_PeriodMonth( ¤t, from, to, 1); break; case time_ePeriod_OneYear: case time_ePeriod_ThisYear: sts = time_GetTime( ¤t); sts = time_PeriodYear( ¤t, 0, from, 1); *to = current; if ( daybreak) { to->tv_sec += ONEDAY; time_PreviousDayBreak( to, to); } break; default: { // time_ePeriod_All: struct tm *tm; sts = time_GetTime( to); if ( daybreak) { to->tv_sec += ONEDAY; time_PreviousDayBreak( to, to); } time_t sec = to->tv_sec; tm = localtime(&sec); tm->tm_sec = 0; tm->tm_min = 0; tm->tm_hour = 0; tm->tm_mday = 1; tm->tm_mon = 0; tm->tm_year = 70; from->tv_sec = mktime(tm); from->tv_nsec = 0; break; } } }
void wb_build::webbrowserconfig( pwr_tOid oid) { pwr_tTime modtime; pwr_tFileName fname; pwr_tTime ftime; pwr_tStatus fsts; FILE *fp; int i, j; int found; char line[200]; pwr_tObjName vname; strncpy( vname, m_session.name(), sizeof(vname)); wb_object o = m_session.object(oid); if ( !o) { m_sts = o.sts(); return; } modtime = o.modTime(); sprintf( fname, "$pwrp_db/pwrp_cnf_websymbols.dat"); dcli_translate_filename( fname, fname); fsts = dcli_file_time( fname, &ftime); m_sts = PWRB__NOBUILT; if ( opt.force || EVEN(fsts) || time_Acomp( &modtime, &ftime) == 1) { pwr_sClass_WebBrowserConfig body; int url_symbols_size = sizeof(body.URL_Symbols)/sizeof(body.URL_Symbols[0]); char sym_vect[MAXSYMBOLS][80]; char value_vect[MAXSYMBOLS][80]; char volume_vect[MAXSYMBOLS][80]; int vect_cnt; int nr; char elemv[3][80]; wb_attribute a = m_session.attribute( oid, "RtBody", "URL_Symbols"); if ( !a) { m_sts = a.sts(); return; } a.value( body.URL_Symbols); if ( !a) { m_sts = a.sts(); return; } // Read the file and merge the symbols of this volume with other symbols in the project vect_cnt = 0; fp = fopen( fname, "r"); if ( fp) { while ( dcli_read_line( line, sizeof( line), fp)) { nr = dcli_parse( line, " ", "", (char *)elemv, sizeof( elemv) / sizeof( elemv[0]), sizeof( elemv[0]), 0); if ( nr != 3) continue; // Skip old symbols from this volume if ( cdh_NoCaseStrcmp( vname, elemv[0]) == 0) continue; strcpy( volume_vect[vect_cnt], elemv[0]); strcpy( sym_vect[vect_cnt], elemv[1]); strcpy( value_vect[vect_cnt], elemv[2]); vect_cnt++; } fclose( fp); } for ( i = 0; i < url_symbols_size; i++) { nr = dcli_parse( body.URL_Symbols[i], " ", "", (char *)elemv, sizeof( elemv) / sizeof( elemv[0]), sizeof( elemv[0]), 0); if ( nr != 2) continue; found = 0; for ( j = 0; j < vect_cnt; j++) { if ( cdh_NoCaseStrcmp( elemv[0], sym_vect[j]) == 0) { strcpy( value_vect[j], elemv[1]); found = 1; break; } } if ( !found) { // Insert first for ( j = MIN(vect_cnt,MAXSYMBOLS-1); j > 0; j--) { strcpy( volume_vect[j], volume_vect[j-1]); strcpy( sym_vect[j], sym_vect[j-1]); strcpy( value_vect[j], value_vect[j-1]); } strcpy( volume_vect[0], vname); strcpy( sym_vect[0], elemv[0]); strcpy( value_vect[0], elemv[1]); vect_cnt++; if ( vect_cnt > MAXSYMBOLS) vect_cnt = MAXSYMBOLS; } } // Write the file fp = fopen( fname, "w"); if ( !fp) { char msg[200]; sprintf( msg, "Build: Unable to open file %s", fname); MsgWindow::message( 'E', msg, msgw_ePop_No, oid); return; } for ( i = 0; i < vect_cnt; i++) fprintf( fp, "%s %s %s\n", volume_vect[i], sym_vect[i], value_vect[i]); fclose( fp); } }
int main (int argc, char **argv) { pwr_tStatus sts; pwr_tObjid ObjId; pwr_sClass_DsTrendConf *TConfP; pwr_tBoolean InitOK; pwr_tTime CurrentTime, LastScan, NextScan; pwr_tDeltaTime ScanDeltaTime, WaitTime; qcom_sQid qini; qcom_sQattr qAttr; int tmo; char mp[2000]; qcom_sQid qid = qcom_cNQid; qcom_sGet get; int swap = 0; trend_tCtx ctx; errh_Init("pwr_trend", errh_eAnix_trend); errh_SetStatus( PWR__SRVSTARTUP); sts = gdh_Init("ds_trend"); If_Error_Log_Exit(sts, "gdh_Init"); if (!qcom_Init(&sts, 0, "pwr_trend")) { errh_Fatal("qcom_Init, %m", sts); exit(sts); } qAttr.type = qcom_eQtype_private; qAttr.quota = 100; if (!qcom_CreateQ(&sts, &qid, &qAttr, "events")) { errh_Fatal("qcom_CreateQ, %m", sts); exit(sts); } qini = qcom_cQini; if (!qcom_Bind(&sts, &qid, &qini)) { errh_Fatal("qcom_Bind(Qini), %m", sts); exit(-1); } ctx = (trend_tCtx) calloc( 1, sizeof(trend_sCtx)); /* Wait until local nethandler has started */ while(EVEN(gdh_NethandlerRunning())) sleep(1); /* Fetch ScanTime */ sts = gdh_GetClassList(pwr_cClass_DsTrendConf, &ObjId); if (EVEN(sts)) { errh_Info("Couldn't get the DsTrendConf object. Used ScanTime = 1 s"); ctx->scantime = 1; ctx->scantime_tc = 1.0; } else { gdh_ObjidToPointer(ObjId, (pwr_tAddress *)&TConfP); ctx->scantime = TConfP->ScanTime; if ( ctx->scantime > 3600) ctx->scantime = 3600; else if ( ctx->scantime < 1) ctx->scantime = 1; ctx->scantime_tc = TConfP->ScanTime; if ( ctx->scantime_tc > 3600) ctx->scantime_tc = 3600; } ctx->dstrend_multiple = (int) (ctx->scantime / ctx->scantime_tc + 0.5); aproc_RegisterObject( ObjId); InitOK = FALSE; sts = InitTrendList( ctx); if ( EVEN(sts)) { /* This should be removed when we can wait for init messages. */ errh_SetStatus(0); errh_Info("No DsTrend objects configured"); exit(0); } /* If even sts, just wait for init message */ time_GetTimeMonotonic(&LastScan); time_FloatToD( &ScanDeltaTime, ctx->scantime_tc); aproc_TimeStamp( ctx->scantime, 5.0); errh_SetStatus( PWR__SRUN); for (;;) { time_GetTimeMonotonic(&CurrentTime); time_Aadd(&NextScan, &LastScan, &ScanDeltaTime); if (time_Acomp(&CurrentTime, &NextScan) < 0) { time_Adiff(&WaitTime, &NextScan, &CurrentTime); tmo = 1000 * time_DToFloat( 0, &WaitTime); get.maxSize = sizeof(mp); get.data = mp; qcom_Get( &sts, &qid, &get, tmo); if (sts == QCOM__TMO || sts == QCOM__QEMPTY) { if ( !swap) StoreData( ctx); } else { ini_mEvent new_event; qcom_sEvent *ep = (qcom_sEvent*) get.data; new_event.m = ep->mask; if (new_event.b.oldPlcStop && !swap) { swap = 1; errh_SetStatus( PWR__SRVRESTART); CloseTrendList( ctx); } else if (new_event.b.swapDone && swap) { swap = 0; sts = InitTrendList( ctx); errh_SetStatus( PWR__SRUN); errh_Info("Warm restart completed"); } else if (new_event.b.terminate) { exit(0); } } } else if ( !swap) StoreData( ctx); LastScan = NextScan; aproc_TimeStamp( ctx->scantime, 5.0); } return 1; }
void wb_build::rootvolume( pwr_tVid vid) { pwr_tStatus sumsts, plcsts; pwr_tOid oid; pwr_tTime modtime; pwr_tObjName vname; pwr_tFileName fname; pwr_tTime dbs_time, rtt_time; pwr_tCmd cmd; char msg[80]; wb_log::push(); if ( !opt.manual) { // Build all plcpgm classlist( pwr_cClass_plc); if ( evenSts()) return; plcsts = sumsts = m_sts; // Build all XttGraph classlist( pwr_cClass_XttGraph); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; classlist( pwr_cClass_WebHandler); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; classlist( pwr_cClass_WebBrowserConfig); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; // Build all WebGraph classlist( pwr_cClass_WebGraph); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; // Build all AppGraph classlist( pwr_cClass_AppGraph); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; classlist( pwr_cClass_Application); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; classlist( pwr_cClass_PlcProcess); if ( evenSts()) return; if ( sumsts == PWRB__NOBUILT && m_sts != PWRB__NOBUILT) sumsts = m_sts; } wb_log::pull(); // Create loadfiles oid.oix = 0; oid.vid = m_session.vid(); wb_attribute a = m_session.attribute( oid, "SysBody", "Modified"); if ( !a) { m_sts = a.sts(); return; } a.value( &modtime); if ( !a) { m_sts = a.sts(); return; } cdh_ToLower( vname, m_session.name()); sprintf( fname, "$pwrp_load/%s.dbs", vname); dcli_translate_filename( fname, fname); m_sts = dcli_file_time( fname, &dbs_time); // Get time for classvolumes wb_merep *merep = ((wb_vrep *)m_session)->merep(); pwr_tTime mtime = pwr_cNTime; pwr_tTime t; pwr_tStatus sts; for ( wb_mvrep *mvrep = merep->volume( &sts); ODD(sts); mvrep = merep->nextVolume( &sts, mvrep->vid())) { mvrep->time( &t); if ( time_Acomp( &t, &mtime) == 1) mtime = t; } if ( opt.force || opt.manual || evenSts() || time_Acomp( &modtime, &dbs_time) == 1 || time_Acomp( &mtime, &dbs_time) == 1 || plcsts != PWRB__NOBUILT) { m_sts = lfu_create_loadfile( (ldh_tSession *) &m_session); if ( evenSts()) return; m_sts = ldh_CreateLoadFile( (ldh_tSession *) &m_session); if ( evenSts()) return; sprintf( msg, "Build: Volume Loadfiles created volume %s", m_session.name()); MsgWindow::message('I', msg, msgw_ePop_No); wb_log::log( &m_session, wlog_eCategory_VolumeBuild, m_session.vid()); sumsts = PWRB__SUCCESS; } else m_sts = sumsts; cdh_uVolumeId uvid; uvid.pwr = m_session.vid(); sprintf( fname, "$pwrp_load/" load_cNameRttCrr, uvid.v.vid_3, uvid.v.vid_2, uvid.v.vid_1, uvid.v.vid_0); dcli_translate_filename( fname, fname); m_sts = dcli_file_time( fname, &rtt_time); if ( opt.crossref && ( evenSts() || time_Acomp( &modtime, &rtt_time) == 1)) { strcpy( cmd, "create crossreferencefiles"); m_wnav->command( cmd); if ( ODD(sumsts)) sumsts = PWRB__SUCCESS; sprintf( msg, "Build: Volume Crossreference file generated volume %s", m_session.name()); MsgWindow::message('I', msg, msgw_ePop_No); } m_sts = sumsts; }
static void *mb_connect( void *arg) { io_sRack *rp = (io_sRack *)arg; io_sServerLocal* local = rp->Local; int sts; pwr_sClass_Modbus_TCP_Server *op; struct sockaddr_in r_addr; socklen_t r_addr_len; int c_socket; mb_sCondata *condata; int idx; int found; int i; op = (pwr_sClass_Modbus_TCP_Server *) rp->op; while ( 1) { /* Wait for client connect request */ r_addr_len = sizeof(r_addr); c_socket = accept( local->s, (struct sockaddr *) &r_addr, &r_addr_len); if ( c_socket < 0) { errh_Error( "Error accept IO modbus tcp server %s, %d", rp->Name, local->s); continue; } if ( op->DisableServer) continue; errh_Info( "Connection accepted for IO modbus tcp server %s, %d", rp->Name, c_socket); /* Close other connections to this address */ for ( i = 0; i < MB_MAX_CONNECTIONS; i++) { if ( local->connections[i].occupied && r_addr_len == local->connections[i].addrlen && r_addr.sin_family == local->connections[i].addr.sin_family && memcmp( &r_addr.sin_addr, &local->connections[i].addr.sin_addr, sizeof(r_addr.sin_addr)) == 0) { mb_close_connection( rp, i); } } /* Find next empty in connection list */ found = 0; for ( i = 0; i < MB_MAX_CONNECTIONS; i++) { if ( !local->connections[i].occupied) { found = 1; idx = i; break; } } if ( !found) { /* Remove the oldest connection */ int oldest_idx = 0; for ( i = 1; i < MB_MAX_CONNECTIONS; i++) { if ( time_Acomp( &local->connections[i].last_req_time, &local->connections[oldest_idx].last_req_time) < 0) oldest_idx = i; } mb_close_connection( rp, oldest_idx); errh_Info( "Connection closed, IO modbus tcp server %s, %d", rp->Name, local->s); idx = oldest_idx; } local->connections[idx].c_socket = c_socket; local->connections[idx].occupied = 1; time_GetTime( &local->connections[idx].last_req_time); local->connections[idx].addrlen = r_addr_len; memcpy( &local->connections[idx].addr, &r_addr, r_addr_len); /* Create a thread for this connection */ condata = (mb_sCondata *) malloc( sizeof(mb_sCondata)); condata->rp = rp; condata->idx = idx; sts = thread_Create( &local->connections[idx].t, 0, mb_receive, (void *)condata); if ( EVEN(sts)) { local->connections[idx].occupied = 0; errh_Error( "Error creating thread IO modbus tcp server %s, %d", rp->Name, local->s); free( condata); continue; } } return 0; }
/** Handle GetCclass message */ void cmvolsm_GetCclass ( qcom_sGet *get ) { pwr_tStatus sts; pwr_tStatus lsts; int size; net_sGetCclassR *rmp = NULL; net_sGetCclass *mp = get->data; qcom_sPut put; gdb_sAttribute *ap; net_sCattribute *cap; gdb_sClass *cp; gdb_sObject *cop; int i; pwr_tBoolean equal = FALSE; const int maxacnt = ((net_cSizeLarge - sizeof(*rmp)) / sizeof(rmp->attr[0])) + 1; int maxaidx; int acnt; pwr_tTime mp_time; gdb_AssumeUnlocked; gdb_ScopeLock { cp = hash_Search(&sts, gdbroot->cid_ht, &mp->cid); if (cp == NULL) break; cop = pool_Address(NULL, gdbroot->pool, cp->cor); mp_time = net_NetTimeToTime(&mp->time); if (time_Acomp(&mp_time, &cop->u.n.time) == 0) { equal = TRUE; size = sizeof(*rmp); } else { acnt = MIN(maxacnt, cp->acount - mp->aidx); maxaidx = acnt + mp->aidx; size = sizeof(*rmp) + MAX(0, (acnt - 1)) * sizeof(rmp->attr[0]); } rmp = net_Alloc(&sts, &put, size, net_eMsg_getCclassR); if (rmp == NULL) { errh_Error("cmvolsm_GetCclass. net_Alloc, size %d, cid %d, error %m", size, mp->cid, sts); break; } rmp->ver = net_cVersion; rmp->sts = 1; rmp->equal = equal; if (equal) { rmp->acntmsg = 0; rmp->cclass.size = 0; rmp->cclass.acount = 0; break; } rmp->cclass.cid = mp->cid; rmp->cclass.time = net_TimeToNetTime(&cop->u.n.time); rmp->cclass.size = cp->size; rmp->cclass.acount = cp->acount; for (i = mp->aidx, ap = &cp->attr[mp->aidx], cap = rmp->attr; i < maxaidx; i++, ap++, cap++ ) { cap->aix = ap->aix; cap->flags = ap->flags; cap->type = ap->type; cap->offs = ap->offs; cap->size = ap->size; cap->elem = ap->elem; cap->moffset = ap->moffset; } rmp->acntmsg = acnt; rmp->saidx = mp->aidx; rmp->naidx = (i == cp->acount) ? UINT_MAX : i; } gdb_ScopeUnlock; if (EVEN(sts)) { rmp = net_Alloc(&lsts, &put, sizeof(*rmp), net_eMsg_getCclassR); if (EVEN(lsts)) { errh_Error("cmvolsm_GetCclass. net_Alloc, size %d, cid %d, error %m", sizeof(*rmp), mp->cid, lsts); return; } rmp->ver = net_cVersion; } if (EVEN(sts)) rmp->sts = sts; else rmp->sts = 1; net_Reply(&lsts, get, &put, 0); }