int sc_struct::unpack_array_attr(sc_session *s,sc_addr tuple,sc_smart_addr arr[],sc_addr attrs[],int max_cnt,int min_cnt)
{
int i=0;
for (;i<min_cnt;i++)
arr[i] = find_attr(s,tuple,attrs[i]);
for (;i<max_cnt;i++)
if (!(arr[i] = find_attr(s,tuple,attrs[i])))
break;
return i;
}
std::vector<sc_smart_addr> sc_struct::unpack_vector_attr(sc_session *s,sc_addr tuple,sc_addr attrs[],int max_cnt,int min_cnt)
{
std::vector<sc_smart_addr> rv;
rv.reserve(min_cnt);
int i=0;
for (;i<min_cnt;i++)
rv.push_back(find_attr(s,tuple,attrs[i]));
for (;i<max_cnt;i++) {
sc_addr addr = find_attr(s,tuple,attrs[i]);
if (!addr)
break;
rv.push_back(addr);
}
return rv;
}
int
status_attrib(svrattrl *pal, attribute_def *padef, attribute *pattr, int limit, int priv, pbs_list_head *phead, int *bad)
{
int index;
int nth = 0;
priv &= (ATR_DFLAG_RDACC | ATR_DFLAG_SvWR); /* user-client privilege */
resc_access_perm = priv; /* pass privilege to encode_resc() */
/* for each attribute asked for or for all attributes, add to reply */
if (pal) { /* client specified certain attributes */
while (pal) {
++nth;
index = find_attr(padef, pal->al_name, limit);
if (index < 0) {
*bad = nth;
return (-1);
}
if ((padef+index)->at_flags & priv) {
svrcached(pattr+index, phead, padef+index);
}
pal = (svrattrl *)GET_NEXT(pal->al_link);
}
} else { /* non specified, return all readable attributes */
for (index = 0; index < limit; index++) {
if ((padef+index)->at_flags & priv) {
svrcached(pattr+index, phead, padef+index);
}
}
}
return (0);
}
int read_service(xmlNode *list_node, service_t **dst)
{
int res = 0;
xmlAttr *a;
const char *a_val;
xmlNode *n;
int first_node;
DEBUG_LOG("read_service(): called\n");
/* allocate memory and prepare empty node */
if (!dst) return -1;
*dst = (service_t*)cds_malloc(sizeof(service_t));
if (!(*dst)) return -2;
memset(*dst, 0, sizeof(service_t));
/* get attributes */
a = find_attr(list_node->properties, "uri");
if (a) {
a_val = get_attr_value(a);
if (a_val) (*dst)->uri = zt_strdup(a_val);
}
/* read child nodes */
n = list_node->children;
first_node = 1;
while (n) {
if (n->type == XML_ELEMENT_NODE) {
if (first_node) {
/* element must be list or resource-list */
if (cmp_node(n, "list", rls_namespace) >= 0) {
res = read_list(n, &(*dst)->content.list, 0);
if ( (res == 0) && ((*dst)->content.list) ) {
(*dst)->content_type = stc_list;
}
else return -1;
}
else if (cmp_node(n, "resource-list", rls_namespace) >= 0) {
a_val = get_node_value(n);
if (a_val)
(*dst)->content.resource_list = zt_strdup(a_val);
else
(*dst)->content.resource_list = NULL;
(*dst)->content_type = stc_resource_list;
}
else return -1;
first_node = 0;
}
else { /* packages node */
if (cmp_node(n, "packages", rls_namespace) >= 0) {
res = read_packages(n, &(*dst)->packages);
}
break;
}
}
n = n->next;
}
return 0;
}
void decode_attribute(
svrattrl *pal,
job **pjob)
{
int index;
job *pj = *pjob;
/* find the pbs_attribute definition based on the name */
index = find_attr(job_attr_def, pal->al_name, JOB_ATR_LAST);
if (index < 0)
index = JOB_ATR_UNKN;
job_attr_def[index].at_free(&pj->ji_wattr[index]);
job_attr_def[index].at_decode(
&pj->ji_wattr[index],
pal->al_name,
pal->al_resc,
pal->al_value,
ATR_DFLAG_ACCESS);
if (job_attr_def[index].at_action != NULL)
job_attr_def[index].at_action(&pj->ji_wattr[index], pj, ATR_ACTION_RECOV);
pj->ji_wattr[index].at_flags = pal->al_flags & ~ATR_VFLAG_MODIFY;
}
static void
check_style_attr (struct taginfo *tag, struct map_context *ctx)
{
int attrind;
int raw_start;
int raw_len;
char *style = find_attr (tag, "style", &attrind);
if (!style)
return;
/* raw pos and raw size include the quotes, skip them when they are
present. */
raw_start = ATTR_POS (tag, attrind, ctx);
raw_len = ATTR_SIZE (tag, attrind);
if( *(char *)(ctx->text + raw_start) == '\''
|| *(char *)(ctx->text + raw_start) == '"')
{
raw_start += 1;
raw_len -= 2;
}
if(raw_len <= 0)
return;
get_urls_css (ctx, raw_start, raw_len);
}
END_TEST
START_TEST(test_three)
{
pbs_attribute attr;
attribute_def def;
pbs_attribute attrA;
pbs_attribute attrB;
memset(&attr,(unsigned)~0,sizeof(pbs_attribute));
memset(&def,0,sizeof(attribute_def));
memset(&attrA,0,sizeof(pbs_attribute));
memset(&attrB,0,sizeof(pbs_attribute));
def.at_type = ATR_TYPE_LIST;
clear_attr(&attr,&def);
fail_unless(attr.at_type == ATR_TYPE_LIST);
attribute_def defa[3];
memset(defa,0,sizeof(defa));
defa[0].at_name = "Hello There.";
defa[1].at_name = "Howdy Pard.";
defa[2].at_name = "hello";
fail_unless(find_attr(defa,"HeLlo",3) == 2);
fail_unless(find_attr(defa,"Hello there. ",3) == -1);
attrA.at_val.at_long = 5;
attrB.at_val.at_long = 6;
fail_unless(attr_ifelse_long(&attrA,&attrB,3) == 3);
attrB.at_flags = ATR_VFLAG_SET;
fail_unless(attr_ifelse_long(&attrA,&attrB,3) == 6);
attrA.at_flags = ATR_VFLAG_SET;
fail_unless(attr_ifelse_long(&attrA,&attrB,3) == 5);
free_null(&attrA);
fail_unless(attrA.at_flags == 0);
free_noop(&attrA);
comp_null(&attrA,&attrB);
}
static void
tag_handle_link (int tagid, struct taginfo *tag, struct map_context *ctx)
{
int attrind;
char *href = find_attr (tag, "href", &attrind);
/* All <link href="..."> link references are external, except those
known not to be, such as style sheet and shortcut icon:
<link rel="stylesheet" href="...">
<link rel="shortcut icon" href="...">
*/
if (href)
{
struct urlpos *up = append_url (href, ATTR_POS(tag,attrind,ctx),
ATTR_SIZE(tag,attrind), ctx);
if (up)
{
char *rel = find_attr (tag, "rel", NULL);
if (rel)
{
if (0 == strcasecmp (rel, "stylesheet"))
{
up->link_inline_p = 1;
up->link_expect_css = 1;
}
else if (0 == strcasecmp (rel, "shortcut icon"))
{
up->link_inline_p = 1;
}
else
{
/* The external ones usually point to HTML pages, such as
<link rel="next" href="...">
except when the type attribute says otherwise:
<link rel="alternate" type="application/rss+xml" href=".../?feed=rss2" />
*/
char *type = find_attr (tag, "type", NULL);
if (!type || strcasecmp (type, "text/html") == 0)
up->link_expect_html = 1;
}
}
}
}
}
status_t
device_node::_RegisterDynamic(device_node* previous)
{
// If this is not a bus, we don't have to scan it
if (find_attr(this, B_DEVICE_BUS, false, B_STRING_TYPE) == NULL)
return B_OK;
// If we're not being probed, we honour the B_FIND_CHILD_ON_DEMAND
// requirements
if (!IsProbed() && (fFlags & B_FIND_CHILD_ON_DEMAND) != 0
&& !_AlwaysRegisterDynamic())
return B_OK;
KPath path;
if ((fFlags & B_FIND_MULTIPLE_CHILDREN) == 0) {
// find the one driver
driver_module_info* bestDriver = NULL;
float bestSupport = 0.0;
void* cookie = NULL;
while (_GetNextDriverPath(cookie, path) == B_OK) {
_FindBestDriver(path.Path(), bestDriver, bestSupport, previous);
}
if (bestDriver != NULL) {
TRACE((" register best module \"%s\", support %f\n",
bestDriver->info.name, bestSupport));
if (bestDriver->register_device(this) == B_OK) {
// There can only be one node of this driver
// (usually only one at all, but there might be a new driver
// "waiting" for its turn)
device_node* child = FindChild(bestDriver->info.name);
if (child != NULL) {
child->fSupportsParent = bestSupport;
if (previous != NULL) {
previous->fFlags |= NODE_FLAG_OBSOLETE_DRIVER;
previous->Release();
child->fFlags |= NODE_FLAG_WAITING_FOR_DRIVER;
}
}
// TODO: if this fails, we could try the second best driver,
// and so on...
}
put_module(bestDriver->info.name);
}
} else {
// register all drivers that match
void* cookie = NULL;
while (_GetNextDriverPath(cookie, path) == B_OK) {
_RegisterPath(path.Path());
}
}
return B_OK;
}
SaErrorT get_rpt_attr(Rpt_t *rpt, char *attr_name, union_type_t *val)
{
int i;
if ((attr_name == (char *)NULL) || (val == (union_type_t *)NULL))
return(SA_ERR_HPI_INVALID_PARAMS);
i = find_attr(&(rpt->Attrutes), attr_name);
if (i < 0)
return(SA_ERR_HPI_INVALID_PARAMS);
*val = rpt->Attrutes.Attrs[i].value;
return(SA_OK);
}
int
sched_recov_db(void)
{
pbs_db_conn_t *conn = (pbs_db_conn_t *) svr_db_conn;
pbs_db_sched_info_t dbsched;
pbs_db_attr_info_t attr_info;
pbs_db_obj_info_t obj;
int rc;
int index;
/* load server_qs */
strcpy(dbsched.sched_name, pbs_server_id);
if (pbs_db_begin_trx(conn, 0, 0) !=0)
goto db_err;
obj.pbs_db_obj_type = PBS_DB_SCHED;
obj.pbs_db_un.pbs_db_sched = &dbsched;
/* read in job fixed sub-structure */
if ((rc = pbs_db_load_obj(conn, &obj)) == -1) /* error */
goto db_err;
if (rc == 0) {
db_to_svr_sched(&scheduler, &dbsched);
attr_info.parent_id = pbs_server_id;
attr_info.parent_obj_type = PARENT_TYPE_SCHED; /* svr attr */
/* read in server attributes */
if (recov_attr_db(conn, &scheduler, &attr_info, sched_attr_def, scheduler.sch_attr,
(int)SCHED_ATR_LAST, 0) != 0)
goto db_err;
}
if (pbs_db_end_trx(conn, PBS_DB_COMMIT) != 0)
goto db_err;
if (pbs_conf.pbs_use_tcp == 0) {
/* check if throughput mode is visible in non-TPP mode, if so make it invisible */
index = find_attr(sched_attr_def, ATTR_throughput_mode, SCHED_ATR_LAST);
scheduler.sch_attr[index].at_flags = 0;
}
return (0);
db_err:
log_err(-1, "sched_recov", "read of scheduler db failed");
(void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK);
return -1;
}
static status_t
get_attr_uint64(const device_node* node, const char* name,
uint64* _value, bool recursive)
{
if (node == NULL || name == NULL || _value == NULL)
return B_BAD_VALUE;
device_attr_private* attr = find_attr(node, name, recursive, B_UINT64_TYPE);
if (attr == NULL)
return B_NAME_NOT_FOUND;
*_value = attr->value.ui64;
return B_OK;
}
static status_t
get_attr_string(const device_node* node, const char* name,
const char** _value, bool recursive)
{
if (node == NULL || name == NULL || _value == NULL)
return B_BAD_VALUE;
device_attr_private* attr = find_attr(node, name, recursive, B_STRING_TYPE);
if (attr == NULL)
return B_NAME_NOT_FOUND;
*_value = attr->value.string;
return B_OK;
}
SaErrorT get_rpt_attr_as_string(Rpt_t *rpt, char *attr_name, char *val, int len)
{
int i;
SaErrorT ret;
if ((attr_name == (char *)NULL) || (val == (char *)NULL) || (len == 0))
return(SA_ERR_HPI_INVALID_PARAMS);
i = find_attr(&(rpt->Attrutes), attr_name);
if (i < 0)
return(SA_ERR_HPI_INVALID_PARAMS);
ret = get_value_as_string(&(rpt->Attrutes), i, val, len);
return(ret);
}
static void
tag_handle_form (int tagid, struct taginfo *tag, struct map_context *ctx)
{
int attrind;
char *action = find_attr (tag, "action", &attrind);
if (action)
{
struct urlpos *up = append_url (action, ATTR_POS(tag,attrind,ctx),
ATTR_SIZE(tag,attrind), ctx);
if (up)
up->ignore_when_downloading = 1;
}
}
static status_t
get_attr_raw(const device_node* node, const char* name, const void** _data,
size_t* _length, bool recursive)
{
if (node == NULL || name == NULL || (_data == NULL && _length == NULL))
return B_BAD_VALUE;
device_attr_private* attr = find_attr(node, name, recursive, B_RAW_TYPE);
if (attr == NULL)
return B_NAME_NOT_FOUND;
if (_data != NULL)
*_data = attr->value.raw.data;
if (_length != NULL)
*_length = attr->value.raw.length;
return B_OK;
}
static int read_entry_ref(xmlNode *entry_node, entry_ref_t **dst)
{
xmlAttr *a;
const char *a_val;
/* allocate memory and prepare empty node */
if (!dst) return -1;
*dst = (entry_ref_t*)cds_malloc(sizeof(entry_ref_t));
if (!(*dst)) return -2;
memset(*dst, 0, sizeof(entry_ref_t));
/* get attributes */
a = find_attr(entry_node->properties, "ref");
if (a) {
a_val = get_attr_value(a);
if (a_val) (*dst)->ref = zt_strdup(a_val);
}
return 0;
}
void decode_attribute(
svrattrl *pal,
job **pjob,
bool freeExisting)
{
int index;
job *pj = *pjob;
/* find the pbs_attribute definition based on the name */
index = find_attr(job_attr_def, pal->al_name, JOB_ATR_LAST);
if (index < 0)
index = JOB_ATR_UNKN;
if (freeExisting)
{
job_attr_def[index].at_free(&pj->ji_wattr[index]);
}
if (index == JOB_ATR_hold)
{
// JOB_ATR_hold is written to file as a number so it won't decode correctly
pj->ji_wattr[index].at_val.at_long = strtol(pal->al_value, NULL, 10);
}
else
{
job_attr_def[index].at_decode(
&pj->ji_wattr[index],
pal->al_name,
pal->al_resc,
pal->al_value,
ATR_DFLAG_ACCESS);
}
if (job_attr_def[index].at_action != NULL)
job_attr_def[index].at_action(&pj->ji_wattr[index], pj, ATR_ACTION_RECOV);
pj->ji_wattr[index].at_flags = pal->al_flags & ~ATR_VFLAG_MODIFY;
} // END decode_attribute()
static int read_name(xmlNode *name_node, display_name_t **dst)
{
xmlAttr *a;
const char *a_val;
/* allocate memory and prepare empty node */
if (!dst) return -1;
*dst = (display_name_t*)cds_malloc(sizeof(display_name_t));
if (!(*dst)) return -2;
memset(*dst, 0, sizeof(display_name_t));
/* get attributes */
a = find_attr(name_node->properties, "lang");
if (a) {
a_val = get_attr_value(a);
if (a_val) (*dst)->lang = zt_strdup(a_val);
}
a_val = get_node_value(name_node);
if (a_val) (*dst)->name = zt_strdup(a_val);
return 0;
}
static void
tag_handle_base (int tagid, struct taginfo *tag, struct map_context *ctx)
{
struct urlpos *base_urlpos;
int attrind;
char *newbase = find_attr (tag, "href", &attrind);
if (!newbase)
return;
base_urlpos = append_url (newbase, ATTR_POS(tag,attrind,ctx),
ATTR_SIZE(tag,attrind), ctx);
if (!base_urlpos)
return;
base_urlpos->ignore_when_downloading = 1;
base_urlpos->link_base_p = 1;
if (ctx->base)
xfree (ctx->base);
if (ctx->parent_base)
ctx->base = uri_merge (ctx->parent_base, newbase);
else
ctx->base = xstrdup (newbase);
}
int attr_atomic_set(
struct svrattrl *plist,
pbs_attribute *old,
pbs_attribute *new_attr,
attribute_def *pdef,
int limit,
int unkn,
int privil,
int *badattr)
{
int acc;
int index;
int listidx;
resource *prc;
int rc;
pbs_attribute temp;
int resc_access_perm = privil; /* set privilege for decode_resc() */
for (index = 0;index < limit;index++)
clear_attr(new_attr + index, pdef + index);
listidx = 0;
rc = PBSE_NONE;
while (plist != NULL)
{
listidx++;
if ((index = find_attr(pdef, plist->al_name, limit)) < 0)
{
if (unkn < 0)
{
/*unknown attr isn't allowed*/
rc = PBSE_NOATTR;
break;
}
else
{
index = unkn; /* if unknown attr are allowed */
}
}
/* have we privilege to set the pbs_attribute ? */
acc = (pdef + index)->at_flags & ATR_DFLAG_ACCESS;
if ((acc & privil & ATR_DFLAG_WRACC) == 0)
{
if (privil & ATR_DFLAG_SvWR)
{
/* from a daemon, just ignore this pbs_attribute */
plist = (svrattrl *)GET_NEXT(plist->al_link);
continue;
}
/* from user, error if can't write pbs_attribute */
rc = PBSE_ATTRRO;
break;
}
/* decode new_attr value */
clear_attr(&temp, pdef + index);
/*
* special gpu cases
* 1) if only ncpus is specified, delete gpus resource if any
* 2) if both ncpus and gpus specified, replace both
*/
if ((strcmp(plist->al_name,ATTR_l) == 0) &&
(strcmp(plist->al_resc,"ncpus") == 0))
{
char *pc;
if ((pc = strstr(plist->al_value,":gpus=")) != NULL)
{
/* save off gpu resource list then add new resource_list entry for it */
char *gpuval;
gpuval = strdup(pc+6);
(*pc) = '\0';
if (gpuval != NULL)
{
rc = (pdef + index)->at_decode(&temp, plist->al_name, (char *)"gpus",
gpuval,ATR_DFLAG_ACCESS);
free(gpuval);
if (rc != 0)
{
if ((rc == PBSE_UNKRESC) && (unkn > 0))
rc = 0; /* ignore the "error" */
else
break;
}
}
}
else
{
/* delete old resource_list.gpus value if any.
* this can be done by setting it to zero
*/
rc = (pdef + index)->at_decode(&temp, plist->al_name, (char *)"gpus",
0,ATR_DFLAG_ACCESS);
if (rc != 0)
{
if ((rc == PBSE_UNKRESC) && (unkn > 0))
rc = 0; /* ignore the "error" */
else
break;
}
}
}
rc = (pdef + index)->at_decode(&temp, plist->al_name, plist->al_resc, plist->al_value,resc_access_perm);
if (rc != 0)
{
if ((rc == PBSE_UNKRESC) && (unkn > 0))
rc = 0; /* ignore the "error" */
else
break;
}
/* duplicate current value, if set AND not already dup-ed */
if (((old + index)->at_flags & ATR_VFLAG_SET) &&
!((new_attr + index)->at_flags & ATR_VFLAG_SET))
{
if ((rc = (pdef + index)->at_set(new_attr + index, old + index, SET)) != 0)
break;
/*
* we need to know if the value is changed during
* the next step, so clear MODIFY here; including
* within resources.
*/
(new_attr + index)->at_flags &= ~ATR_VFLAG_MODIFY;
if ((new_attr + index)->at_type == ATR_TYPE_RESC)
{
prc = (resource *)GET_NEXT((new_attr + index)->at_val.at_list);
while (prc)
{
prc->rs_value.at_flags &= ~ATR_VFLAG_MODIFY;
prc = (resource *)GET_NEXT(prc->rs_link);
}
}
}
/* update new copy with temp, MODIFY is set on ones changed */
if ((plist->al_op != INCR) && (plist->al_op != DECR) &&
(plist->al_op != SET) && (plist->al_op != INCR_OLD))
{
plist->al_op = SET;
}
if (temp.at_flags & ATR_VFLAG_SET)
{
if ((rc = (pdef + index)->at_set(new_attr + index, &temp, plist->al_op)) != 0)
{
(pdef + index)->at_free(&temp);
break;
}
}
else if (temp.at_flags & ATR_VFLAG_MODIFY)
{
(pdef + index)->at_free(new_attr + index);
(new_attr + index)->at_flags |= ATR_VFLAG_MODIFY;
}
(pdef + index)->at_free(&temp);
if (plist->al_link.ll_next == NULL)
break;
plist = (struct svrattrl *)GET_NEXT(plist->al_link);
} /* END while (plist != NULL) */
if (rc != 0)
{
*badattr = listidx;
for (index = 0; index < limit; index++)
(pdef + index)->at_free(new_attr + index);
return(rc);
}
return(0);
} /* END attr_atomic_set() */
int str_to_attr(
const char *name, /* I */
char *val, /* I */
pbs_attribute *attr, /* O */
struct attribute_def *padef, /* I */
int limit) /* I */
{
int index;
char buf[MAXLINE<<5];
char log_buf[LOCAL_LOG_BUF_SIZE];
if ((name == NULL) ||
(val == NULL) ||
(attr == NULL))
{
return(-10);
}
index = find_attr(padef,name,limit);
if (index < 0)
return(ATTR_NOT_FOUND);
switch (padef[index].at_type)
{
case ATR_TYPE_LONG:
attr[index].at_val.at_long = strtol(val, NULL, 10);
break;
case ATR_TYPE_CHAR:
attr[index].at_val.at_char = *val;
break;
case ATR_TYPE_STR:
unescape_xml(val,buf,sizeof(buf));
attr[index].at_val.at_str = strdup(buf);
if (attr[index].at_val.at_str == NULL)
{
log_err(PBSE_SYSTEM, __func__, "Cannot allocate memory\n");
return(PBSE_SYSTEM);
}
break;
case ATR_TYPE_ARST:
case ATR_TYPE_ACL:
{
int rc;
unescape_xml(val,buf,sizeof(buf));
if ((rc = decode_arst(attr + index,name,NULL,buf,0)))
return(rc);
}
break;
case ATR_TYPE_SIZE:
{
unsigned long number;
char *unit;
number = strtol(val, NULL, 10);
attr[index].at_val.at_size.atsv_units = ATR_SV_BYTESZ;
attr[index].at_val.at_size.atsv_num = number;
attr[index].at_val.at_size.atsv_shift = 0;
/* the string always ends with kb,mb if it has units */
unit = val + strlen(val) - 2;
if (unit < val)
break;
else if (isdigit(*val))
break;
switch (*unit)
{
case 'k':
attr[index].at_val.at_size.atsv_shift = 10;
break;
case 'm':
attr[index].at_val.at_size.atsv_shift = 20;
break;
case 'g':
attr[index].at_val.at_size.atsv_shift = 30;
break;
case 't':
attr[index].at_val.at_size.atsv_shift = 40;
break;
case 'p':
attr[index].at_val.at_size.atsv_shift = 50;
break;
}
}
break;
case ATR_TYPE_RESC:
{
char *resc_parent;
char *resc_child;
char *resc_ptr = val;
int len = strlen(resc_ptr);
int rc;
int errFlg = 0;
while (resc_ptr - val < len)
{
if (get_parent_and_child(resc_ptr,&resc_parent,&resc_child,
&resc_ptr))
{
errFlg = TRUE;
break;
}
if ((rc = decode_resc(&(attr[index]),name,resc_parent,resc_child,ATR_DFLAG_ACCESS)))
{
snprintf(log_buf,sizeof(log_buf),
"Error decoding resource %s, %s = %s\n",
name,
resc_parent,
resc_child);
errFlg = TRUE;
log_err(rc, __func__, log_buf);
}
}
if (errFlg == TRUE)
return(-1);
}
break;
/* NYI */
case ATR_TYPE_LIST:
case ATR_TYPE_LL:
case ATR_TYPE_SHORT:
case ATR_TYPE_JINFOP:
break;
} /* END switch (pbs_attribute type) */
attr[index].at_flags |= ATR_VFLAG_SET;
return(PBSE_NONE);
} /* END str_to_attr */
int area_area(struct Map_info *In, int *field, struct Map_info *Tmp,
struct Map_info *Out, struct field_info *Fi,
dbDriver * driver, int operator, int *ofield,
ATTRIBUTES * attr, struct ilist *BList, double snap)
{
int ret, input, line, nlines, area, nareas;
int in_area, in_centr, out_cat;
struct line_pnts *Points;
struct line_cats *Cats;
CENTR *Centr;
char buf[1000];
dbString stmt;
int nmodif;
int verbose;
verbose = G_verbose();
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* optional snap */
if (snap > 0) {
int i, j, snapped_lines = 0;
struct bound_box box;
struct boxlist *boxlist = Vect_new_boxlist(0);
struct ilist *reflist = Vect_new_list();
G_message(_("Snapping boundaries with %g ..."), snap);
/* snap boundaries in B to boundaries in A,
* not modifying boundaries in A */
if (BList->n_values > 1)
qsort(BList->value, BList->n_values, sizeof(int), cmp_int);
snapped_lines = 0;
nlines = BList->n_values;
for (i = 0; i < nlines; i++) {
line = BList->value[i];
Vect_read_line(Tmp, Points, Cats, line);
/* select lines by box */
Vect_get_line_box(Tmp, line, &box);
box.E += snap;
box.W -= snap;
box.N += snap;
box.S -= snap;
box.T = 0.0;
box.B = 0.0;
Vect_select_lines_by_box(Tmp, &box, GV_BOUNDARY, boxlist);
if (boxlist->n_values > 0) {
Vect_reset_list(reflist);
for (j = 0; j < boxlist->n_values; j++) {
int aline = boxlist->id[j];
if (!bsearch(&aline, BList->value, BList->n_values,
sizeof(int), cmp_int)) {
G_ilist_add(reflist, aline);
}
}
/* snap bline to alines */
if (Vect_snap_line(Tmp, reflist, Points, snap, 0, NULL, NULL)) {
/* rewrite bline*/
Vect_delete_line(Tmp, line);
ret = Vect_write_line(Tmp, GV_BOUNDARY, Points, Cats);
G_ilist_add(BList, ret);
snapped_lines++;
G_debug(3, "line %d snapped", line);
}
}
}
Vect_destroy_boxlist(boxlist);
Vect_destroy_list(reflist);
G_verbose_message(n_("%d boundary snapped",
"%d boundaries snapped",
snapped_lines), snapped_lines);
}
/* same procedure like for v.in.ogr:
* Vect_clean_small_angles_at_nodes() can change the geometry so that new intersections
* are created. We must call Vect_break_lines(), Vect_remove_duplicates()
* and Vect_clean_small_angles_at_nodes() until no more small dangles are found */
do {
G_message(_("Breaking lines..."));
Vect_break_lines_list(Tmp, NULL, BList, GV_BOUNDARY, NULL);
/* Probably not necessary for LINE x AREA */
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(Tmp, GV_BOUNDARY, NULL);
G_message(_("Cleaning boundaries at nodes..."));
nmodif =
Vect_clean_small_angles_at_nodes(Tmp, GV_BOUNDARY, NULL);
} while (nmodif > 0);
/* ?: May be result of Vect_break_lines() + Vect_remove_duplicates() any dangle or bridge?
* In that case, calls to Vect_remove_dangles() and Vect_remove_bridges() would be also necessary */
G_set_verbose(0);
/* should be fast, be silent */
Vect_build_partial(Tmp, GV_BUILD_AREAS);
G_set_verbose(verbose);
nlines = Vect_get_num_lines(Tmp);
ret = 0;
for (line = 1; line <= nlines; line++) {
if (!Vect_line_alive(Tmp, line))
continue;
if (Vect_get_line_type(Tmp, line) == GV_BOUNDARY) {
int left, rite;
Vect_get_line_areas(Tmp, line, &left, &rite);
if (left == 0 || rite == 0) {
/* invalid boundary */
ret = 1;
break;
}
}
}
if (ret) {
Vect_remove_dangles(Tmp, GV_BOUNDARY, -1, NULL);
Vect_remove_bridges(Tmp, NULL, NULL, NULL);
}
G_set_verbose(0);
Vect_build_partial(Tmp, GV_BUILD_NONE);
Vect_build_partial(Tmp, GV_BUILD_BASE);
G_set_verbose(verbose);
G_message(_("Merging lines..."));
Vect_merge_lines(Tmp, GV_BOUNDARY, NULL, NULL);
/* Attach islands */
G_message(_("Attaching islands..."));
/* can take some time, show messages */
Vect_build_partial(Tmp, GV_BUILD_ATTACH_ISLES);
/* Calculate new centroids for all areas */
nareas = Vect_get_num_areas(Tmp);
Centr = (CENTR *) G_malloc((nareas + 1) * sizeof(CENTR)); /* index from 1 ! */
for (area = 1; area <= nareas; area++) {
ret =
Vect_get_point_in_area(Tmp, area, &(Centr[area].x),
&(Centr[area].y));
if (ret < 0) {
G_warning(_("Cannot calculate area centroid"));
Centr[area].valid = 0;
}
else {
Centr[area].valid = 1;
}
}
/* Query input maps */
for (input = 0; input < 2; input++) {
G_message(_("Querying vector map <%s>..."),
Vect_get_full_name(&(In[input])));
for (area = 1; area <= nareas; area++) {
Centr[area].cat[input] = Vect_new_cats_struct();
G_percent(area, nareas, 1);
in_area =
Vect_find_area(&(In[input]), Centr[area].x, Centr[area].y);
if (in_area > 0) {
in_centr = Vect_get_area_centroid(&(In[input]), in_area);
if (in_centr > 0) {
int i;
Vect_read_line(&(In[input]), NULL, Cats, in_centr);
/* Add all cats with original field number */
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == field[input]) {
ATTR *at;
Vect_cat_set(Centr[area].cat[input], ofield[input + 1],
Cats->cat[i]);
/* Mark as used */
at = find_attr(&(attr[input]), Cats->cat[i]);
if (!at)
G_fatal_error(_("Attribute not found"));
at->used = 1;
}
}
}
}
}
}
G_message(_("Writing centroids..."));
db_init_string(&stmt);
out_cat = 1;
for (area = 1; area <= nareas; area++) {
int i;
G_percent(area, nareas, 1);
/* check the condition */
switch (operator) {
case OP_AND:
if (!
(Centr[area].cat[0]->n_cats > 0 &&
Centr[area].cat[1]->n_cats > 0))
continue;
break;
case OP_OR:
if (!
(Centr[area].cat[0]->n_cats > 0 ||
Centr[area].cat[1]->n_cats > 0))
continue;
break;
case OP_NOT:
if (!
(Centr[area].cat[0]->n_cats > 0 &&
!(Centr[area].cat[1]->n_cats > 0)))
continue;
break;
case OP_XOR:
if ((Centr[area].cat[0]->n_cats > 0 &&
Centr[area].cat[1]->n_cats > 0) ||
(!(Centr[area].cat[0]->n_cats > 0) &&
!(Centr[area].cat[1]->n_cats > 0)))
continue;
break;
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, Centr[area].x, Centr[area].y, 0.0);
if (ofield[0] > 0) {
/* Add new cats for all combinations of input cats (-1 in cycle for null) */
for (i = -1; i < Centr[area].cat[0]->n_cats; i++) {
int j;
if (i == -1 && Centr[area].cat[0]->n_cats > 0)
continue; /* no need to make null */
for (j = -1; j < Centr[area].cat[1]->n_cats; j++) {
if (j == -1 && Centr[area].cat[1]->n_cats > 0)
continue; /* no need to make null */
if (ofield[0] > 0)
Vect_cat_set(Cats, ofield[0], out_cat);
/* attributes */
if (driver) {
ATTR *at;
sprintf(buf, "insert into %s values ( %d", Fi->table,
out_cat);
db_set_string(&stmt, buf);
/* cata */
if (i >= 0) {
if (attr[0].columns) {
at = find_attr(&(attr[0]),
Centr[area].cat[0]->cat[i]);
if (!at)
G_fatal_error(_("Attribute not found"));
if (at->values)
db_append_string(&stmt, at->values);
else
db_append_string(&stmt, attr[0].null_values);
}
else {
sprintf(buf, ", %d", Centr[area].cat[0]->cat[i]);
db_append_string(&stmt, buf);
}
}
else {
if (attr[0].columns) {
db_append_string(&stmt, attr[0].null_values);
}
else {
sprintf(buf, ", null");
db_append_string(&stmt, buf);
}
}
/* catb */
if (j >= 0) {
if (attr[1].columns) {
at = find_attr(&(attr[1]),
Centr[area].cat[1]->cat[j]);
if (!at)
G_fatal_error(_("Attribute not found"));
if (at->values)
db_append_string(&stmt, at->values);
else
db_append_string(&stmt, attr[1].null_values);
}
else {
sprintf(buf, ", %d", Centr[area].cat[1]->cat[j]);
db_append_string(&stmt, buf);
}
}
else {
if (attr[1].columns) {
db_append_string(&stmt, attr[1].null_values);
}
else {
sprintf(buf, ", null");
db_append_string(&stmt, buf);
}
}
db_append_string(&stmt, " )");
G_debug(3, "%s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_warning(_("Unable to insert new record: '%s'"),
db_get_string(&stmt));
}
out_cat++;
}
}
}
/* Add all cats from input vectors */
if (ofield[1] > 0 && field[0] > 0) {
for (i = 0; i < Centr[area].cat[0]->n_cats; i++) {
if (Centr[area].cat[0]->field[i] == field[0])
Vect_cat_set(Cats, ofield[1], Centr[area].cat[0]->cat[i]);
}
}
if (ofield[2] > 0 && field[1] > 0 && ofield[1] != ofield[2]) {
for (i = 0; i < Centr[area].cat[1]->n_cats; i++) {
if (Centr[area].cat[1]->field[i] == field[1])
Vect_cat_set(Cats, ofield[2], Centr[area].cat[1]->cat[i]);
}
}
Vect_write_line(Tmp, GV_CENTROID, Points, Cats);
Vect_write_line(Out, GV_CENTROID, Points, Cats);
}
G_set_verbose(0);
/* should be fast, be silent */
Vect_build_partial(Tmp, GV_BUILD_CENTROIDS);
G_set_verbose(verbose);
/* Copy valid boundaries to final output */
nlines = Vect_get_num_lines(Tmp);
for (line = 1; line <= nlines; line++) {
int i, ltype, side[2], centr[2];
G_percent(line, nlines, 1); /* must be before any continue */
if (!Vect_line_alive(Tmp, line))
continue;
ltype = Vect_read_line(Tmp, Points, Cats, line);
if (!(ltype & GV_BOUNDARY))
continue;
Vect_get_line_areas(Tmp, line, &side[0], &side[1]);
for (i = 0; i < 2; i++) {
if (side[i] == 0) { /* This should not happen ! */
centr[i] = 0;
continue;
}
if (side[i] > 0) {
area = side[i];
}
else { /* island */
area = Vect_get_isle_area(Tmp, abs(side[i]));
}
if (area > 0)
centr[i] = Vect_get_area_centroid(Tmp, area);
else
centr[i] = 0;
}
if (centr[0] || centr[1])
Vect_write_line(Out, GV_BOUNDARY, Points, Cats);
}
return 0;
}
/*
* get_specific_attributes_status()
*
* Returns the specific attributes specified in pal instead of looping over
* all attributes.
*
* @param pal - the list of attributes to enode
* @param padef - the attribute definition to work from
* @param pattr - the attribute list we are encoding from
* @param phead - the list we're encoding onto
* @param priv - the privileges of the encoder
* @param limit - the number of attributes in padef
* @param bad - the attribute index that is bad. Output
* @param IsOwner - TRUE if the encoder is an owner of this object, FALSE otherwise
* @return - PBSE_NONE if successful, otherwise the appropriate pbs error code
*/
int get_specific_attributes_status(
svrattrl *pal, /* I */
attribute_def *padef,
pbs_attribute *pattr,
tlist_head *phead,
int priv,
int limit,
int *bad,
int IsOwner)
{
int nth = 0;
char log_buf[LOCAL_LOG_BUF_SIZE + 1];
int resc_access_perm;
priv &= ATR_DFLAG_RDACC; /* user-client privilege */
resc_access_perm = priv;
while (pal != NULL)
{
++nth;
int index = find_attr(padef, pal->al_name, limit);
if (index < 0)
{
*bad = nth;
snprintf(log_buf, LOCAL_LOG_BUF_SIZE, "Attribute %s not found. nth = %d", pal->al_name, nth);
LOG_EVENT(PBSEVENT_JOB, PBS_EVENTCLASS_QUEUE, __func__, log_buf);
/* FAILURE */
return(PBSE_NOATTR);
}
if ((padef + index)->at_flags & priv)
{
if (!(((padef + index)->at_flags & ATR_DFLAG_PRIVR) && (IsOwner == 0)))
{
(padef + index)->at_encode(
pattr + index,
phead,
(padef + index)->at_name,
NULL,
ATR_ENCODE_CLIENT,
resc_access_perm);
}
}
pal = (svrattrl *)GET_NEXT(pal->al_link);
}
if (padef == job_attr_def)
{
/* We want to return walltime remaining for all running jobs */
if ((pattr + JOB_ATR_start_time)->at_flags & ATR_VFLAG_SET)
add_walltime_remaining(JOB_ATR_start_time, pattr, phead);
}
/* SUCCESS */
return(PBSE_NONE);
} // END get_specific_attributes_values()
int modify_job(
void **j, /* O */
svrattrl *plist, /* I */
struct batch_request *preq, /* I */
int checkpoint_req, /* I */
int flag) /* I */
{
int bad = 0;
int i;
int newstate;
int newsubstate;
resource_def *prsd;
int rc;
int sendmom = 0;
int copy_checkpoint_files = FALSE;
char log_buf[LOCAL_LOG_BUF_SIZE];
struct batch_request *dup_req = NULL;
job *pjob = (job *)*j;
if (pjob == NULL)
{
sprintf(log_buf, "job structure is NULL");
log_err(PBSE_IVALREQ, __func__, log_buf);
return(PBSE_IVALREQ);
}
/* cannot be in exiting or transit, exiting has already been checked */
if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT)
{
/* FAILURE */
snprintf(log_buf,sizeof(log_buf),
"Cannot modify job '%s' in transit\n",
pjob->ji_qs.ji_jobid);
log_err(PBSE_BADSTATE, __func__, log_buf);
return(PBSE_BADSTATE);
}
if (((checkpoint_req == CHK_HOLD) || (checkpoint_req == CHK_CONT)) &&
(pjob->ji_qs.ji_substate == JOB_SUBSTATE_RUNNING))
{
/* May need to request copy of the checkpoint file from mom */
copy_checkpoint_files = TRUE;
if (checkpoint_req == CHK_HOLD)
{
sprintf(log_buf,"setting jobsubstate for %s to RERUN\n", pjob->ji_qs.ji_jobid);
pjob->ji_qs.ji_substate = JOB_SUBSTATE_RERUN;
job_save(pjob, SAVEJOB_QUICK, 0);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, pjob->ji_qs.ji_jobid, log_buf);
/* remove checkpoint restart file if there is one */
if (pjob->ji_wattr[JOB_ATR_restart_name].at_flags & ATR_VFLAG_SET)
{
cleanup_restart_file(pjob);
}
}
}
/* if job is running, special checks must be made */
/* NOTE: must determine if job exists down at MOM - this will occur if
job is running, job is held, or job was held and just barely
released (ie qhold/qrls) */
/* COMMENTED OUT BY JOSH B IN 2.3 DUE TO MAJOR PROBLEMS w/ CUSTOMERS
* --FIX and uncomment once we know what is really going on.
*
* We now know that ji_destin gets set on a qmove and that the mom does not
* have the job at that point.
*
if ((pjob->ji_qs.ji_state == JOB_STATE_RUNNING) ||
((pjob->ji_qs.ji_state == JOB_STATE_HELD) && (pjob->ji_qs.ji_destin[0] != '\0')) ||
((pjob->ji_qs.ji_state == JOB_STATE_QUEUED) && (pjob->ji_qs.ji_destin[0] != '\0')))
*/
if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING)
{
while (plist != NULL)
{
/* is the pbs_attribute modifiable in RUN state ? */
i = find_attr(job_attr_def, plist->al_name, JOB_ATR_LAST);
if ((i < 0) ||
((job_attr_def[i].at_flags & ATR_DFLAG_ALTRUN) == 0))
{
/* FAILURE */
snprintf(log_buf,sizeof(log_buf),
"Cannot modify attribute '%s' while running\n",
plist->al_name);
log_err(PBSE_MODATRRUN, __func__, log_buf);
return PBSE_MODATRRUN;
}
/* NOTE: only explicitly specified job attributes are routed down to MOM */
if (i == JOB_ATR_resource)
{
/* is the specified resource modifiable while */
/* the job is running */
prsd = find_resc_def(svr_resc_def, plist->al_resc, svr_resc_size);
if (prsd == NULL)
{
/* FAILURE */
snprintf(log_buf,sizeof(log_buf),
"Unknown attribute '%s'\n",
plist->al_name);
log_err(PBSE_UNKRESC, __func__, log_buf);
return(PBSE_UNKRESC);
}
if ((prsd->rs_flags & ATR_DFLAG_ALTRUN) == 0)
{
/* FAILURE */
snprintf(log_buf,sizeof(log_buf),
"Cannot modify attribute '%s' while running\n",
plist->al_name);
log_err(PBSE_MODATRRUN, __func__, log_buf);
return(PBSE_MODATRRUN);
}
sendmom = 1;
}
/*
else if ((i == JOB_ATR_checkpoint_name) || (i == JOB_ATR_variables))
{
sendmom = 1;
}
*/
plist = (svrattrl *)GET_NEXT(plist->al_link);
}
} /* END if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) */
/* modify the job's attributes */
bad = 0;
plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
rc = modify_job_attr(pjob, plist, preq->rq_perm, &bad);
if (rc)
{
/* FAILURE */
snprintf(log_buf,sizeof(log_buf),
"Cannot set attributes for job '%s'\n",
pjob->ji_qs.ji_jobid);
log_err(rc, __func__, log_buf);
if (rc == PBSE_JOBNOTFOUND)
*j = NULL;
return(rc);
}
/* Reset any defaults resource limit which might have been unset */
set_resc_deflt(pjob, NULL, FALSE);
/* if job is not running, may need to change its state */
if (pjob->ji_qs.ji_state != JOB_STATE_RUNNING)
{
svr_evaljobstate(pjob, &newstate, &newsubstate, 0);
svr_setjobstate(pjob, newstate, newsubstate, FALSE);
}
else
{
job_save(pjob, SAVEJOB_FULL, 0);
}
sprintf(log_buf, msg_manager, msg_jobmod, preq->rq_user, preq->rq_host);
log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buf);
/* if a resource limit changed for a running job, send to MOM */
if (sendmom)
{
/* if the NO_MOM_RELAY flag is set the calling function will call
relay_to_mom so we do not need to do it here */
if (flag != NO_MOM_RELAY)
{
/* The last number is unused unless this is an array */
if ((rc = copy_batchrequest(&dup_req, preq, 0, -1)) != 0)
{
}
/* The dup_req is freed in relay_to_mom (failure)
* or in issue_Drequest (success) */
else if ((rc = relay_to_mom(&pjob, dup_req, post_modify_req)))
{
if (pjob != NULL)
{
snprintf(log_buf,sizeof(log_buf),
"Unable to relay information to mom for job '%s'\n",
pjob->ji_qs.ji_jobid);
log_err(rc, __func__, log_buf);
}
return(rc); /* unable to get to MOM */
}
}
return(PBSE_RELAYED_TO_MOM);
}
if (copy_checkpoint_files)
{
struct batch_request *momreq = 0;
momreq = cpy_checkpoint(momreq, pjob, JOB_ATR_checkpoint_name, CKPT_DIR_OUT);
if (momreq != NULL)
{
/* have files to copy */
momreq->rq_extra = strdup(pjob->ji_qs.ji_jobid);
/* The momreq is freed in relay_to_mom (failure)
* or in issue_Drequest (success) */
if (checkpoint_req == CHK_HOLD)
{
rc = relay_to_mom(&pjob, momreq, chkpt_xfr_hold);
}
else
{
rc = relay_to_mom(&pjob, momreq, chkpt_xfr_done);
}
if (rc != 0)
{
if (pjob != NULL)
{
snprintf(log_buf,sizeof(log_buf),
"Unable to relay information to mom for job '%s'\n",
pjob->ji_qs.ji_jobid);
log_err(rc, __func__, log_buf);
}
return(PBSE_NONE); /* come back when mom replies */
}
}
else
{
log_err(-1, __func__, "Failed to get batch request");
}
}
return(PBSE_NONE);
} /* END modify_job() */
/**
* @brief Service the Modify Reservation Request from client such as pbs_ralter.
*
* This request atomically modifies one or more of a reservation's attributes.
* An error is returned to the client if the user does not have permission
* to perform the modification, the attribute is read-only, the reservation is
* running and the attribute is only modifiable when the reservation is not
* running or is empty.
*
* @param[in] preq - pointer to batch request from client
*/
void
req_modifyReservation(struct batch_request *preq)
{
char *rid = NULL;
svrattrl *psatl = NULL;
attribute_def *pdef = NULL;
int rc = 0;
int bad = 0;
char buf[PBS_MAXUSER + PBS_MAXHOSTNAME + 32] = {0};
int sock;
int resc_access_perm_save = 0;
int send_to_scheduler = 0;
int log_len = 0;
char *fmt = "%a %b %d %H:%M:%S %Y";
int is_standing = 0;
int next_occr_start = 0;
extern char *msg_stdg_resv_occr_conflict;
resc_resv *presv;
if (preq == NULL)
return;
sock = preq->rq_conn;
presv = chk_rescResv_request(preq->rq_ind.rq_modify.rq_objname, preq);
/* Note: on failure, chk_rescResv_request invokes req_reject
* appropriate reply is sent and batch_request is freed.
*/
if (presv == NULL)
return;
rid = preq->rq_ind.rq_modify.rq_objname;
if ((presv = find_resv(rid)) == NULL) {
/* Not on "all_resvs" list try "new_resvs" list */
presv = (resc_resv *)GET_NEXT(svr_newresvs);
while (presv) {
if (!strcmp(presv->ri_qs.ri_resvID, rid))
break;
presv = (resc_resv *)GET_NEXT(presv->ri_allresvs);
}
}
if (presv == NULL) {
req_reject(PBSE_UNKRESVID, 0, preq);
return;
}
is_standing = presv->ri_wattr[RESV_ATR_resv_standing].at_val.at_long;
if (is_standing)
next_occr_start = get_occurrence(presv->ri_wattr[RESV_ATR_resv_rrule].at_val.at_str,
presv->ri_wattr[RESV_ATR_start].at_val.at_long,
presv->ri_wattr[RESV_ATR_resv_timezone].at_val.at_str, 2);
resc_access_perm_save = resc_access_perm;
psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
presv->ri_alter_flags = 0;
while (psatl) {
long temp = 0;
char *end = NULL;
int index;
/* identify the attribute by name */
index = find_attr(resv_attr_def, psatl->al_name, RESV_ATR_LAST);
if (index < 0) {
/* didn`t recognize the name */
reply_badattr(PBSE_NOATTR, 1, psatl, preq);
return;
}
pdef = &resv_attr_def[index];
/* Does attribute's definition flags indicate that
* we have sufficient permission to write the attribute?
*/
resc_access_perm = resc_access_perm_save; /* reset */
if (psatl->al_flags & ATR_VFLAG_HOOK) {
resc_access_perm = ATR_DFLAG_USWR | \
ATR_DFLAG_OPWR | \
ATR_DFLAG_MGWR | \
ATR_DFLAG_SvWR | \
ATR_DFLAG_Creat;
}
if ((pdef->at_flags & resc_access_perm) == 0) {
reply_badattr(PBSE_ATTRRO, 1, psatl, preq);
return;
}
switch (index) {
case RESV_ATR_start:
if ((presv->ri_wattr[RESV_ATR_state].at_val.at_long != RESV_RUNNING) ||
!(presv->ri_qp->qu_numjobs)) {
temp = strtol(psatl->al_value, &end, 10);
if ((temp > time(NULL)) &&
(temp != presv->ri_wattr[RESV_ATR_start].at_val.at_long)) {
if (!is_standing || (temp < next_occr_start)) {
send_to_scheduler = RESV_START_TIME_MODIFIED;
presv->ri_alter_stime = presv->ri_wattr[RESV_ATR_start].at_val.at_long;
presv->ri_alter_flags |= RESV_START_TIME_MODIFIED;
} else {
snprintf(log_buffer, sizeof(log_buffer), "%s", msg_stdg_resv_occr_conflict);
log_event(PBSEVENT_RESV, PBS_EVENTCLASS_RESV, LOG_INFO,
preq->rq_ind.rq_modify.rq_objname, log_buffer);
req_reject(PBSE_STDG_RESV_OCCR_CONFLICT, 0, preq);
return;
}
} else {
req_reject(PBSE_BADTSPEC, 0, preq);
return;
}
} else {
if (presv->ri_qp->qu_numjobs)
req_reject(PBSE_RESV_NOT_EMPTY, 0, preq);
else
req_reject(PBSE_BADTSPEC, 0, preq);
return;
}
break;
case RESV_ATR_end:
temp = strtol(psatl->al_value, &end, 10);
if (temp == presv->ri_wattr[RESV_ATR_end].at_val.at_long) {
req_reject(PBSE_BADTSPEC, 0, preq);
return;
}
if (!is_standing || temp < next_occr_start) {
send_to_scheduler = RESV_END_TIME_MODIFIED;
presv->ri_alter_etime = presv->ri_wattr[RESV_ATR_end].at_val.at_long;
presv->ri_alter_flags |= RESV_END_TIME_MODIFIED;
} else {
snprintf(log_buffer, sizeof(log_buffer), "%s", msg_stdg_resv_occr_conflict);
log_event(PBSEVENT_RESV, PBS_EVENTCLASS_RESV, LOG_INFO,
preq->rq_ind.rq_modify.rq_objname, log_buffer);
req_reject(PBSE_STDG_RESV_OCCR_CONFLICT, 0, preq);
return;
}
break;
default:
break;
}
/* decode attribute */
rc = pdef->at_decode(&presv->ri_wattr[index],
psatl->al_name, psatl->al_resc, psatl->al_value);
if (rc != 0) {
reply_badattr(rc, 1, psatl, preq);
return;
}
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
}
resc_access_perm = resc_access_perm_save; /* restore perm */
if (send_to_scheduler) {
presv->ri_alter_state = presv->ri_wattr[RESV_ATR_state].at_val.at_long;
resv_setResvState(presv, RESV_BEING_ALTERED, presv->ri_qs.ri_substate);
/*"start", "end","duration", and "wall"; derive and check */
if (start_end_dur_wall(presv, RESC_RESV_OBJECT)) {
req_reject(PBSE_BADTSPEC, 0, preq);
resv_revert_alter_times(presv);
return;
}
presv->ri_wattr[RESV_ATR_resource].at_flags |= ATR_VFLAG_SET | ATR_VFLAG_MODIFY | ATR_VFLAG_MODCACHE;
}
bad = 0;
psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
if (psatl)
rc = modify_resv_attr(presv, psatl, preq->rq_perm, &bad);
if (send_to_scheduler)
set_scheduler_flag(SCH_SCHEDULE_RESV_RECONFIRM, dflt_scheduler);
(void)sprintf(log_buffer, "Attempting to modify reservation");
if (presv->ri_alter_flags & RESV_START_TIME_MODIFIED) {
strftime(buf, sizeof(buf), fmt, localtime((time_t *) &presv->ri_wattr[RESV_ATR_start].at_val.at_long));
log_len = strlen(log_buffer);
snprintf(log_buffer + log_len, sizeof(log_buffer) - log_len," start=%s", buf);
}
if (presv->ri_alter_flags & RESV_END_TIME_MODIFIED) {
strftime(buf, sizeof(buf), fmt, localtime((time_t *) &presv->ri_wattr[RESV_ATR_end].at_val.at_long));
log_len = strlen(log_buffer);
snprintf(log_buffer + log_len, sizeof(log_buffer) - log_len," end=%s", buf);
}
log_event(PBSEVENT_RESV, PBS_EVENTCLASS_RESV, LOG_INFO, preq->rq_ind.rq_modify.rq_objname, log_buffer);
if ((presv->ri_wattr[RESV_ATR_interactive].at_flags &
ATR_VFLAG_SET) == 0) {
char buf1[PBS_MAXUSER + PBS_MAXHOSTNAME + 32] = {0};
/*Not "interactive" so don't wait on scheduler, reply now*/
sprintf(buf, "%s ALTER REQUESTED", presv->ri_qs.ri_resvID);
sprintf(buf1, "requestor=%s@%s", preq->rq_user, preq->rq_host);
if ((rc = reply_text(preq, PBSE_NONE, buf))) {
/* reply failed, close connection; DON'T purge resv */
close_client(sock);
return;
}
} else {
/*Don't reply back until scheduler decides*/
long dt;
presv->ri_brp = preq;
dt = presv->ri_wattr[RESV_ATR_interactive].at_val.at_long;
/*reply with id and state no decision in +dt secs*/
(void)gen_future_reply(presv, dt);
(void)snprintf(buf, sizeof(buf), "requestor=%s@%s Interactive=%ld",
preq->rq_user, preq->rq_host, dt);
}
}
void
req_modifyjob(struct batch_request *preq)
{
int add_to_am_list = 0; /* if altered during sched cycle */
int bad = 0;
int jt; /* job type */
int newstate;
int newsubstate;
resource_def *outsideselect = NULL;
job *pjob;
svrattrl *plist;
resource *presc;
resource_def *prsd;
int rc;
int running = 0;
int sendmom = 0;
char hook_msg[HOOK_MSG_SIZE];
int mod_project = 0;
pbs_sched *psched;
switch (process_hooks(preq, hook_msg, sizeof(hook_msg),
pbs_python_set_interrupt)) {
case 0: /* explicit reject */
reply_text(preq, PBSE_HOOKERROR, hook_msg);
return;
case 1: /* explicit accept */
if (recreate_request(preq) == -1) { /* error */
/* we have to reject the request, as 'preq' */
/* may have been partly modified */
strcpy(hook_msg,
"modifyjob event: rejected request");
log_event(PBSEVENT_ERROR, PBS_EVENTCLASS_HOOK,
LOG_ERR, "", hook_msg);
reply_text(preq, PBSE_HOOKERROR, hook_msg);
return;
}
break;
case 2: /* no hook script executed - go ahead and accept event*/
break;
default:
log_event(PBSEVENT_DEBUG2, PBS_EVENTCLASS_HOOK,
LOG_INFO, "", "modifyjob event: accept req by default");
}
if (pseldef == NULL) /* do one time to keep handy */
pseldef = find_resc_def(svr_resc_def, "select", svr_resc_size);
pjob = chk_job_request(preq->rq_ind.rq_modify.rq_objname, preq, &jt);
if (pjob == NULL)
return;
if ((jt == IS_ARRAY_Single) || (jt == IS_ARRAY_Range)) {
req_reject(PBSE_IVALREQ, 0, preq);
return;
}
psched = find_sched_from_sock(preq->rq_conn);
/* allow scheduler to modify job */
if (psched == NULL) {
/* provisioning job is not allowed to be modified */
if ((pjob->ji_qs.ji_state == JOB_STATE_RUNNING) &&
(pjob->ji_qs.ji_substate == JOB_SUBSTATE_PROVISION)) {
req_reject(PBSE_BADSTATE, 0, preq);
return;
}
}
/* cannot be in exiting or transit, exiting has already be checked */
if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT) {
req_reject(PBSE_BADSTATE, 0, preq);
return;
}
plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
if (plist == NULL) { /* nothing to do */
reply_ack(preq);
return;
}
/*
* Special checks must be made:
* if during a scheduling cycle and certain attributes are altered,
* make a note of the job to prevent it from being run now;
* if job is running, only certain attributes/resources can be
* altered.
*/
if (pjob->ji_qs.ji_state == JOB_STATE_RUNNING) {
running = 1;
}
while (plist) {
int i;
i = find_attr(job_attr_def, plist->al_name, JOB_ATR_LAST);
/*
* Is the attribute being altered one which could change
* scheduling (ATR_DFLAG_SCGALT set) and if a scheduling
* cycle is in progress, then set flag to add the job to list
* of jobs which cannot be run in this cycle.
* If the scheduler itself sends a modify job request,
* no need to delay the job until next cycle.
*/
if ((psched == NULL) && (scheduler_jobs_stat) && (job_attr_def[i].at_flags & ATR_DFLAG_SCGALT))
add_to_am_list = 1;
/* Is the attribute modifiable in RUN state ? */
if (i < 0) {
reply_badattr(PBSE_NOATTR, 1, plist, preq);
return;
}
if ((running == 1) &&
((job_attr_def[i].at_flags & ATR_DFLAG_ALTRUN) == 0)) {
reply_badattr(PBSE_MODATRRUN, 1, plist, preq);
return;
}
if (i == (int)JOB_ATR_resource) {
prsd = find_resc_def(svr_resc_def, plist->al_resc,
svr_resc_size);
if (prsd == 0) {
reply_badattr(PBSE_UNKRESC, 1, plist, preq);
return;
}
/* is the specified resource modifiable while */
/* the job is running */
if (running) {
if ((prsd->rs_flags & ATR_DFLAG_ALTRUN) == 0) {
reply_badattr(PBSE_MODATRRUN, 1, plist, preq);
return;
}
sendmom = 1;
}
/* should the resource be only in a select spec */
if (prsd->rs_flags & ATR_DFLAG_CVTSLT && !outsideselect &&
plist->al_atopl.value && plist->al_atopl.value[0]) {
/* if "-lresource" is set and has non-NULL value,
** remember as potential bad resource
** if this appears along "select".
*/
outsideselect = prsd;
}
}
if (strcmp(plist->al_name, ATTR_project) == 0) {
mod_project = 1;
} else if ((strcmp(plist->al_name, ATTR_runcount) == 0) &&
((plist->al_flags & ATR_VFLAG_HOOK) == 0) &&
(plist->al_value != NULL) &&
(plist->al_value[0] != '\0') &&
((preq->rq_perm & (ATR_DFLAG_MGWR | ATR_DFLAG_OPWR)) == 0) &&
(atol(plist->al_value) < \
pjob->ji_wattr[(int)JOB_ATR_runcount].at_val.at_long)) {
sprintf(log_buffer,
"regular user %s@%s cannot decrease '%s' attribute value from %ld to %ld",
preq->rq_user, preq->rq_host, ATTR_runcount,
pjob->ji_wattr[(int)JOB_ATR_runcount].at_val.at_long,
atol(plist->al_value));
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_ERR,
pjob->ji_qs.ji_jobid, log_buffer);
req_reject(PBSE_PERM, 0, preq);
return;
}
plist = (svrattrl *)GET_NEXT(plist->al_link);
}
if (outsideselect) {
presc = find_resc_entry(&pjob->ji_wattr[(int)JOB_ATR_resource],
pseldef);
if (presc &&
((presc->rs_value.at_flags & ATR_VFLAG_DEFLT) == 0)) {
/* select is not a default, so reject qalter */
resc_in_err = strdup(outsideselect->rs_name);
req_reject(PBSE_INVALJOBRESC, 0, preq);
return;
}
}
/* modify the jobs attributes */
bad = 0;
plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
rc = modify_job_attr(pjob, plist, preq->rq_perm, &bad);
if (rc) {
if (pjob->ji_clterrmsg)
reply_text(preq, rc, pjob->ji_clterrmsg);
else
reply_badattr(rc, bad, plist, preq);
return;
}
/* If certain attributes modified and if in scheduling cycle */
/* then add to list of jobs which cannot be run in this cycle */
if (add_to_am_list)
am_jobs_add(pjob); /* see req_runjob() */
/* check if project attribute was requested to be modified to */
/* be the default project value */
if (mod_project && (pjob->ji_wattr[(int)JOB_ATR_project].at_flags & \
ATR_VFLAG_SET)) {
if (strcmp(pjob->ji_wattr[(int)JOB_ATR_project].at_val.at_str,
PBS_DEFAULT_PROJECT) == 0) {
sprintf(log_buffer, msg_defproject,
ATTR_project, PBS_DEFAULT_PROJECT);
#ifdef NAS /* localmod 107 */
log_event(PBSEVENT_DEBUG4, PBS_EVENTCLASS_JOB, LOG_INFO,
pjob->ji_qs.ji_jobid, log_buffer);
#else
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO,
pjob->ji_qs.ji_jobid, log_buffer);
#endif /* localmod 107 */
}
}
if (pjob->ji_wattr[(int)JOB_ATR_resource].at_flags & ATR_VFLAG_MODIFY) {
presc = find_resc_entry(&pjob->ji_wattr[(int)JOB_ATR_resource],
pseldef);
if (presc && (presc->rs_value.at_flags & ATR_VFLAG_DEFLT)) {
/* changing Resource_List and select is a default */
/* clear "select" so it is rebuilt inset_resc_deflt */
pseldef->rs_free(&presc->rs_value);
}
}
/* Reset any defaults resource limit which might have been unset */
if ((rc = set_resc_deflt((void *)pjob, JOB_OBJECT, NULL)) != 0) {
req_reject(rc, 0, preq);
return;
}
/* if job is not running, may need to change its state */
if (pjob->ji_qs.ji_state != JOB_STATE_RUNNING) {
svr_evaljobstate(pjob, &newstate, &newsubstate, 0);
(void)svr_setjobstate(pjob, newstate, newsubstate);
} else {
(void)job_save(pjob, SAVEJOB_FULL);
}
(void)sprintf(log_buffer, msg_manager, msg_jobmod,
preq->rq_user, preq->rq_host);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO,
pjob->ji_qs.ji_jobid, log_buffer);
/* if a resource limit changed for a running job, send to MOM */
if (sendmom) {
rc = relay_to_mom(pjob, preq, post_modify_req);
if (rc)
req_reject(rc, 0, preq); /* unable to get to MOM */
return;
}
reply_ack(preq);
}
int attr_atomic_node_set(
struct svrattrl *plist, /* list of pbs_attribute modif structs */
pbs_attribute *old, /* unused */
pbs_attribute *new_attr, /* new pbs_attribute array begins here */
attribute_def *pdef, /* begin array definition structs */
int limit, /* number elts in definition array */
int unkn, /* <0 unknown attrib not permitted */
int privil, /* requester's access privileges */
int *badattr) /* return list position wher bad */
{
int acc;
int index;
int listidx;
int rc = 0;
pbs_attribute temp;
listidx = 0;
while (plist)
{
/*Traverse loop for each client entered pbs_attribute*/
listidx++;
if ((index = find_attr(pdef, plist->al_name, limit)) < 0)
{
if (unkn < 0) /*if unknown attr not allowed*/
{
rc = PBSE_NOATTR;
break;
}
else
index = unkn; /*if unknown attr are allowed*/
}
/* The name of the pbs_attribute is in the definitions list*/
/* Now, have we privilege to set the pbs_attribute ? */
/* Check access capabilities specified in the attrdef */
/* against the requestor's privilege level */
acc = (pdef + index)->at_flags & ATR_DFLAG_ACCESS;
if ((acc & privil & ATR_DFLAG_WRACC) == 0)
{
if (privil & ATR_DFLAG_SvWR)
{
/* from a daemon, just ignore this pbs_attribute */
plist = (struct svrattrl *)GET_NEXT(plist->al_link);
continue;
}
else
{
/*from user, no write access to pbs_attribute */
rc = PBSE_ATTRRO;
break;
}
}
/*decode new value*/
clear_attr(&temp, pdef + index);
if ((rc = (pdef + index)->at_decode(&temp, plist->al_name,
plist->al_resc, plist->al_value,0) != 0))
{
if ((rc == PBSE_UNKRESC) && (unkn > 0))
rc = 0; /*ignore the "error"*/
else
break;
}
/*update "new" with "temp", MODIFY is set on "new" if changed*/
(new_attr + index)->at_flags &= ~ATR_VFLAG_MODIFY;
if ((plist->al_op != INCR) && (plist->al_op != DECR) &&
(plist->al_op != SET) && (plist->al_op != INCR_OLD))
plist->al_op = SET;
if (temp.at_flags & ATR_VFLAG_SET)
{
/* "temp" has a data value, use it to update "new" */
if ((rc = (pdef + index)->at_set(new_attr + index, &temp, plist->al_op)) != 0)
{
(pdef + index)->at_free(&temp);
break;
}
}
else if (temp.at_flags & ATR_VFLAG_MODIFY)
{
(pdef + index)->at_free(new_attr + index);
(new_attr + index)->at_flags |= ATR_VFLAG_MODIFY;
}
(pdef + index)->at_free(&temp);
plist = (struct svrattrl *)GET_NEXT(plist->al_link);
}
if (rc != 0)
{
/*"at_free" functions get invoked by upstream caller*/
/*invoking attr_atomic_kill() on the array of */
/*node-pbs_attribute structs-- any hanging structs are */
/*freed and then the node-pbs_attribute array is freed */
*badattr = listidx; /*the svrattrl that gave a problem*/
}
return (rc);
}
int line_area(struct Map_info *In, int *field, struct Map_info *Tmp,
struct Map_info *Out, struct field_info *Fi,
dbDriver * driver, int operator, int *ofield,
ATTRIBUTES * attr, struct ilist *BList)
{
int line, nlines, ncat;
struct line_pnts *Points;
struct line_cats *Cats, *ACats, *OCats;
char buf[1000];
dbString stmt;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ACats = Vect_new_cats_struct();
OCats = Vect_new_cats_struct();
db_init_string(&stmt);
G_message(_("Breaking lines..."));
Vect_break_lines_list(Tmp, NULL, BList, GV_LINE | GV_BOUNDARY, NULL);
/*
G_message(_("Merging lines..."));
Vect_merge_lines(Tmp, GV_LINE, NULL, NULL);
*/
nlines = Vect_get_num_lines(Tmp);
/* Warning!: cleaning process (break) creates new vertices which are usually slightly
* moved (RE), to compare such new vertex with original input is a problem?
*
* TODO?: would it be better to copy centroids also and query output map?
*/
/* Check if the line is inside or outside binput area */
G_message(_("Selecting lines..."));
ncat = 1;
for (line = 1; line <= nlines; line++) {
int ltype;
G_percent(line, nlines, 1); /* must be before any continue */
if (!Vect_line_alive(Tmp, line))
continue;
ltype = Vect_get_line_type(Tmp, line);
if (ltype == GV_BOUNDARY) { /* No more needed */
continue;
}
/* Now the type should be only GV_LINE */
/* Decide if the line is inside or outside the area. In theory:
* 1) All vertices outside
* - easy, first vertex must be outside
* 2) All vertices inside
* 3) All vertices on the boundary, we take it as inside (attention,
* result of Vect_point_in_area() for points on segments between vertices may be both
* inside or outside, because of representation of numbers)
* 4) One or two end vertices on the boundary, all others outside
* 5) One or two end vertices on the boundary, all others inside
*
*/
/* Note/TODO: the test done is quite simple, check the point in the middle of segment.
* If the line overlaps the boundary, the result may be both outside and inside
* this should be solved (check angles?)
* This should not happen if Vect_break_lines_list() works correctly
*/
/* merge here */
merge_line(Tmp, line, Points, Cats);
G_debug(3, "line = %d", line);
point_area(&(In[1]), field[1], (Points->x[0] + Points->x[1]) / 2,
(Points->y[0] + Points->y[1]) / 2, ACats);
if ((ACats->n_cats > 0 && operator == OP_AND) ||
(ACats->n_cats == 0 && operator == OP_NOT)) {
int i;
/* Point is inside */
G_debug(3, "OK, write line, line ncats = %d area ncats = %d",
Cats->n_cats, ACats->n_cats);
Vect_reset_cats(OCats);
if (ofield[0] > 0) {
/* rewrite with all combinations of acat - bcat (-1 in cycle for null) */
for (i = -1; i < Cats->n_cats; i++) { /* line cats */
int j;
if (i == -1 && Cats->n_cats > 0)
continue; /* no need to make null */
for (j = -1; j < ACats->n_cats; j++) {
if (j == -1 && ACats->n_cats > 0)
continue; /* no need to make null */
if (ofield[0] > 0)
Vect_cat_set(OCats, ofield[0], ncat);
/* Attributes */
if (driver) {
ATTR *at;
sprintf(buf, "insert into %s values ( %d", Fi->table,
ncat);
db_set_string(&stmt, buf);
/* cata */
if (i >= 0) {
if (attr[0].columns) {
at = find_attr(&(attr[0]), Cats->cat[i]);
if (!at)
G_fatal_error(_("Attribute not found"));
if (at->values)
db_append_string(&stmt, at->values);
else
db_append_string(&stmt,
attr[0].null_values);
}
else {
sprintf(buf, ", %d", Cats->cat[i]);
db_append_string(&stmt, buf);
}
}
else {
if (attr[0].columns) {
db_append_string(&stmt, attr[0].null_values);
}
else {
sprintf(buf, ", null");
db_append_string(&stmt, buf);
}
}
/* catb */
if (j >= 0) {
if (attr[1].columns) {
at = find_attr(&(attr[1]), ACats->cat[j]);
if (!at)
G_fatal_error(_("Attribute not found"));
if (at->values)
db_append_string(&stmt, at->values);
else
db_append_string(&stmt,
attr[1].null_values);
}
else {
sprintf(buf, ", %d", ACats->cat[j]);
db_append_string(&stmt, buf);
}
}
else {
if (attr[1].columns) {
db_append_string(&stmt, attr[1].null_values);
}
else {
sprintf(buf, ", null");
db_append_string(&stmt, buf);
}
}
db_append_string(&stmt, " )");
G_debug(3, "%s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_warning(_("Unable to insert new record: '%s'"),
db_get_string(&stmt));
}
ncat++;
}
}
}
/* Add cats from input vectors */
if (ofield[1] > 0 && field[0] > 0) {
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == field[0])
Vect_cat_set(OCats, ofield[1], Cats->cat[i]);
}
}
if (ofield[2] > 0 && field[1] > 0 && ofield[1] != ofield[2]) {
for (i = 0; i < ACats->n_cats; i++) {
if (ACats->field[i] == field[1])
Vect_cat_set(OCats, ofield[2], ACats->cat[i]);
}
}
Vect_write_line(Out, ltype, Points, OCats);
}
}
return 0;
}
void req_quejob(
struct batch_request *preq) /* ptr to the decoded request */
{
char *id = "req_quejob";
char basename[PBS_JOBBASE + 1];
int created_here = 0;
int index;
char *jid;
attribute_def *pdef;
job *pj;
svrattrl *psatl;
int rc;
int sock = preq->rq_conn;
int IsCheckpoint = 0;
/* set basic (user) level access permission */
resc_access_perm = ATR_DFLAG_USWR | ATR_DFLAG_Creat;
if (PBSNodeCheckProlog)
{
check_state(1);
mom_server_all_update_stat();
if (internal_state & INUSE_DOWN)
{
req_reject(PBSE_MOMREJECT,0,preq,NULL,NULL);
return;
}
}
if (preq->rq_fromsvr)
{
/* from another server - accept the extra attributes */
resc_access_perm |= ATR_DFLAG_MGWR | ATR_DFLAG_SvWR | ATR_DFLAG_MOM;
jid = preq->rq_ind.rq_queuejob.rq_jid;
}
else
{
/* request must be from server */
log_err(errno, id, "request not from server");
req_reject(PBSE_IVALREQ, 0, preq, NULL, "request not received from server");
return;
}
/* does job already exist, check both old and new jobs */
if ((pj = find_job(jid)) == NULL)
{
pj = (job *)GET_NEXT(svr_newjobs);
while (pj != NULL)
{
if (!strcmp(pj->ji_qs.ji_jobid, jid))
break;
pj = (job *)GET_NEXT(pj->ji_alljobs);
}
}
/*
* New job ...
*
* for MOM - rather than make up a hashname, we use the name sent
* to us by the server as an attribute.
*/
psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_queuejob.rq_attr);
while (psatl != NULL)
{
if (!strcmp(psatl->al_name,ATTR_hashname))
{
strcpy(basename,psatl->al_value);
break;
}
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
}
if (pj != NULL)
{
/* newly queued job already exists */
if (pj->ji_qs.ji_substate == JOB_SUBSTATE_RUNNING)
{
/* FAILURE - job exists and is running */
log_err(errno,id,"cannot queue new job, job exists and is running");
req_reject(PBSE_JOBEXIST,0,preq,NULL,"job is running");
return;
}
/* if checkpointed, then keep old and skip rest of process */
if (pj->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE)
{
IsCheckpoint = 1;
} /* END if (pj->ji_qs.ji_svrflags & JOB_SVFLG_CHECKPOINT_FILE) */
else
{
/* unlink job from svr_alljobs since it will be placed on newjobs */
delete_link(&pj->ji_alljobs);
}
} /* END if (pj != NULL) */
else
{
/* if not already here, allocate job struct */
if ((pj = job_alloc()) == NULL)
{
/* FAILURE */
req_reject(PBSE_SYSTEM, 0, preq, NULL, "cannot allocate new job structure");
return;
}
} /* END else (pj != NULL) */
if (IsCheckpoint == 0)
{
strcpy(pj->ji_qs.ji_jobid,jid);
strcpy(pj->ji_qs.ji_fileprefix,basename);
pj->ji_modified = 1;
pj->ji_qs.ji_svrflags = created_here;
pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW;
}
/* decode attributes from request into job structure */
psatl = (svrattrl *)GET_NEXT(preq->rq_ind.rq_queuejob.rq_attr);
while (psatl != NULL)
{
if (IsCheckpoint == 1)
{
if (strcmp(psatl->al_name,ATTR_checkpoint_name) &&
strcmp(psatl->al_name,ATTR_v))
{
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
continue;
}
}
/* identify the attribute by name */
index = find_attr(job_attr_def,psatl->al_name,JOB_ATR_LAST);
if (index < 0)
{
/* FAILURE */
/* didn`t recognize the name */
job_purge(pj); /* CRI - 12/20/2004 */
reply_badattr(PBSE_NOATTR,1,psatl,preq);
return;
}
pdef = &job_attr_def[index];
/* Is attribute not writeable by manager or by a server? */
if ((pdef->at_flags & resc_access_perm) == 0)
{
/* FAILURE */
job_purge(pj);
reply_badattr(PBSE_ATTRRO,1,psatl,preq);
return;
}
/* decode attribute */
if (!strcmp(psatl->al_name,ATTR_v))
{
rc = decode_arst_merge(
&pj->ji_wattr[index],
psatl->al_name,
psatl->al_resc,
psatl->al_value);
}
else
{
rc = pdef->at_decode(
&pj->ji_wattr[index],
psatl->al_name,
psatl->al_resc,
psatl->al_value);
}
if (rc != 0)
{
/* FAILURE */
/* all errors are fatal for MOM */
job_purge(pj);
reply_badattr(rc,1,psatl,preq);
return;
}
if (psatl->al_op == DFLT)
{
if (psatl->al_resc)
{
resource *presc;
resource_def *prdef;
prdef = find_resc_def(svr_resc_def,psatl->al_resc,svr_resc_size);
if (prdef == NULL)
{
job_purge(pj);
reply_badattr(rc,1,psatl, preq);
return;
}
presc = find_resc_entry(&pj->ji_wattr[index],prdef);
if (presc != NULL)
presc->rs_value.at_flags |= ATR_VFLAG_DEFLT;
}
else
{
pj->ji_wattr[index].at_flags |= ATR_VFLAG_DEFLT;
}
} /* END if (psatl->al_op == DFLT) */
psatl = (svrattrl *)GET_NEXT(psatl->al_link);
} /* END while (psatl != NULL) */
if (IsCheckpoint == 1)
{
pj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSIN;
if (reply_jobid(preq,pj->ji_qs.ji_jobid,BATCH_REPLY_CHOICE_Queue) == 0)
{
delete_link(&pj->ji_alljobs);
append_link(&svr_newjobs,&pj->ji_alljobs,pj);
pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW;
pj->ji_qs.ji_un.ji_newt.ji_fromsock = sock;
pj->ji_qs.ji_un.ji_newt.ji_fromaddr = get_connectaddr(sock);
pj->ji_qs.ji_un.ji_newt.ji_scriptsz = 0;
/* Per Eric R., req_mvjobfile was giving error in open_std_file,
showed up as fishy error message */
if (pj->ji_grpcache != NULL)
{
free(pj->ji_grpcache);
pj->ji_grpcache = NULL;
}
}
else
{
close_conn(sock);
}
/* SUCCESS */
return;
}
/* set remaining job structure elements */
pj->ji_qs.ji_state = JOB_STATE_TRANSIT;
pj->ji_qs.ji_substate = JOB_SUBSTATE_TRANSIN;
pj->ji_wattr[(int)JOB_ATR_mtime].at_val.at_long = (long)time_now;
pj->ji_wattr[(int)JOB_ATR_mtime].at_flags |= ATR_VFLAG_SET;
pj->ji_qs.ji_un_type = JOB_UNION_TYPE_NEW;
pj->ji_qs.ji_un.ji_newt.ji_fromsock = sock;
pj->ji_qs.ji_un.ji_newt.ji_fromaddr = get_connectaddr(sock);
pj->ji_qs.ji_un.ji_newt.ji_scriptsz = 0;
/* acknowledge the request with the job id */
if (reply_jobid(preq, pj->ji_qs.ji_jobid, BATCH_REPLY_CHOICE_Queue) != 0)
{
/* reply failed, purge the job and close the connection */
close_conn(sock);
job_purge(pj);
return;
}
/* link job into server's new jobs list request */
append_link(&svr_newjobs, &pj->ji_alljobs, pj);
return;
} /* END req_quejob() */