void QueueResourcesList::fromPbsQueueInfoString(QString const& queueInfo)
{
QueueResources* queue(0);
QStringList lines(queueInfo.split(QRegExp("\\n"), QString::SkipEmptyParts));
QStringList tokens;
QString line;
bool ok;
int n;
QStringList::iterator iter;
for (iter = lines.begin(); iter != lines.end(); ++iter) {
line = *iter;
tokens = line.split(QRegExp("\\s+"), QString::SkipEmptyParts);
if (line.contains("Queue: ")) {
queue = new QueueResources(tokens[1]);
append(queue);
}
if (!queue) break;
if (line.contains("resources_max.walltime")) {
queue->m_maxWallTime = tokens[2];
}else if (line.contains("resources_default.walltime")) {
queue->m_defaultWallTime = tokens[2];
}else if (line.contains("resources_max.vmem")) {
queue->m_maxMemory = parseResource(tokens[2]);
}else if (line.contains("resources_min.vmem")) {
queue->m_minMemory = parseResource(tokens[2]);
}else if (line.contains("resources_default.vmem")) {
queue->m_defaultMemory = parseResource(tokens[2]);
}else if (line.contains("resources_max.jobfs")) {
queue->m_maxScratch = parseResource(tokens[2]);
}else if (line.contains("resources_min.jobfs")) {
queue->m_minScratch = parseResource(tokens[2]);
}else if (line.contains("resources_default.jobfs")) {
queue->m_defaultScratch = parseResource(tokens[2]);
}else if (line.contains("resources_max.ncpus")) {
n = tokens[2].toInt(&ok);
if (ok) queue->m_maxCpus = n;
}else if (line.contains("resources_min.ncpus")) {
n = tokens[2].toInt(&ok);
if (ok) queue->m_minCpus = n;
}else if (line.contains("resources_default.ncpus")) {
n = tokens[2].toInt(&ok);
if (ok) queue->m_defaultCpus = n;
}
}
}
VariableValue* PHPVariableParser::parseValue(PHPVariable* var)
{
PHPArrayValue* arrayValue;
PHPObjectValue* objectValue;
PHPScalarValue* scalarValue;
int index;
switch(m_raw.at(m_index).latin1())
{
case 'b':
scalarValue = new PHPScalarValue(var);
scalarValue->setType(PHPScalarValue::Boolean);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->set(parseBool());
return scalarValue;
//break;
case 's':
scalarValue = new PHPScalarValue(var);
scalarValue->setType(PHPScalarValue::String);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->set(QString("\"") + parseString() + QString("\""));
return scalarValue;
//break;
case 'a':
arrayValue = new PHPArrayValue(var);
arrayValue->setScalar(false);
//var->setValue(arrayValue);
m_indexedVarList.append(arrayValue);
arrayValue->setList(parseArray(var));
return arrayValue;
//break;
case 'O':
objectValue = new PHPObjectValue(var);
objectValue->setScalar(false);
//var->setValue(objectValue);
m_indexedVarList.append(objectValue);
objectValue->setClassType(parseClassType());
objectValue->setList(parseObjectMembers(var));
return objectValue;
//break;
case 'i':
scalarValue = new PHPScalarValue(var);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Integer);
scalarValue->set(parseInt());
return scalarValue;
//break;
case 'r':
index = parseSoftReference();
var->setValueShared(true);
//var->setValue(m_indexedVarList.at(index-2));
return m_indexedVarList.at(index-1);
//break;
case 'R':
index = parseReference();
var->setValueShared(true);
var->setReference(true);
return m_indexedVarList.at(index-1);
//var->setValue(m_indexedVarList.at(index-2));
break;
case 'N':
scalarValue = new PHPScalarValue(var);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Undefined);
scalarValue->set("null");
m_index+=2; //eats the 'N;'
return scalarValue;
//break;
case 'd':
scalarValue = new PHPScalarValue(var);
//var->setValue(scalarValue);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Double);
scalarValue->set(parseDouble());
return scalarValue;
case 'z':
scalarValue = new PHPScalarValue(var);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Resource);
scalarValue->set(parseResource());
return scalarValue;
case '?':
scalarValue = new PHPScalarValue(var);
m_indexedVarList.append(scalarValue);
scalarValue->setType(PHPScalarValue::Undefined);
scalarValue->set("?");
m_index += 2;
return scalarValue;
default:
kdDebug() << "+++++ Bug on PHPVariableParser! > " << m_index << endl;
kdDebug() << m_raw.mid(0, 200) << endl;
return 0;
}
}
ParsedElement
Animxmlparser::parseNext ()
{
ParsedElement parsedElement;
parsedElement.type = XML_INVALID;
parsedElement.version = m_version;
parsedElement.isWpacket = false;
if (m_reader->atEnd () || m_reader->hasError ())
{
m_parsingComplete = true;
m_traceFile->close ();
return parsedElement;
}
QXmlStreamReader::TokenType token = m_reader->readNext ();
if (token == QXmlStreamReader::StartDocument)
return parsedElement;
if (token == QXmlStreamReader::StartElement)
{
if (m_reader->name () == "anim")
{
parsedElement = parseAnim ();
}
if (m_reader->name () == "topology")
{
parsedElement = parseTopology ();
}
if (m_reader->name () == "node")
{
parsedElement = parseNode ();
}
if (m_reader->name () == "packet")
{
parsedElement = parsePacket ();
}
if (m_reader->name () == "p")
{
parsedElement = parseP ();
}
if (m_reader->name () == "wp")
{
parsedElement = parseWp ();
}
if (m_reader->name () == "wpacket")
{
parsedElement = parseWPacket ();
}
if (m_reader->name () == "link")
{
parsedElement = parseLink ();
}
if (m_reader->name () == "nonp2plinkproperties")
{
parsedElement = parseNonP2pLink ();
}
if (m_reader->name () == "linkupdate")
{
parsedElement = parseLinkUpdate ();
}
if (m_reader->name () == "nu")
{
parsedElement = parseNodeUpdate ();
}
if (m_reader->name () == "res")
{
parsedElement = parseResource ();
}
if (m_reader->name () == "bg")
{
parsedElement = parseBackground ();
}
if (m_reader->name () == "ncs")
{
parsedElement = parseCreateNodeCounter ();
}
if (m_reader->name () == "nc")
{
parsedElement = parseNodeCounterUpdate ();
}
if (m_reader->name () == "pr")
{
parsedElement = parsePacketTxRef ();
}
if (m_reader->name () == "wpr")
{
parsedElement = parseWPacketRxRef ();
}
//qDebug (m_reader->name ().toString ());
}
if (m_reader->atEnd ())
{
m_parsingComplete = true;
m_traceFile->close ();
}
return parsedElement;
}
static struct host
parseHost
(json_value *hostObj, int *ret)
{
json_value *jName = json_find(hostObj, "name", json_string);
json_value *jMac = json_find(hostObj, "mac", json_string);
if ((NULL == jName) || (NULL == jMac))
return (*ret = 1), (struct host) {0};
struct host result = {
.name = utilStringDup(jName->u.string.ptr),
.macAddress = utilStringDup(jMac->u.string.ptr)
};
return result;
}
static struct host *
parseHosts
(json_value *root, size_t *numHosts)
{
json_value *jHosts = json_find(root, "hosts", json_array);
if (NULL == jHosts)
return NULL;
const size_t numJHosts = jHosts->u.array.length;
struct host *result = calloc(numJHosts, sizeof(*result));
for (size_t i=0; i<numJHosts; i++)
{
json_value *jHostObj = jHosts->u.array.values[i];
int ret = 0;
result[i] = parseHost(jHostObj, &ret);
if (ret)
{
free(result);
return NULL;
}
}
*numHosts = numJHosts;
return result;
}
static struct resource
parseResource
(json_value *jResource, int *ret)
{
json_value *jName = json_find(jResource, "name", json_string);
json_value *jHost = json_find(jResource, "host", json_string);
json_value *jVars = json_find(jResource, "vars", json_array);
if ((NULL == jName) || (NULL == jHost) || (NULL == jVars))
return (*ret = 1), (struct resource) {0};
const size_t numVars = jVars->u.array.length;
char **keyMap = calloc(numVars, sizeof(char *));
char **valMap = calloc(numVars, sizeof(char *));
for (size_t i=0; i<numVars; i++)
{
json_value *jVar = jVars->u.array.values[i];
if (jVar->type != json_array)
return (*ret = 1), (struct resource) {0};
if (jVar->u.array.length != 2)
return (*ret = 1), (struct resource) {0};
json_value *jKey = jVar->u.array.values[0];
json_value *jVal = jVar->u.array.values[1];
if (jKey->type != json_string)
return (*ret = 1), (struct resource) {0};
if (jVal->type != json_string)
return (*ret = 1), (struct resource) {0};
keyMap[i] = utilStringDup(jKey->u.string.ptr);
valMap[i] = utilStringDup(jVal->u.string.ptr);
}
struct resource result = {
.name = utilStringDup(jName->u.string.ptr),
.host = utilStringDup(jHost->u.string.ptr),
.numVars = numVars,
.keyMap = keyMap,
.valMap = valMap,
};
return result;
}
struct resource *
parseResources
(json_value *root, size_t *numResources)
{
json_value *jResources = json_find(root, "resources", json_array);
if (NULL == jResources)
return NULL;
const size_t numJResources = jResources->u.array.length;
struct resource *result = calloc(numJResources, sizeof(*result));
for (size_t i=0; i<numJResources; i++)
{
json_value *jResource = jResources->u.array.values[i];
int ret = 0;
result[i] = parseResource(jResource, &ret);
result[i].id = i;
#if defined(CLUSTERD_BUILD)
result[i].mutex = calloc(1, sizeof(pthread_mutex_t));
result[i].inUse = calloc(1, sizeof(bool));
pthread_mutex_init(result[i].mutex, NULL);
#endif
}
*numResources = numJResources;
return result;
}
configuration *
parseConfiguration
(void)
{
char *jsonConfig = readFile(_configPath);
if (NULL == jsonConfig)
{
fprintf(stderr, "Error: Unable to read configuration file\n");
fprintf(stderr, "Does %s exist?\n", _configPath);
return NULL;
}
json_value *root = json_parse(jsonConfig, strlen(jsonConfig));
free(jsonConfig);
if (NULL == root)
{
fprintf(stderr, "Error: Configuration file %s is malformed\n", _configPath);
fprintf(stderr, "Unable to parse json\n");
return NULL;
}
configuration *result = calloc(1, sizeof(configuration));
result->hosts = parseHosts(root, &result->numHosts);
if (NULL == result->hosts)
{
fprintf(stderr, "Error: Configuration file %s is malformed\n", _configPath);
fprintf(stderr, "Unable to parse hosts\n");
return NULL;
}
result->resources = parseResources(root, &result->numResources);
if (NULL == result->hosts)
{
fprintf(stderr, "Error: Configuration file %s is malformed\n", _configPath);
fprintf(stderr, "Unable to parse resources\n");
return NULL;
}
json_value *jMaster = json_find(root, "master", json_string);
if (NULL == jMaster)
{
fprintf(stderr, "Error: No master hostname set\n");
return NULL;
}
if (jMaster->type != json_string)
{
fprintf(stderr, "Error: Master feild is not a string\n");
return NULL;
}
result->master = utilStringDup(jMaster->u.string.ptr);
json_value_free(root);
return result;
}
