static int expect_element_end (
xmlTextReaderPtr reader,
char *exp_name)
{
xmlChar *name;
/* maybe we are already on the end element ... lets see */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_END_ELEMENT){
xmlChar *temp;
xmlChar *temp2;
temp = xmlTextReaderName(reader);
temp2 = (xmlChar*)sprintf_alloc("/%s", temp);
name = xmlStrdup(temp2);
xmlFree(temp);
free(temp2);
} else {
name = get_xml_element(reader);
}
if (name == NULL)
return -1;
if (xmlStrcasecmp(name+1,(xmlChar *)exp_name) != 0 || name[0] != '/'){
rrd_set_error("line %d: expected </%s> end element but found <%s>",
xmlTextReaderGetParserLineNumber(reader),exp_name,name);
xmlFree(name);
return -1;
}
xmlFree(name);
return 0;
} /* expect_element_end */
static int get_xml_time_t(
xmlTextReaderPtr reader,
time_t *value)
{
xmlChar *text;
time_t temp;
if ((text = get_xml_text(reader)) != NULL){
errno = 0;
#if SIZEOF_TIME_T == 4
temp = strtol((char *)text,NULL, 0);
#elif SIZEOF_TIME_T == 8
temp = strtoll((char *)text,NULL, 0);
#else
#error "Don't know how to deal with TIME_T other than 4 or 8 bytes"
#endif
if (errno>0){
rrd_set_error("ling %d: get_xml_time_t from '%s' %s",
xmlTextReaderGetParserLineNumber(reader),
text,rrd_strerror(errno));
xmlFree(text);
return -1;
}
xmlFree(text);
*value = temp;
return 0;
}
return -1;
} /* get_xml_time_t */
char* readRequiredAttribute( xmlTextReaderPtr xmlRead, const char* name ) {
char* s = (char*) xmlTextReaderGetAttribute( xmlRead, name );
if( s == NULL || strlen( s ) == 0 ) {
printf( "Error on line %d: expected required attribute\n", xmlTextReaderGetParserLineNumber( xmlRead ) );
return NULL;
}
return s;
}
char* readString( xmlTextReaderPtr xmlRead ) {
char* s = (char*) xmlTextReaderReadInnerXML( xmlRead );
if( s == NULL || strlen( s ) == 0 ) {
printf( "Error on line %d: expected string\n", xmlTextReaderGetParserLineNumber( xmlRead ) );
return NULL;
}
return s;
}
gint
xml_reader_get_line_number (XmlReader *reader)
{
g_return_val_if_fail(XML_IS_READER(reader), -1);
if (reader->xml)
return xmlTextReaderGetParserLineNumber(reader->xml);
return -1;
}
static xmlChar* get_xml_text (
xmlTextReaderPtr reader
)
{
while(xmlTextReaderRead(reader)){
xmlChar *ret;
xmlChar *text;
xmlChar *begin_ptr;
xmlChar *end_ptr;
int type;
type = xmlTextReaderNodeType(reader);
if (type == XML_READER_TYPE_ELEMENT){
xmlChar *name;
name = xmlTextReaderName(reader);
rrd_set_error("line %d: expected a value but found a <%s> element",
xmlTextReaderGetParserLineNumber(reader),
name);
xmlFree(name);
return NULL;
}
/* trying to read text from <a></a> we end up here
lets return an empty string instead. This is a tad optimistic
since we do not check if it is actually </a> and not </b>
we got, but first we do not know if we expect </a> and second
we the whole implementation is on the optimistic side. */
if (type == XML_READER_TYPE_END_ELEMENT){
return xmlStrdup(BAD_CAST "");
}
/* skip all other non-text */
if (type != XML_READER_TYPE_TEXT)
continue;
text = xmlTextReaderValue(reader);
begin_ptr = text;
while ((begin_ptr[0] != 0) && (isspace(begin_ptr[0])))
begin_ptr++;
if (begin_ptr[0] == 0) {
xmlFree(text);
return xmlStrdup(BAD_CAST "");
}
end_ptr = begin_ptr;
while ((end_ptr[0] != 0) && (!isspace(end_ptr[0])))
end_ptr++;
end_ptr[0] = 0;
ret = xmlStrdup(begin_ptr);
xmlFree(text);
return ret;
}
rrd_set_error("file ended while looking for text");
return NULL;
} /* get_xml_text */
void reportError(void *ptr, xmlErrorPtr error)
{
ErrorInfo *errorInfo = (ErrorInfo*) ptr;
assert(errorInfo);
if (errorInfo->verbose)
{
int msglen;
int domain = error->domain;
const char *filename =
error->file? error->file :
errorInfo? errorInfo->filename :
NULL;
xmlTextReaderPtr reader = errorInfo->xmlReader;
int line = (!filename)? 0 :
(reader)? xmlTextReaderGetParserLineNumber(reader) :
error->line;
int column = (!filename)? 0 :
(reader)? xmlTextReaderGetParserColumnNumber(reader) :
error->int2;
if (line)
{
fprintf(stderr, "%s:%d.%d: ", filename, line, column);
}
msglen = strlen(error->message);
if (error->message[msglen-1] == '\n')
error->message[msglen-1] = '\0';
fprintf(stderr, "%s", error->message);
/* only print extra info if it's not in message */
if (error->str1 && strstr(error->message, error->str1) == NULL) {
fprintf(stderr, ": %s", error->str1);
if (error->str2 && strstr(error->message, error->str2) == NULL) {
fprintf(stderr, ", %s", error->str2);
}
if (error->str3 && strstr(error->message, error->str3) == NULL) {
fprintf(stderr, ", %s", error->str3);
}
}
fprintf(stderr, "\n");
if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
(domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
(domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
xmlParserCtxtPtr ctxt = error->ctxt;
if (ctxt) xmlParserPrintFileContext(ctxt->input);
}
}
if (errorInfo->stop == STOP) {
exit(EXIT_FAILURE);
}
}
/* reader:line_number() */
static int xmlreader_line_number(lua_State *L) {
xmlreader xr = check_xmlreader(L, 1);
int ret = xmlTextReaderGetParserLineNumber(xr);
if (ret != 0) {
lua_pushinteger(L, ret);
} else {
lua_pushnil(L); /* Should we just return 0? */
}
return 1;
}
int XMIResource::processText(xmlTextReaderPtr reader)
{
int ret;
switch (parent)
{
case e_nzcross:
// nzcross is a Block property
ret = loadIntArray(reader, NZCROSS, processed.back());
break;
case e_nmode:
// nmode is a Block property
ret = loadIntArray(reader, NMODE, processed.back());
break;
case e_rpar:
// rpar is a Block property
ret = loadDoubleArray(reader, RPAR, processed.back());
break;
case e_ipar:
// ipar is a Block property
ret = loadIntArray(reader, IPAR, processed.back());
break;
case e_state:
// state is a Block property
ret = loadDoubleArray(reader, RPAR, processed.back());
break;
case e_dstate:
// dstate is a Block property
ret = loadDoubleArray(reader, RPAR, processed.back());
break;
case e_expression:
// expression is a Block property
ret = loadStringArray(reader, EXPRS, processed.back());
break;
case e_context:
// context is a Layer property
ret = loadStringArray(reader, DIAGRAM_CONTEXT, processed.back());
break;
case e_datatype:
// datatype is a port property
ret = loadIntArray(reader, DATATYPE, processed.back());
break;
default:
sciprint("Unable to decode text value at line %d\n", xmlTextReaderGetParserLineNumber(reader) - 1);
ret = -1;
break;
}
return ret;
}
static int expect_element (
xmlTextReaderPtr reader,
char *exp_name)
{
xmlChar *name;
name = get_xml_element(reader);
if (!name)
return -1;
if (xmlStrcasecmp(name,(xmlChar *)exp_name) != 0){
rrd_set_error("line %d: expected <%s> element but found <%s>",
xmlTextReaderGetParserLineNumber(reader),name,exp_name);
xmlFree(name);
return -1;
}
xmlFree(name);
return 0;
} /* expect_element */
static int get_xml_ulong(
xmlTextReaderPtr reader,
unsigned long *value)
{
xmlChar *text;
unsigned long temp;
if ((text = get_xml_text(reader)) != NULL){
errno = 0;
temp = strtoul((char *)text,NULL, 0);
if (errno>0){
rrd_set_error("ling %d: get_xml_ulong from '%s' %s",
xmlTextReaderGetParserLineNumber(reader),
text,rrd_strerror(errno));
xmlFree(text);
return -1;
}
xmlFree(text);
*value = temp;
return 0;
}
return -1;
} /* get_xml_ulong */
static int get_xml_double(
xmlTextReaderPtr reader,
double *value)
{
xmlChar *text;
double temp;
if ((text = get_xml_text(reader))!= NULL){
if (xmlStrcasestr(text,(xmlChar *)"nan")){
*value = DNAN;
xmlFree(text);
return 0;
}
else if (xmlStrcasestr(text,(xmlChar *)"-inf")){
*value = -DINF;
xmlFree(text);
return 0;
}
else if (xmlStrcasestr(text,(xmlChar *)"+inf")
|| xmlStrcasestr(text,(xmlChar *)"inf")){
*value = DINF;
xmlFree(text);
return 0;
}
if ( rrd_strtodbl((char *)text,NULL, &temp, NULL) != 2 ){
rrd_set_error("ling %d: get_xml_double from '%s' %s",
xmlTextReaderGetParserLineNumber(reader),
text,rrd_strerror(errno));
xmlFree(text);
return -1;
}
xmlFree(text);
*value = temp;
return 0;
}
return -1;
} /* get_xml_double */
/*
* call-seq:
* reader.line_number -> number
*
* Provide the line number of the current parsing point.
*/
static VALUE
rxml_reader_line_number(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2NUM(xmlTextReaderGetParserLineNumber(xreader));
}
static int parse_tag_rra_database(
xmlTextReaderPtr reader,
rrd_t *rrd )
{
rra_def_t *cur_rra_def;
unsigned int total_row_cnt;
int status;
int i;
xmlChar *element;
total_row_cnt = 0;
for (i = 0; i < (((int) rrd->stat_head->rra_cnt) - 1); i++)
total_row_cnt += rrd->rra_def[i].row_cnt;
cur_rra_def = rrd->rra_def + i;
status = 0;
while ((element = get_xml_element(reader)) != NULL){
if (xmlStrcasecmp(element,(const xmlChar *)"row") == 0){
rrd_value_t *temp;
rrd_value_t *cur_rrd_value;
unsigned int total_values_count = rrd->stat_head->ds_cnt
* (total_row_cnt + 1);
/* Allocate space for the new values.. */
temp = (rrd_value_t *) realloc(rrd->rrd_value,
sizeof(rrd_value_t) *
total_values_count);
if (temp == NULL) {
rrd_set_error("parse_tag_rra_database: realloc failed.");
status = -1;
break;
}
rrd->rrd_value = temp;
cur_rrd_value = rrd->rrd_value
+ (rrd->stat_head->ds_cnt * total_row_cnt);
memset(cur_rrd_value, '\0',
sizeof(rrd_value_t) * rrd->stat_head->ds_cnt);
total_row_cnt++;
cur_rra_def->row_cnt++;
status =
parse_tag_rra_database_row(reader, rrd, cur_rrd_value);
if (status == 0)
status = expect_element(reader,"/row");
} /* if (xmlStrcasecmp(element,"row")) */
else {
if ( xmlStrcasecmp(element,(const xmlChar *)"/database") == 0){
xmlFree(element);
break;
}
else {
rrd_set_error("line %d: found unexpected tag: %s",
xmlTextReaderGetParserLineNumber(reader),element);
status = -1;
}
}
xmlFree(element);
if (status != 0)
break;
}
return (status);
} /* int parse_tag_rra_database */
void readConfig( const char* filename ) {
/* States:
* 0 : reading new entities ( to: 1, 3, 4, 5 )
* 1 : reading machine
* 2 : reading role
* 3 : reading core
* 4 : reading file
* 5 : reading test ( to: 2 )
*/
int state = 0;
struct machine m;
struct role r;
struct file f;
struct core c;
struct test t;
xmlTextReaderPtr xmlRead = xmlReaderForFile( filename, NULL, XML_PARSE_NONET | XML_PARSE_NOENT | XML_PARSE_NOCDATA | XML_PARSE_NOXINCNODE | XML_PARSE_COMPACT );
if( !xmlRead )
quit( "Could not open %s for reading as XML config\n", filename );
xmlTextReaderSetErrorHandler( xmlRead, xmlErrorHandler, 0 );
int nodeType, ret;
xmlChar* nodeName;
while( 1 ) {
if( ( ret = xmlTextReaderRead( xmlRead ) ) != 1 ) {
if( ret < 0 )
quit( "Error occurred\n" );
if( state )
quit( "No more nodes to read, but state is not 0. Incomplete elements.\n" );
xmlTextReaderClose( xmlRead );
return;
}
nodeType = xmlTextReaderNodeType( xmlRead );
nodeName = NULL;
switch( nodeType ) {
case XmlNodeType.Element :
nodeName = xmlTextReaderLocalName( xmlRead );
switch( state ) {
case 0 :
if( !strcmp( nodeName, "machine" ) ) {
state = 1;
bzero( m, sizeof( struct machine ) );
readValidRequiredAttribute( m.name, "machine", "name" );
readValidRequiredAttribute( m.address, "machine", "address" );
if( !strcmp( m.address, "DAS4" ) ) {
readValidRequiredAttribute( m.count, "machine", "DAS4 node count" );
char* end = NULL;
m.icount = strtol( m.count, &end, 10 );
if( end == m.count || *end || m.icount < 1 )
quit( "Invalid DAS4 node count for machine %s\n", m.name );
}
break;
}
if( !strcmp( nodeName, "core" ) ) {
state = 3;
bzero( c, sizeof( struct core ) );
readValidRequiredAttribute( c.name, "core", "name" );
break;
}
if( !strcmp( nodeName, "file" ) ) {
state = 4;
bzero( f, sizeof( struct file ) );
readValidRequiredAttribute( f.name, "file", "name" );
readValidRequiredAttribute( f.size, "file", "size" );
char* end = NULL;
f.isize = strtol( f.size, &end, 10 );
if( end == f.size || f.isize < 1 )
quit( "Invalid size specifier for file %s\n", f.name );
if( *end && *(end+1) )
quit( "Invalid size specifier for file %s\n", f.name );
if( *end ) {
switch( *end ) {
case 'b' :
case 'B' :
break;
case 'k' :
case 'K' :
f.isize *= 1024;
break;
case 'm' :
case 'M' :
f.isize *= 1024 * 1024;
break;
case 'g' :
case 'G' :
f.isize *= 1024 * 1024 * 1024;
break;
case 't' :
case 'T' :
f.isize *= 1024 * 1024 * 1024 * 1024;
break;
default :
quit( "Invalid size specifier for file %s\n", f.name );
}
}
if( f.isize > 512 * 1024 * 1024 ) {
int p = 512*1024*1024;
while( p < f.isize )
p <<= 1;
if( p != f.isize )
quit( "Invalid size specifier for file %s: sizes above 512M should be powers of 2\n", f.name );
}
if( f.isize & 0x3 )
quit( "Invalid size specifier for file %s: sizes should be a multiple of 4\n", f.name );
break;
}
if( !strcmp( nodeName, "test" ) ) {
state = 5;
bzero( t, sizeof( struct test ) );
readValidRequiredAttribute( t.name, "test", "name" );
break;
}
break;
case 1 :
if( !strcmp( nodeName, "tmpDir" ) ) {
onlyOne( m.tmpdir, "machine", "tmpDir" );
readValidString( m.tmpdir, "temporary directory location" );
skipToEndElement( "tmpDir" );
break;
}
if( !strcmp( nodeName, "params" ) ) {
onlyOne( m.params, "machine", "params" );
readValidString( m.params, "params" );
skipToEndElement( "params" );
break;
}
printf( "Unexpected element %s in machine %s\n", nodeName, m.name );
break;
case 2 :
if( !strcmp( nodeName, "machine" ) ) {
if( r.machineCount > 255 )
quit( "Maximum of 256 machines per role passed on line %d\n", xmlTextReaderGetParserLineNumber( xmlRead ) );
readValid( r.machine[r.machineCount], "machine name" );
r.machineCount++;
skipToEndElement( "machine" );
break;
}
if( !strcmp( nodeName, "user" ) ) {
onlyOne( r.user, "role", "user" );
readValidString( r.user, "user" );
skipToEndElement( "user" );
break;
}
if( !strcmp( nodeName, "core" ) ) {
onlyOne( r.core, "role", "core" );
readValidString( r.core, "core name" );
skipToEndElement( "core" );
break;
}
if( !strcmp( nodeName, "file" ) ) {
onlyOne( r.file, "role", "file" );
readValidString( r.file, "file name" );
skipToEndElement( "file" );
break;
}
if( !strcmp( nodeName, "params" ) ) {
onlyOne( r.params, "role", "params" );
readValidString( r.params, "params" );
skipToEndElement( "params" );
break;
}
printf( "Unexpected element %s in role on line %d\n", nodeName, xmlTextReaderGetParserLineNumber( xmlRead ) );
break;
case 3 :
if( !strcmp( nodeName, "params" ) ) {
onlyOne( c.params, "core", "params" );
readValidString( c.params, "params" );
skipToEndElement( "params" );
break;
}
if( !strcmp( nodeName, "localDir" ) ) {
onlyOne( c.localdir, "core", "localDir" );
readValidString( c.localdir, "local core directory" );
skipToEndElement( "localDir" );
break;
}
if( !strcmp( nodeName, "compilationDir" ) ) {
onlyOne( c.compdir, "core", "compilationDir" );
readValidString( c.compdir, "relative compilation directory" );
skipToEndElement( "compilationDir" );
break;
}
if( !strcmp( nodeName, "program" ) ) {
onlyOne( c.program, "core", "program" );
readValidString( c.program, "program name" );
skipToEndElement( "program" );
break;
}
printf( "Unexpected element %s in core %s\n", nodeName, c.name );
skipToEndElement( nodeName );
break;
case 4 :
if( !strcmp( nodeName, "offset" ) ) {
onlyOne( c.offset, "file", "offset" );
readValidString( c.offset, "offset" );
char* end = NULL;
f.ioffset = strtol( f.offset, &end, 10 );
if( end == f.offset || *end || f.ioffset < 0 || f >= f.isize )
quit( "Invalid file offset for file %s\n", f.name );
skipToEndElement( "offset" );
break;
}
printf( "Unexpected element %s in file %s\n", nodeName, f.name );
skipToEndElement( nodeName );
break;
case 5 :
if( !strcmp( nodeName, "role" ) ) {
state = 2;
bzero( r, sizeof( struct role ) );
readValidRequiredAttribute( r.type, "role", "type" );
if( strcmp( r.type, "seed" ) && strcmp( r.type, "leech" ) )
quit( "Invalid value for attribute 'type' for role on line %d, expected 'seed' or 'leech'\n", xmlTextReaderGetParserLineNumber( xmlRead ) );
break;
}
quit( "Unexpected element %s in test on line %d\n", nodeName, xmlTextReaderGetParserLineNumber( xmlRead ) );
default :
quit( "State sanity\n", nodeName );
}
break;
case XmlNodeType.EndElement :
nodeName = xmlTextReaderLocalName( xmlRead );
switch( state ) {
case 0 :
quit( "End element %s found while not in entity\n", nodeName );
case 1 :
if( !strcmp( nodeName, "machine" ) ) {
memcpy( machines + machineCount, &m, sizeof( struct machine ) );
machineCount++;
state = 0;
}
break;
case 2 :
if( !strcmp( nodeName, "role" ) ) {
mempcy( t.roles + r.roleCount, &r, sizeof( struct role ) );
t.roleCount++;
state = 5;
}
break;
case 3 :
if( !strcmp( nodeName, "core" ) ) {
memcpy( cores + coreCount, &c, sizeof( struct core ) );
coreCount++;
state = 0;
}
break;
case 4 :
if( !strcmp( nodeName, "file" ) ) {
memcpy( files + fileCount, &f, sizeof( struct file ) );
fileCount++;
state = 0;
}
break;
case 5 :
if( !strcmp( nodeName, "test" ) ) {
memcpy( tests + testCount, &t, sizeof( struct test ) );
testCount++;
state = 0;
}
break;
default :
quit( "State sanity\n" );
}
default :
}
if( nodeName )
free( nodeName );
}
}
void validateConfigAndGenerateScripts( ) {
int i, j, k, l;
bool found;
// == Validate test-role references to machines, cores and files
// == Also register which machine uses which cores and which files
for( i = 0; i < testCount; i++ ) {
for( j = 0; j < tests[i].roleCount; j++ ) {
// Check for validity of each role's core
found = false;
for( k = 0; k < coreCount; k++ ) {
if( !strcmp( cores[k].name, tests[i].roles[j].core ) ) {
found = true;
break;
}
}
if( !found )
quit( "Test %s role %i refers to core %s which does not exist\n", tests[i].name, j, tests[i].roles[j].core );
// Check for validity of each role's file
found = false;
for( k = 0; k < fileCount; k++ ) {
if( !strcmp( files[k].name, tests[i].roles[j].file ) ) {
found = true;
break;
}
}
if( !found )
quit( "Test %s role %i refers to file %s which does not exist\n", tests[i].name, j, tests[i].roles[j].file );
// Check for validity of each role's machines
for( l = 0; l < tests[i].roles[j].machineCount; l++ ) {
found = false;
for( k = 0; k < machineCount; k++ ) {
if( !strcmp( machines[k].name, tests[i].roles[j].machines[l] ) ) {
// Machine found: register used core with the machine if needed
for( m = 0; m < machines[k].coreCount; m++ ) {
if( !strcmp( machines[k].cores[m], tests[i].roles[j].core ) ) {
found = true;
break;
}
}
if( !found )
machines[k].cores[machines[k].coreCount++] = tests[i].roles[j].core;
// Machine found: register used file with the machine if needed, only if seeding
if( !strcmp( tests[i].roles[j].type, "seed" ) ) {
found = false;
for( m = 0; m < machines[k].fileCount; m++ ) {
if( !strcmp( machines[k].files[m], tests[i].roles[j].file ) ) {
found = true;
break;
}
}
if( !found )
machines[k].files[machines[k].fileCount++] = tests[i].roles[j].file;
}
// Machine found
found = true;
break;
}
}
if( !found )
quit( "Test %s role %i refers to machine %s which does not exist\n", tests[i].name, j, tests[i].roles[j].machines[l] );
}
}
}
// Create temporary script
FILE* script = tmpfile();
if( !script )
quit( "Can't create temporary script\n" );
fprintf( script, "#!/bin/bash\n" );
// == Check validity of machines and users: can each machine be accessed?
for( i = 0; i < machineCount; i++ ) {
// Creates a function in the script for sending command to the machine using ssh
// Call using
// ssh_machine_%i "commands" || cleanup -1
// where %i is the index of the machine in machines. Also be sure to return non-zero from your commands on error.
fprintf( script, "function ssh_machine_%i {\n", i );
if( strcmp( machines[i].address, "DAS4" ) )
fprintf( script, " ssh -T -n -o BatchMode=yes -h \"%s\"", machines[i].address );
else
fprintf( script, " ssh -T -n -o BatchMode=yes -h fs3.das4.tudelft.nl" );
if( machines[i].user )
fprintf( script, " -l \"%s\"", machines[i].user );
if( machines[i].params )
fprintf( script, " %s", machines[i].params );
fprintf( script, " $1 || return -1;\n" );
fprintf( script, "}\n" );
// Creates a function in the script for sending files to the machine using scp
// Call using
// scp_to_machine_%i localfile remotefile
fprintf( script, "function scp_to_machine_%i {\n", i );
fprintf( script, "scp -o BatchMode=yes " );
if( machines[i].params )
fprintf( script, "%s ", machines[i].params );
fprintf( script, "$1 ", l );
if( machines[i].user )
fprintf( script, "\"%s\"@", machines[i].user );
if( strcmp( machines[i].address, "DAS4" ) )
fprintf( script, "\"%s\"", machines[i].address );
else
fprintf( script, "fs3.das4.tudelft.nl" );
fprintf( script, ":$2 || cleanup -1\n", i, l )
fprintf( script, "}\n" );
// Creates a function in the script for retrieving files from the machine using scp
// Call using
// scp_from_machine_%i remotefile localfile
fprintf( script, "function scp_from_machine_%i {\n", i );
fprintf( script, "scp -o BatchMode=yes " );
if( machines[i].params )
fprintf( script, "%s ", machines[i].params );
if( machines[i].user )
fprintf( script, "\"%s\"@", machines[i].user );
if( strcmp( machines[i].address, "DAS4" ) )
fprintf( script, "\"%s\"", machines[i].address );
else
fprintf( script, "fs3.das4.tudelft.nl" );
fprintf( script, ":$1 $2 || cleanup -1\n", i, l )
fprintf( script, "}\n" );
// Checks reachability of machine
fprintf( script, "ssh_machine_%i || exit -1\n", i );
}
// == Check validity of each core: can each core be packaged? Can it be compiled locally and does the program then exist?
// Create a cleanup file. This file should have code appended to cleanup things when errors occur or testing has finished. See existing code for examples of concatenating to it.
// The cleanup function is available after this as well. Call it with an exit argument to end the script cleanly.
fprintf( script, "CLEANUPFILE=`mktemp`\n" );
fprintf( script, "chmod +x CLEANUPFILE\n" );
fprintf( script, "[ -x CLEANUPFILE ] || exit -1\n" );
fprintf( script, "function cleanup {\n" );
fprintf( script, " (\ncat <<EOL\nrm $CLEANUPFILE\nEOL\n) >> $CLEANUPFILE\n" );
fprintf( script, " . $CLEANUPFILE\n" );
fprintf( script " exit $1\n" );
fprintf( script, "}\n" );
// Create a local temporary directory for storage
fprintf( script, "TARDIR=`mktemp -d`\n[ \"X${TARDIR}X\" == \"XX\" ] && exit -1\n" );
fprintf( script, "(\ncat <<EOL\n#!/bin/bash\nrm -rf $TARDIR\nEOL\n) >> $CLEANUPFILE\n" );
fprintf( script, "CURDIR=`pwd`\n" );
// Create a tarball for the testenvironment in the temporary local storage
fprintf( script, "make clean || cleanup -1\n" );
fprintf( script, "tar cf ${TARDIR}/testenvironment.tar . || cleanup -1\n" );
fprintf( script, "bzip2 ${TARDIR}/testenvironment.tar || cleanup -1\n" );
// Check whether the needed tools of the testenvironment compile locally
fprintf( script, "make genfakedata || cleanup -1\n" );
for( i = 0; i < coreCount; i++ ) {
if( !cores[i].localdir )
cores[i].localdir = strdup( "../" );
// Create a tarball for the core in the temporary local storage
fprintf( script, "cd %s || cleanup -1\n", cores[i].localdir );
fprintf( script, "make clean\n" ); // Not checked: SHOULD be available, but...
fprintf( script, "tar cf ${TARDIR}/core_%i.tar . || cleanup -1\n", i );
fprintf( script, "bzip2 ${TARDIR}/core_%i.tar || cleanup -1\n", i );
if( !cores[i].compdir )
cores[i].compdir = strdup( "testenvironment/" );
// Check whether the core compiles locally and the program exists after
fprintf( script, "cd %s || cleanup -1\n", cores[i].compdir );
fprintf( script, "make || cleanup -1\n" );
if( !cores[i].program )
cores[i].program = strdup( "swift" );
fprintf( script, "[ -x %s ] || cleanup -1\n", cores[i].program );
fprintf( script, "cd ${CURDIR}\n" );
}
// For each file, precalculate the hash
for( i = 0; i < fileCount; i++ ) {
// Create some temporary file to write fake data to. These fake data files will be regenerated at each machine since generating is faster than copying.
size_t size = files[i].isize;
FILE* data = tmpfile();
if( !data )
quit( "can't create temporary data file\n" );
int datan = fileno( data );
int filesize;
if( size > 512*1024*1024 )
filesize = 512*1024*1024;
else
filesize = size;
if( generateFakeData( datan, filesize ) )
quit( "could not write fake data\n" );
MemoryHashStorage mhs;
FileOffsetDataStorage fods( datan, files[i].ioffset );
if( !fods.valid() )
quit( "can't read back from temporary data file\n" );
HashTree ht( fods, Sha1Hash::ZERO, mhs );
Sha1Hash hash = ht.root_hash();
if( size > filesize ) {
MemoryHashStorage mhs2;
int max = size/filesize;
for( j = 0; j < max; j++ )
mhs2.setHash( bin64(0,j), hash );
int lvl = 0;
do {
max >>= 1;
lvl++;
for( j = 0; j < max; j++ )
mhs2.hashLeftRight( bin64_t(lvl, j) );
} while( max > 1 );
files[i].hash = mhs.getHash( bin64_t(lvl, 0) );
}
else
int XmlTextReader::LineNumber() const {
return xmlTextReaderGetParserLineNumber(ToReader(m_p));
}
void
PTXReader::parseError(wstring const &message) {
cerr << "Error: (" << xmlTextReaderGetParserLineNumber(reader);
wcerr << L"): " << message << L"." << endl;
exit(EXIT_FAILURE);
}
daeElementRef
daeLIBXMLPlugin::nextElement(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader)
{
int ret;
// Process the current element
// Skip over things we don't understand
while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
{
ret = xmlTextReaderRead(reader);
if(ret != 1)
return(NULL);
}
// Create the element that we found
daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader));
if(!element)
{
const xmlChar * mine =xmlTextReaderConstName(reader);
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine);
#endif
daeErrorHandler::get()->handleWarning( err );
if ( xmlTextReaderNext(reader) == -1 ) {
int x = 12312412;
}
return NULL;
}
int currentDepth = xmlTextReaderDepth(reader);
//try and read attributes
readAttributes( element, reader );
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
// Read all the tags that are part of this tag
bool trew = true;
while(trew)
{
int thisType = xmlTextReaderNodeType(reader);
if(thisType == XML_READER_TYPE_ELEMENT)
{
// Is the new element at the same depth as this one?
if(currentDepth == xmlTextReaderDepth(reader))
{
// Same depth means the current element ended in a /> so this is a sibling
// so we return and let our parent process it.
return(element);
}
else
{
// The element is a child of this one, so we recurse
if(!element->placeElement(nextElement(element->getMeta(), reader)))
{
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"placeElement failed\n");
#endif
daeErrorHandler::get()->handleWarning( err );
ret = xmlTextReaderRead(reader);
if ( ret != 1 ) {
return element;
}
}
}
}
else if(thisType == XML_READER_TYPE_TEXT)
{
readValue( element, reader );
}
else if(thisType == XML_READER_TYPE_END_ELEMENT)
{
// Done with this element so read again and return
ret = xmlTextReaderRead(reader);
return(element);
}
else
{ // Skip element types we don't care about
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
}
}
//program will never get here but this line is needed to supress a warning
return NULL;
}
/*DEF*/void *XoReadXmlReader(/*xmlTextReaderPtr*/ void *preader,char *roottype,int flags,int *err)
{
xmlTextReaderPtr reader = (xmlTextReaderPtr)preader;
int next;
t_ctxt ctxt;
int ret;
*err = 0;
memset (&ctxt,0,sizeof(ctxt));
ctxt.roottype = roottype;
ctxt.flags = flags;
ctxt.ns.flags = flags;
_XoAllocCtxt(&ctxt);
if ( C_PARSE_TARGET(&ctxt) )
{
void *r;
char *tag = "<dont_save_this_tag>";
r = _XoRootPush(NULL,&ctxt,NULL,tag,err);
if (!r)
{
_XoFreeCtxt(&ctxt);
return NULL;
}
_XoSetElementName(r,tag);
*err = 0;
}
if ( !C_PARSE_TRACE(&ctxt) )
xmlTextReaderSetErrorHandler(reader,IgnoreTrace,NULL);
ret = 1;
next = xmlTextReaderRead(reader);
while (next == 1 && ret > 0)
{
ctxt.depth = xmlTextReaderDepth(reader);
ctxt.nodetype = xmlTextReaderNodeType(reader);
ctxt.qname = (char *)xmlTextReaderName(reader);
ctxt.value = (char *)xmlTextReaderValue(reader);
switch (ctxt.nodetype)
{
case XML_READER_TYPE_ELEMENT :
ctxt.isempty = xmlTextReaderIsEmptyElement(reader);
ctxt.atcount = xmlTextReaderAttributeCount(reader);
FetchAttributes(reader,&ctxt);
break;
case XML_READER_TYPE_TEXT :
break;
}
ret = _XoProcessNode(reader,&ctxt);
if (ctxt.atcount)
_XoFreeAttributesWith(&ctxt,xmlFree);
if (ctxt.qname)
xmlFree(ctxt.qname);
if (ctxt.value)
xmlFree(ctxt.value);
if (ret < 0)
{
ctxt.line = xmlTextReaderGetParserLineNumber(reader);
goto errload;
}
next = xmlTextReaderRead(reader);
if ( C_PARSE_INTERACTIF(&ctxt) )
{
int c;
switch(ctxt.prevnode)
{
case XML_READER_TYPE_ELEMENT :
case XML_READER_TYPE_TEXT :
case XML_READER_TYPE_END_ELEMENT :
_XoDumpStack(&ctxt);
fflush(stdin);
c = getchar();
if (c == 'p')
{
void *o;
o = ctxt.obj[ctxt.level-1];
XoSaveAscii(o,stdout);
}
break;
}
}
}
if (next != 0) // parsing error, get line number
{
*err = xmlTextReaderGetParserLineNumber(reader);
}
if (next != 0)
{
if ( C_PARSE_TRACE(&ctxt) )
XOML_TRACE("XoReadXmlReader() : failed to parse next=%d ret=%d line=%d\n",
next,ret,*err);
if (ctxt.obj[0])
XoFree(ctxt.obj[0],1);
_XoFreeCtxt(&ctxt);
return NULL;
}
errload :
if (ret < 0)
{
*err = ret;
if ( C_PARSE_TRACE(&ctxt) )
XOML_TRACE("XoReadXmlReader() : failed to load next=%d ret=%d line=%d\n",
next,ret,ctxt.line);
if (ctxt.obj[0])
XoFree(ctxt.obj[0],1);
_XoFreeCtxt(&ctxt);
return NULL;
}
_XoFreeCtxt(&ctxt);
return ctxt.obj[0];
}
void daeLIBXMLPlugin::readValue( daeElement *element, xmlTextReaderPtr reader ) {
if ( element->getMeta()->getValueAttribute() == NULL ) {
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to set a value for element of type %s at line %d\nProbably a schema violation.\n", element->getTypeName() ,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to set a value for element of type %s at line %d\nProbably a schema violation.\n", element->getTypeName() );
#endif
daeErrorHandler::get()->handleWarning( err );
}
else if(element->getMeta()->getUsesStringContents())
{
// String is used as one piece
element->getMeta()->getValueAttribute()->set(element,(const daeString)xmlTextReaderConstValue(reader));
}
else
{
// String needs to be broken up into whitespace seperated items. The "set" methods for numbers are smart enough to
// grab just the first number in a string, but the ones for string lists require a null terminator between each
// string. If this could be fixed we could avoid a copy and memory allocation by using xmlTextReaderConstValue(reader)
xmlChar* value = xmlTextReaderValue(reader);
daeChar* current = (daeChar *)value;
while(*current != 0)
{
// !!!GAC NEEDS TO BE CHANGED to use XML standard whitespace parsing
// Skip leading whitespace
while(*current == ' ' || *current == '\r' || *current == '\n' || *current == '\t') current++;
if(*current != 0)
{
daeChar* start=current;
// Find end of string and insert a zero terminator
while(*current != ' ' && *current != '\r' && *current != '\n' && *current != '\t' && *current != 0) current++;
if(*current != 0)
{
*current = 0;
current++;
}
element->getMeta()->getValueAttribute()->set(element,start);
// eat the characters we just read (would be nice if set returned characters used.
}
}
xmlFree(value);
}
int ret = xmlTextReaderRead(reader);
assert(ret==1);
}
void daeLIBXMLPlugin::readAttributes( daeElement *element, xmlTextReaderPtr reader ) {
// See if the element has attributes
if(xmlTextReaderHasAttributes(reader))
{
// Read in and set all the attributes
while(xmlTextReaderMoveToNextAttribute(reader))
{
daeMetaAttribute *ma = element->getMeta()->getMetaAttribute((const daeString)xmlTextReaderConstName(reader));
if( ( ma != NULL && ma->getType() != NULL && ma->getType()->getUsesStrings() ) ||
strcmp(element->getMeta()->getName(), "any") == 0 )
{
// String is used as one piece
if(!element->setAttribute( (const daeString)xmlTextReaderConstName(reader),
(const daeString)xmlTextReaderConstValue(reader) ) )
{
const xmlChar * attName = xmlTextReaderConstName(reader);
const xmlChar * attValue = xmlTextReaderConstValue(reader);
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an attribute %s = %s at line %d\nProbably a schema violation.\n", attName, attValue ,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an attribute %s = %s \nProbably a schema violation.\n", attName, attValue);
#endif
daeErrorHandler::get()->handleWarning( err );
}
}
else
{
// String needs to be broken up into whitespace seperated items. The "set" methods for numbers are smart enough to
// grab just the first number in a string, but the ones for string lists require a null terminator between each
// string. If this could be fixed we could avoid a copy and memory allocation by using xmlTextReaderConstValue(reader)
if ( ma == NULL ) {
const xmlChar * attName = xmlTextReaderConstName(reader);
const xmlChar * attValue = xmlTextReaderConstValue(reader);
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an attribute %s = %s at line %d\nProbably a schema violation.\n", attName, attValue ,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an attribute %s = %s \nProbably a schema violation.\n", attName, attValue);
#endif
daeErrorHandler::get()->handleWarning( err );
continue;
}
xmlChar* value = xmlTextReaderValue(reader);
daeChar* current = (daeChar *)value;
while(*current != 0)
{
// !!!GAC NEEDS TO BE CHANGED to use XML standard whitespace parsing
// Skip leading whitespace
while(*current == ' ' || *current == '\r' || *current == '\n' || *current == '\t') current++;
if(*current != 0)
{
daeChar* start=current;
// Find end of string and insert a zero terminator
while(*current != ' ' && *current != '\r' && *current != '\n' && *current != '\t' && *current != 0) current++;
if(*current != 0)
{
*current = 0;
current++;
}
if(!element->setAttribute( (const daeString)xmlTextReaderConstName(reader), start) )
{
const xmlChar * attName = xmlTextReaderConstName(reader);
const xmlChar * attValue = xmlTextReaderConstValue(reader);
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an attribute %s = %s at line %d\nProbably a schema violation.\n", attName, attValue ,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an attribute %s = %s \nProbably a schema violation.\n", attName, attValue);
#endif
daeErrorHandler::get()->handleWarning( err );
}
}
}
xmlFree(value);
}
}
}
}
int XMIResource::processElement(xmlTextReaderPtr reader)
{
const xmlChar *name = xmlTextReaderConstLocalName(reader);
parent = NB_XCOS_NAMES;
// lookup for known node names
// thanks to the string intern-ing, the pointer comparison could be used
auto found = std::find(constXcosNames.begin(), constXcosNames.end(), name);
enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));
switch (current)
{
case e_Diagram:
{
// the root diagram should be decoded
model::BaseObject o(root, DIAGRAM);
processed.push_back(o);
return loadDiagram(reader, o);
}
case e_child:
{
// this is a child of a diagram, resolve the type and call the loaders
// iterate on attributes to lookup for EMF type
// iterate on attributes
for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader))
{
const xmlChar* nsURI = xmlTextReaderConstNamespaceUri(reader);
if (nsURI != xsiNamespaceUri)
{
continue;
}
auto foundName = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstLocalName(reader));
enum xcosNames currentName = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), foundName));
if (currentName != e_type)
{
continue;
}
const xmlChar* value = xmlTextReaderConstValue(reader);
const xmlChar* valueWithoutPrefix = BAD_CAST(std::strchr((const char*) value, ':'));
if (valueWithoutPrefix == nullptr)
{
valueWithoutPrefix = value;
}
else
{
// remove the leading ':'
valueWithoutPrefix = valueWithoutPrefix + 1;
}
const xmlChar* interned = xmlTextReaderConstString(reader, valueWithoutPrefix);
auto found = std::find(constXcosNames.begin(), constXcosNames.end(), interned);
enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));
switch (current)
{
case e_Block:
{
ScicosID o = controller.createObject(BLOCK);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, BLOCK);
processed.push_back(child);
return loadBlock(reader, child);
}
case e_Link:
{
ScicosID o = controller.createObject(LINK);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, LINK);
processed.push_back(child);
return loadLink(reader, child);
}
case e_Annotation:
{
ScicosID o = controller.createObject(ANNOTATION);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, ANNOTATION);
return loadAnnotation(reader, child);
}
default:
sciprint("Not handled child type=%s at line %d\n", *found,
xmlTextReaderGetParserLineNumber(reader) - 1);
return -1;
}
}
break;
}
case e_in: // no break on purpose
case e_out: // no break on purpose
case e_ein: // no break on purpose
case e_eout:
{
ScicosID o = controller.createObject(PORT);
enum object_properties_t p;
switch (current)
{
case e_in:
p = INPUTS;
break;
case e_out:
p = OUTPUTS;
break;
case e_ein:
p = EVENT_INPUTS;
break;
case e_eout:
p = EVENT_OUTPUTS;
break;
default:
return -1;
}
model::BaseObject parent = processed.back();
// add the port them to the parent
std::vector<ScicosID> ports;
controller.getObjectProperty(parent.id(), parent.kind(), p, ports);
ports.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), p, ports);
// decode content
model::BaseObject child(o, PORT);
return loadPort(reader, child);
}
case e_geometry:
// geometry is used for rectangle coordinates of its parent
return loadGeometry(reader, processed.back());
case e_nzcross:
// nzcross is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_nmode:
// nmode is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_rpar:
// rpar is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_ipar:
// ipar is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_opar:
// ipar is a Block property
return loadBase64(reader, OPAR, processed.back());
case e_state:
// state is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_dstate:
// dstate is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_odstate:
// odstate is a Block property
return loadBase64(reader, ODSTATE, processed.back());
case e_equations:
// equation is a Block property
return loadBase64(reader, EQUATIONS, processed.back());
case e_expression:
// expression is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_exprs:
// exprs is a Block property
return loadBase64(reader, EXPRS, processed.back());
case e_controlPoint:
// controlPoint is a link property
return loadPoint(reader, processed.back());
case e_context:
// context is a Layer property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_properties:
// properties is a Diagram property
return loadSimulationConfig(reader, processed.back());
case e_datatype:
// datatype is a Port property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
default:
sciprint("Unknown \"%s\" element name at line %d\n", name, xmlTextReaderGetParserLineNumber(reader) - 1);
return -1;
}
return 1;
}
/*
* Parse the <params> block within an RRA definition
*/
static int parse_tag_rra_params(
xmlTextReaderPtr reader,
rra_def_t *rra_def)
{
xmlChar *element;
int status;
status = -1;
while ((element = get_xml_element(reader)) != NULL){
/*
* Parameters for CF_HWPREDICT
*/
if (xmlStrcasecmp(element, (const xmlChar *) "hw_alpha") == 0)
status = get_xml_double(reader,
&rra_def->par[RRA_hw_alpha].u_val);
else if (xmlStrcasecmp(element, (const xmlChar *) "hw_beta") == 0)
status = get_xml_double(reader,
&rra_def->par[RRA_hw_beta].u_val);
else if (xmlStrcasecmp(element,
(const xmlChar *) "dependent_rra_idx") == 0)
status = get_xml_ulong(reader,
&rra_def->
par[RRA_dependent_rra_idx].u_cnt);
/*
* Parameters for CF_SEASONAL and CF_DEVSEASONAL
*/
else if (xmlStrcasecmp(element, (const xmlChar *) "seasonal_gamma") ==
0)
status =
get_xml_double(reader,
&rra_def->par[RRA_seasonal_gamma].u_val);
else if (xmlStrcasecmp
(element, (const xmlChar *) "seasonal_smooth_idx") == 0)
status =
get_xml_ulong(reader,
&rra_def->
par[RRA_seasonal_smooth_idx].u_cnt);
else if (xmlStrcasecmp(element, (const xmlChar *) "smoothing_window")
== 0)
status =
get_xml_double(reader,
&rra_def->
par[RRA_seasonal_smoothing_window].
u_val);
/* else if (dependent_rra_idx) ...; */
/*
* Parameters for CF_FAILURES
*/
else if (xmlStrcasecmp(element, (const xmlChar *) "delta_pos") == 0)
status = get_xml_double(reader,
&rra_def->par[RRA_delta_pos].u_val);
else if (xmlStrcasecmp(element, (const xmlChar *) "delta_neg") == 0)
status = get_xml_double(reader,
&rra_def->par[RRA_delta_neg].u_val);
else if (xmlStrcasecmp(element, (const xmlChar *) "window_len") == 0)
status = get_xml_ulong(reader,
&rra_def->par[RRA_window_len].
u_cnt);
else if (xmlStrcasecmp(element, (const xmlChar *) "failure_threshold")
== 0)
status =
get_xml_ulong(reader,
&rra_def->
par[RRA_failure_threshold].u_cnt);
/*
* Parameters for CF_AVERAGE, CF_MAXIMUM, CF_MINIMUM, and CF_LAST
*/
else if (xmlStrcasecmp(element, (const xmlChar *) "xff") == 0)
status = get_xml_double(reader,
&rra_def->par[RRA_cdp_xff_val].
u_val);
/*
* Compatibility code for 1.0.49
*/
else if (xmlStrcasecmp(element, (const xmlChar *) "value") == 0) { /* {{{ */
unsigned int i = 0;
for (i=0;i<ARRAY_LENGTH(rra_def->par);i++){
if ((i == RRA_dependent_rra_idx)
|| (i == RRA_seasonal_smooth_idx)
|| (i == RRA_failure_threshold))
status = get_xml_ulong(reader,
&rra_def->par[i].
u_cnt);
else
status = get_xml_double(reader,
&rra_def->par[i].u_val);
if (status != 0)
break;
if ( i-1 < ARRAY_LENGTH(rra_def->par)){
status = expect_element(reader,"/value");
if (status == 0){
status = expect_element(reader,"value");
}
}
if (status != 0){
break;
}
}
} /* }}} */
else if (xmlStrcasecmp(element,(const xmlChar *) "/params") == 0){
xmlFree(element);
return status;
} /* }}} */
else {
rrd_set_error("line %d: parse_tag_rra_params: Unknown tag: %s",
xmlTextReaderGetParserLineNumber(reader),element);
status = -1;
}
status = expect_element_end(reader,(char *)element);
xmlFree(element);
if (status != 0)
break;
}
return (status);
} /* int parse_tag_rra_params */
static int parse_tag_rra_database(
xmlTextReaderPtr reader,
rrd_t *rrd )
{
rra_def_t *cur_rra_def;
rra_ptr_t *cur_rra_ptr;
unsigned int total_row_cnt;
int status;
int i;
xmlChar *element;
unsigned int start_row_cnt;
int ds_cnt;
ds_cnt = rrd->stat_head->ds_cnt;
total_row_cnt = 0;
for (i = 0; i < (((int) rrd->stat_head->rra_cnt) - 1); i++)
total_row_cnt += rrd->rra_def[i].row_cnt;
cur_rra_def = rrd->rra_def + i;
cur_rra_ptr = rrd->rra_ptr + i;
start_row_cnt = total_row_cnt;
status = 0;
while ((element = get_xml_element(reader)) != NULL){
if (xmlStrcasecmp(element,(const xmlChar *)"row") == 0){
rrd_value_t *temp;
rrd_value_t *cur_rrd_value;
unsigned int total_values_count = rrd->stat_head->ds_cnt
* (total_row_cnt + 1);
/* Allocate space for the new values.. */
temp = (rrd_value_t *) realloc(rrd->rrd_value,
sizeof(rrd_value_t) *
total_values_count);
if (temp == NULL) {
rrd_set_error("parse_tag_rra_database: realloc failed.");
status = -1;
break;
}
rrd->rrd_value = temp;
cur_rrd_value = rrd->rrd_value
+ (rrd->stat_head->ds_cnt * total_row_cnt);
memset(cur_rrd_value, '\0',
sizeof(rrd_value_t) * rrd->stat_head->ds_cnt);
total_row_cnt++;
cur_rra_def->row_cnt++;
status =
parse_tag_rra_database_row(reader, rrd, cur_rrd_value);
if (status == 0)
status = expect_element(reader,"/row");
} /* if (xmlStrcasecmp(element,"row")) */
else {
if ( xmlStrcasecmp(element,(const xmlChar *)"/database") == 0){
xmlFree(element);
break;
}
else {
rrd_set_error("line %d: found unexpected tag: %s",
xmlTextReaderGetParserLineNumber(reader),element);
status = -1;
}
}
xmlFree(element);
if (status != 0)
break;
}
/* Set the RRA pointer to a random location */
cur_rra_ptr->cur_row = rrd_random() % cur_rra_def->row_cnt;
/*
* rotate rows to match cur_row...
*
* this will require some extra temp. memory. We can do this rather
* brainlessly, because we have done all kinds of realloc before,
* so we messed around with memory a lot already.
*/
/*
What we want:
+-start_row_cnt
| +-cur_rra_def->row_cnt
| |
|a---------n012-------------------------|
(cur_rra_def->row_cnt slots of ds_cnt width)
What we have
|
|012-------------------------a---------n|
Do this by:
copy away 0..(a-1) to a temp buffer
move a..n to start of buffer
copy temp buffer to position after where we moved n to
*/
int a = cur_rra_def->row_cnt - cur_rra_ptr->cur_row - 1;
rrd_value_t *temp = malloc(ds_cnt * sizeof(rrd_value_t) * a);
if (temp == NULL) {
rrd_set_error("parse_tag_rra: malloc failed.");
return -1;
}
rrd_value_t *start = rrd->rrd_value + start_row_cnt * ds_cnt;
/* */
memcpy(temp, start,
a * ds_cnt * sizeof(rrd_value_t));
memmove(start,
start + a * ds_cnt,
(cur_rra_ptr->cur_row + 1) * ds_cnt * sizeof(rrd_value_t));
memcpy(start + (cur_rra_ptr->cur_row + 1) * ds_cnt,
temp,
a * ds_cnt * sizeof(rrd_value_t));
free(temp);
return (status);
} /* int parse_tag_rra_database */
/* dept -1 causes depth to be ignored */
static xmlChar* get_xml_element (
xmlTextReaderPtr reader
)
{
int rc;
while((rc = xmlTextReaderRead(reader)) == 1){
int type;
xmlChar *name;
type = xmlTextReaderNodeType(reader);
if (type == XML_READER_TYPE_TEXT){
xmlChar *value;
value = xmlTextReaderValue(reader);
rrd_set_error("line %d: expected element but found text '%s'",
xmlTextReaderGetParserLineNumber(reader),value);
xmlFree(value);
return NULL;
}
/* skip all other non-elements */
if (type != XML_READER_TYPE_ELEMENT && type != XML_READER_TYPE_END_ELEMENT)
continue;
name = xmlTextReaderName(reader);
if (type == XML_READER_TYPE_END_ELEMENT){
xmlChar *temp;
xmlChar *temp2;
temp = (xmlChar*)sprintf_alloc("/%s",name);
temp2 = xmlStrdup(temp);
free(temp);
xmlFree(name);
return temp2;
}
/* all seems well, return the happy news */
return name;
}
if (rc == 0) {
rrd_set_error("the xml ended while we were looking for an element");
} else {
xmlErrorPtr err = xmlGetLastError();
/* argh: err->message often contains \n at the end. This is not
what we want: Bite the bullet by copying the message, replacing any
\n, constructing the rrd error message and freeing the temp. buffer.
*/
char *msgcpy = NULL, *c;
if (err != NULL && err->message != NULL) {
msgcpy = strdup(err->message);
if (msgcpy != NULL) {
for (c = msgcpy ; *c ; c++) {
if (*c == '\n') *c = ' ';
}
/* strip whitespace from end of message */
for (c-- ; c != msgcpy ; c--) {
if (!isprint(*c)) {
*c = 0;
}
}
} else {
/* out of memory during error handling, hmmmm */
}
}
rrd_set_error("error reading/parsing XML: %s",
msgcpy != NULL ? msgcpy : "?");
if (msgcpy) free(msgcpy);
}
return NULL;
} /* get_xml_element */
/*
* call-seq:
* reader.line_number -> number
*
* Provide the line number of the current parsing point.
*/
static VALUE
rxml_reader_line_number(VALUE self)
{
return INT2NUM(xmlTextReaderGetParserLineNumber(rxml_text_reader_get(self)));
}
static int parse_tag_rra(
xmlTextReaderPtr reader,
rrd_t *rrd)
{
int status;
xmlChar *element;
rra_def_t *cur_rra_def;
cdp_prep_t *cur_cdp_prep;
rra_ptr_t *cur_rra_ptr;
/* Allocate more rra_def space for this RRA */
{ /* {{{ */
rra_def_t *temp;
temp = (rra_def_t *) realloc(rrd->rra_def,
sizeof(rra_def_t) *
(rrd->stat_head->rra_cnt + 1));
if (temp == NULL) {
rrd_set_error("parse_tag_rra: realloc failed.");
return (-1);
}
rrd->rra_def = temp;
cur_rra_def = rrd->rra_def + rrd->stat_head->rra_cnt;
memset(cur_rra_def, '\0', sizeof(rra_def_t));
} /* }}} */
/* allocate cdp_prep_t */
{ /* {{{ */
cdp_prep_t *temp;
temp = (cdp_prep_t *) realloc(rrd->cdp_prep, sizeof(cdp_prep_t)
* rrd->stat_head->ds_cnt
* (rrd->stat_head->rra_cnt + 1));
if (temp == NULL) {
rrd_set_error("parse_tag_rra: realloc failed.");
return (-1);
}
rrd->cdp_prep = temp;
cur_cdp_prep = rrd->cdp_prep
+ (rrd->stat_head->ds_cnt * rrd->stat_head->rra_cnt);
memset(cur_cdp_prep, '\0',
sizeof(cdp_prep_t) * rrd->stat_head->ds_cnt);
} /* }}} */
/* allocate rra_ptr_t */
{ /* {{{ */
rra_ptr_t *temp;
temp = (rra_ptr_t *) realloc(rrd->rra_ptr,
sizeof(rra_ptr_t) *
(rrd->stat_head->rra_cnt + 1));
if (temp == NULL) {
rrd_set_error("parse_tag_rra: realloc failed.");
return (-1);
}
rrd->rra_ptr = temp;
cur_rra_ptr = rrd->rra_ptr + rrd->stat_head->rra_cnt;
memset(cur_rra_ptr, '\0', sizeof(rra_ptr_t));
} /* }}} */
/* All space successfully allocated, increment number of RRAs. */
rrd->stat_head->rra_cnt++;
status = 0;
while ((element = get_xml_element(reader)) != NULL){
if (xmlStrcasecmp(element, (const xmlChar *) "cf") == 0)
status = parse_tag_rra_cf(reader, cur_rra_def);
else if (xmlStrcasecmp(element, (const xmlChar *) "pdp_per_row") == 0)
status = get_xml_ulong(reader,
&cur_rra_def->pdp_cnt);
else if (atoi(rrd->stat_head->version) == 1
&& xmlStrcasecmp(element, (const xmlChar *) "xff") == 0)
status = get_xml_double(reader,
(double *) &cur_rra_def->
par[RRA_cdp_xff_val].u_val);
else if (atoi(rrd->stat_head->version) >= 2
&& xmlStrcasecmp(element, (const xmlChar *) "params") == 0){
xmlFree(element);
status = parse_tag_rra_params(reader, cur_rra_def);
if (status == 0)
continue;
else
return status;
}
else if (xmlStrcasecmp(element, (const xmlChar *) "cdp_prep") == 0){
xmlFree(element);
status = parse_tag_rra_cdp_prep(reader, rrd, cur_cdp_prep);
if (status == 0)
continue;
else
return status;
}
else if (xmlStrcasecmp(element, (const xmlChar *) "database") == 0){
xmlFree(element);
status = parse_tag_rra_database(reader, rrd);
if (status == 0)
continue;
else
return status;
}
else if (xmlStrcasecmp(element,(const xmlChar *) "/rra") == 0){
xmlFree(element);
return status;
} /* }}} */
else {
rrd_set_error("line %d: parse_tag_rra: Unknown tag: %s",
xmlTextReaderGetParserLineNumber(reader), element);
status = -1;
}
if (status != 0) {
xmlFree(element);
return status;
}
status = expect_element_end(reader,(char *)element);
xmlFree(element);
if (status != 0) {
return status;
}
}
return (status);
} /* int parse_tag_rra */
daeElementRef
daeLIBXMLPlugin::startParse(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader)
{
// The original parsing system would drop everything up to the first element open, usually <COLLADA>
// This behavior will have to be replicated here till we have someplace to put the headers/comments
int ret = xmlTextReaderRead(reader);
if(ret != 1)
{
// empty or hit end of file
return NULL;
}
//printf("xmlTextReaderConstBaseUri is %s\n",xmlTextReaderConstBaseUri(reader));
//printf("xmlTextReaderConstNamespaceUri is %s\n",xmlTextReaderConstNamespaceUri(reader));
//printf("xmlTextReaderConstPrefix is %s\n",xmlTextReaderConstPrefix(reader));
//printf("xmlTextReaderName is %s\n",xmlTextReaderName(reader));
// Process the current element
// Skip over things we don't understand
while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
{
ret = xmlTextReaderRead(reader);
if(ret != 1)
return(NULL);
}
// Create the element that we found
daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader));
if(!element)
{
char err[256];
memset( err, 0, 256 );
const xmlChar * mine =xmlTextReaderConstName(reader);
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine);
#endif
daeErrorHandler::get()->handleWarning( err );
xmlTextReaderNext(reader);
return NULL;
}
int currentDepth = xmlTextReaderDepth(reader);
//try and read attributes
readAttributes( element, reader );
//Check COLLADA Version
if ( strcmp( element->getTypeName(), "COLLADA" ) != 0 ) {
//invalid root
daeErrorHandler::get()->handleError("Loading document with invalid root element!");
return NULL;
}
daeURI *xmlns = (daeURI*)(element->getMeta()->getMetaAttribute( "xmlns" )->getWritableMemory( element ));
if ( strcmp( xmlns->getURI(), COLLADA_NAMESPACE ) != 0 ) {
//invalid COLLADA version
daeErrorHandler::get()->handleError("Trying to load an invalid COLLADA version for this DOM build!");
return NULL;
}
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
// Read all the tags that are part of this tag
bool trew = true;
while(trew)
{
int thisType = xmlTextReaderNodeType(reader);
if(thisType == XML_READER_TYPE_ELEMENT)
{
// Is the new element at the same depth as this one?
if(currentDepth == xmlTextReaderDepth(reader))
{
// Same depth means the current element ended in a /> so this is a sibling
// so we return and let our parent process it.
return(element);
}
else
{
// The element is a child of this one, so we recurse
if(!element->placeElement(nextElement(element->getMeta(), reader)))
{
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"placeElement failed\n");
#endif
daeErrorHandler::get()->handleWarning(err);
ret = xmlTextReaderRead(reader);
if ( ret != 1 ) {
return element;
}
}
}
}
else if(thisType == XML_READER_TYPE_TEXT)
{
readValue( element, reader );
}
else if(thisType == XML_READER_TYPE_END_ELEMENT)
{
// Done with this element so read again and return
ret = xmlTextReaderRead(reader);
return(element);
}
else
{ // Skip element types we don't care about
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
}
}
// Return NULL on an error
return NULL;
}
