var CLEAR_FIELDS = 6;
var NEW_RECORD = 7;
var CLEAR_RECORDS = 8;
+
+/**
+ * event: FIELD_STATE_CHANGED
+ *
+ * Parameters:
+ * dict :
+ * .request : ???? used to be FIELD_REQUEST_ADD / FIELD_REQUEST_REMOVE
+ * .key : ??? the key fields of the record
+ * .value : the key of the record who has received an update
+ * .status : the new state of the record
+ * TODO rename to state, and use values from STATE_SET
+ */
var FIELD_STATE_CHANGED = 9;
var IN_PROGRESS = 101;
var DONE = 102;
/* Update requests related to subqueries */
+
+/**
+ * event: SET_ADD
+ *
+ * Parameters:
+ * string : The key of the element being added
+ */
var SET_ADD = 201;
+
+/**
+ * event: SET_REMOVED
+ *
+ * Parameters:
+ * string : The key of the element being removed
+ */
var SET_REMOVED = 202;
+
// request
var FIELD_REQUEST_CHANGE = 301;
var FIELD_REQUEST_ADD = 302;
var FIELD_REQUEST_REMOVE = 303;
var FIELD_REQUEST_ADD_RESET = 304;
var FIELD_REQUEST_REMOVE_RESET = 305;
-// status
+// status (XXX Should be deprecated)
var FIELD_REQUEST_PENDING = 401;
var FIELD_REQUEST_SUCCESS = 402;
var FIELD_REQUEST_FAILURE = 403;
+var STATUS_OKAY = 404;
+var STATUS_SET_WARNING = 405;
+var STATUS_ADD_WARNING = 406;
+var STATUS_REMOVE_WARNING = 407;
+var STATUS_RESET = 408;
+
+/* Requests for query cycle */
+var RUN_UPDATE = 601;
+
+/* MANIFOLD types */
+var TYPE_VALUE = 1;
+var TYPE_RECORD = 2;
+var TYPE_LIST_OF_VALUES = 3;
+var TYPE_LIST_OF_RECORDS = 4;
+
+/******************************************************************************
+ * QUERY STATUS (for manifold events)
+ ******************************************************************************/
-/* Query status */
var STATUS_NONE = 500; // Query has not been started yet
var STATUS_GET_IN_PROGRESS = 501; // Query has been sent, no result has been received
var STATUS_GET_RECEIVED = 502; // Success
var STATUS_UPDATE_RECEIVED = 506;
var STATUS_UPDATE_ERROR = 507;
-/* Requests for query cycle */
-var RUN_UPDATE = 601;
+/******************************************************************************
+ * QUERY STATE (for query_store)
+ ******************************************************************************/
-/* MANIFOLD types */
-var TYPE_VALUE = 1;
-var TYPE_RECORD = 2;
-var TYPE_LIST_OF_VALUES = 3;
-var TYPE_LIST_OF_RECORDS = 4;
+// XXX Rendundant with query status ?
+
+var QUERY_STATE_INIT = 0;
+var QUERY_STATE_INPROGRESS = 1;
+var QUERY_STATE_DONE = 2;
+
+/******************************************************************************
+ * RECORD STATES (for query_store)
+ ******************************************************************************/
+
+var STATE_SET = 0;
+var STATE_WARNINGS = 1;
+var STATE_VISIBLE = 2;
+
+// STATE_SET : enum
+var STATE_SET_IN = 0;
+var STATE_SET_OUT = 1;
+var STATE_SET_IN_PENDING = 2;
+var STATE_SET_OUT_PENDING = 3;
+var STATE_SET_IN_SUCCESS = 4;
+var STATE_SET_OUT_SUCCESS = 5;
+var STATE_SET_IN_FAILURE = 6;
+var STATE_SET_OUT_FAILURE = 7;
+
+// STATE_WARNINGS : dict
+
+// STATE_VISIBLE : boolean
+
+/******************************************************************************
+ * CONSTRAINTS
+ ******************************************************************************/
+var CONSTRAINT_RESERVABLE_LEASE = 0;
// A structure for storing queries
-function QueryExt(query, parent_query_ext, main_query_ext, update_query_ext, disabled) {
+function QueryExt(query, parent_query_ext, main_query_ext, update_query_ext, disabled, domain_query_ext) {
/* Constructor */
if (typeof query == "undefined")
this.main_query_ext = (typeof main_query_ext == "undefined") ? null : main_query_ext;
this.update_query_ext = (typeof update_query_ext == "undefined") ? null : update_query_ext;
this.update_query_orig_ext = (typeof update_query_orig_ext == "undefined") ? null : update_query_orig_ext;
- this.disabled = (typeof update_query_ext == "undefined") ? false : disabled;
+ this.disabled = (typeof disabled == "undefined") ? false : disabled;
+
+ // A domain query is a query that is issued to retrieve all possible values for a set
+ // eg. all resources that can be attached to a slice
+ // It is null unless we are a subquery for which a domain query has been issued
+ this.domain_query_ext = (typeof domain_query_ext == "undefined") ? null : domain_query_ext;
+
+ // Set members to buffer until the domain query is completed
+ // A list of keys
+ this.set_members = [];
+
+ // The set query is the query for which the domain query has been issued.
+ // It is null unless the query is a domain query
+ this.set_query_ext = (typeof set_query_ext == "undefined") ? null : domain_query_ext;
- this.status = null;
- this.results = null;
+ this.query_state = QUERY_STATE_INIT;
+
+ // Results from a query consists in a dict that maps keys to records
+ this.records = new Hashtable();
+
+ // Status is a dict that maps keys to record status
+ this.state = new Hashtable();
+
+ // Filters that impact visibility in the local interface
+ this.filters = [];
+
+ // XXX Until we find a better solution
+ this.num_pending = 0;
+ this.num_unconfigured = 0;
+
// update_query null unless we are a main_query (aka parent_query == null); only main_query_fields can be updated...
}
// We also need to insert all queries and subqueries from the analyzed_query
// XXX We need the root of all subqueries
query.iter_subqueries(function(sq, data, parent_query) {
- if (parent_query)
+ var parent_query_ext;
+ if (parent_query) {
parent_query_ext = manifold.query_store.find_analyzed_query_ext(parent_query.query_uuid);
- else
+ } else {
parent_query_ext = null;
+ }
// XXX parent_query_ext == false
// XXX main.subqueries = {} # Normal, we need analyzed_query
sq_ext = new QueryExt(sq, parent_query_ext, query_ext)
+
+ if (parent_query) {
+ /* Let's issue a query for the subquery domain. This query will not need any update etc.
+ eg. for resources in a slice, we also query all resources */
+ var all_fields = manifold.metadata.get_field_names(sq.object);
+ var domain_query = new ManifoldQuery('get', sq.object, 'now', [], {}, all_fields);
+ //var domain_query = new ManifoldQuery('get', sq.object);
+
+ console.log("Created domain query", domain_query);
+ var domain_query_ext = new QueryExt(domain_query);
+
+ domain_query_ext.set_query_ext = sq_ext;
+ sq_ext.domain_query_ext = domain_query_ext;
+
+ // One of these two is useless ?
+ manifold.query_store.main_queries[domain_query.query_uuid] = domain_query_ext;
+ manifold.query_store.analyzed_queries[domain_query.query_uuid] = domain_query_ext;
+
+ // XXX This query is run before the plugins are initialized and listening
+ manifold.run_query(domain_query);
+ }
+
manifold.query_store.analyzed_queries[sq.query_uuid] = sq_ext;
});
/* Searching */
- this.find_query_ext = function(query_uuid) {
+ this.find_query_ext = function(query_uuid)
+ {
return this.main_queries[query_uuid];
}
- this.find_query = function(query_uuid) {
+ this.find_query = function(query_uuid)
+ {
return this.find_query_ext(query_uuid).query;
}
- this.find_analyzed_query_ext = function(query_uuid) {
+ this.find_analyzed_query_ext = function(query_uuid)
+ {
return this.analyzed_queries[query_uuid];
}
- this.find_analyzed_query = function(query_uuid) {
+ this.find_analyzed_query = function(query_uuid)
+ {
return this.find_analyzed_query_ext(query_uuid).query;
}
+
+ this.state_dict_create = function(default_set)
+ {
+ default_set = (default_set === undefined) ? STATE_SET_OUT : default_set;
+ var state_dict = {};
+ // We cannot use constants in literal definition, so...
+ state_dict[STATE_WARNINGS] = {};
+ state_dict[STATE_SET] = default_set;
+ state_dict[STATE_VISIBLE] = true;
+ return state_dict;
+ }
+
+ // RECORDS
+
+ this.set_records = function(query_uuid, records, default_set)
+ {
+ default_set = (default_set === undefined) ? STATE_SET_OUT : default_set;
+
+ var self = this;
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ var record_key = manifold.metadata.get_key(query_ext.query.object);
+ $.each(records, function(i, record) {
+ var key = manifold.metadata.get_key(query_ext.query.object);
+ // ["start_time", "resource", "end_time"]
+ // ["urn"]
+
+ var record_key_value = manifold.record_get_value(record, record_key);
+ query_ext.records.put(record_key_value, record);
+
+ if (!(query_ext.state.get(record_key_value)))
+ query_ext.state.put(record_key_value, self.state_dict_create(default_set));
+ });
+ }
+
+ this.get_records = function(query_uuid)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ return query_ext.records.values();
+ }
+
+ this.get_record = function(query_uuid, record_key)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ return query_ext.records.get(record_key);
+ }
+
+ this.add_record = function(query_uuid, record, new_state)
+ {
+ var query_ext, key, record_key;
+ query_ext = this.find_analyzed_query_ext(query_uuid);
+
+ if (typeof(record) == 'object') {
+ key = manifold.metadata.get_key(query_ext.query.object);
+ record_key = manifold.record_get_value(record, key);
+ } else {
+ record_key = record;
+ }
+
+ var record_entry = query_ext.records.get(record_key);
+ if (!record_entry)
+ query_ext.records.put(record_key, record);
+
+ manifold.query_store.set_record_state(query_uuid, record_key, STATE_SET, new_state);
+ }
+
+ this.remove_record = function(query_uuid, record, new_state)
+ {
+ var query_ext, key, record_key;
+ query_ext = this.find_analyzed_query_ext(query_uuid);
+
+ if (typeof(record) == 'object') {
+ key = manifold.metadata.get_key(query_ext.query.object);
+ record_key = manifold.record_get_value(record, key);
+ } else {
+ record_key = record;
+ }
+
+ manifold.query_store.set_record_state(query_uuid, record_key, STATE_SET, new_state);
+ }
+
+ this.iter_records = function(query_uuid, callback)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ query_ext.records.each(callback);
+ //callback = function(record_key, record)
+ }
+
+ this.iter_visible_records = function(query_uuid, callback)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ query_ext.records.each(function(record_key, record) {
+ if (query_ext.state.get(record_key)[STATE_VISIBLE]) // .STATE_VISIBLE would be for the string key
+ callback(record_key, record);
+ });
+ //callback = function(record_key, record)
+
+ }
+
+ // STATE
+
+ this.set_record_state = function(query_uuid, result_key, state, value)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ var state_dict = query_ext.state.get(result_key);
+ if (!state_dict)
+ state_dict = this.state_dict_create();
+
+ state_dict[state] = value;
+
+ query_ext.state.put(result_key, state_dict);
+ }
+
+ this.get_record_state = function(query_uuid, result_key, state)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ var state_dict = query_ext.state.get(result_key);
+ if (!state_dict)
+ return null;
+ return state_dict[state];
+ }
+
+ // FILTERS
+
+ this.add_filter = function(query_uuid, filter)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ // XXX When we update a filter
+ query_ext.filters.push(filter);
+
+ this.apply_filters(query_uuid);
+
+ }
+
+ this.update_filter = function(query_uuid, filter)
+ {
+ // XXX
+
+ this.apply_filters(query_uuid);
+ }
+
+ this.remove_filter = function(query_uuid, filter)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ query_ext.filters = $.grep(query_ext.filters, function(x) {
+ return x == filter;
+ });
+
+ this.apply_filters(query_uuid);
+ }
+
+ this.get_filters = function(query_uuid)
+ {
+ var query_ext = this.find_analyzed_query_ext(query_uuid);
+ return query_ext.filters;
+ }
+
+ this.recount = function(query_uuid)
+ {
+ var query_ext;
+ var is_reserved, is_pending, in_set, is_unconfigured;
+
+ query_ext = manifold.query_store.find_analyzed_query_ext(query_uuid);
+ query_ext.num_pending = 0;
+ query_ext.num_unconfigured = 0;
+
+ this.iter_records(query_uuid, function(record_key, record) {
+ var record_state = manifold.query_store.get_record_state(query_uuid, record_key, STATE_SET);
+ var record_warnings = manifold.query_store.get_record_state(query_uuid, record_key, STATE_WARNINGS);
+
+ is_reserved = (record_state == STATE_SET_IN)
+ || (record_state == STATE_SET_OUT_PENDING)
+ || (record_state == STATE_SET_IN_SUCCESS)
+ || (record_state == STATE_SET_OUT_FAILURE);
+
+ is_pending = (record_state == STATE_SET_IN_PENDING)
+ || (record_state == STATE_SET_OUT_PENDING);
+
+ in_set = (record_state == STATE_SET_IN) // should not have warnings
+ || (record_state == STATE_SET_IN_PENDING)
+ || (record_state == STATE_SET_IN_SUCCESS)
+ || (record_state == STATE_SET_OUT_FAILURE); // should not have warnings
+
+ is_unconfigured = (in_set && !$.isEmptyObject(record_warnings));
+
+ /* Let's update num_pending and num_unconfigured at this stage */
+ if (is_pending)
+ query_ext.num_pending++;
+ if (is_unconfigured)
+ query_ext.num_unconfigured++;
+ });
+
+ }
+
+ this.apply_filters = function(query_uuid)
+ {
+ var start = new Date().getTime();
+
+ // Toggle visibility of records according to the different filters.
+
+ var self = this;
+ var filters = this.get_filters(query_uuid);
+ var col_value;
+ /* Let's update num_pending and num_unconfigured at this stage */
+
+ // Adapted from querytable._querytable_filter()
+
+ this.iter_records(query_uuid, function(record_key, record) {
+ var is_reserved, is_pending, in_set, is_unconfigured;
+ var visible = true;
+
+ var record_state = manifold.query_store.get_record_state(query_uuid, record_key, STATE_SET);
+ var record_warnings = manifold.query_store.get_record_state(query_uuid, record_key, STATE_WARNINGS);
+
+ is_reserved = (record_state == STATE_SET_IN)
+ || (record_state == STATE_SET_OUT_PENDING)
+ || (record_state == STATE_SET_IN_SUCCESS)
+ || (record_state == STATE_SET_OUT_FAILURE);
+
+ is_pending = (record_state == STATE_SET_IN_PENDING)
+ || (record_state == STATE_SET_OUT_PENDING);
+
+ in_set = (record_state == STATE_SET_IN) // should not have warnings
+ || (record_state == STATE_SET_IN_PENDING)
+ || (record_state == STATE_SET_IN_SUCCESS)
+ || (record_state == STATE_SET_OUT_FAILURE); // should not have warnings
+
+ is_unconfigured = (in_set && !$.isEmptyObject(record_warnings));
+
+ // We go through each filter and decide whether it affects the visibility of the record
+ $.each(filters, function(index, filter) {
+ var key = filter[0];
+ var op = filter[1];
+ var value = filter[2];
+
+
+ /* We do some special handling for the manifold:status filter
+ * predicates. */
+
+ if (key == 'manifold:status') {
+ if (op != '=' && op != '==') {
+ // Unsupported filter, let's ignore it
+ console.log("Unsupported filter on manifold:status. Should be EQUAL only.");
+ return true; // ~ continue
+ }
+
+ switch (value) {
+ case 'reserved':
+ // true => ~ continue
+ // false => ~ break
+ visible = is_reserved;
+ return visible;
+ case 'unconfigured':
+ visible = is_unconfigured;
+ return visible;
+ case 'pending':
+ visible = is_pending;
+ return visible;
+ }
+ return false; // ~ break
+ }
+
+ /* Normal filtering behaviour (according to the record content) follows... */
+ col_value = manifold.record_get_value(record, key);
+
+ // When the filter does not match, we hide the column by default
+ if (col_value === 'undefined') {
+ visible = false;
+ return false; // ~ break
+ }
+
+ // XXX This should accept pluggable filtering functions.
+
+
+ /* Test whether current filter is compatible with the column */
+ if (op == '=' || op == '==') {
+ if ( col_value != value || col_value==null || col_value=="" || col_value=="n/a")
+ visible = false;
+ }else if (op == 'included') {
+ $.each(value, function(i,x) {
+ if(x == col_value){
+ visible = true;
+ return false; // ~ break
+ }else{
+ visible = false;
+ }
+ });
+ }else if (op == '!=') {
+ if ( col_value == value || col_value==null || col_value=="" || col_value=="n/a")
+ visible = false;
+ } else if(op=='<') {
+ if ( parseFloat(col_value) >= value || col_value==null || col_value=="" || col_value=="n/a")
+ visible = false;
+ } else if(op=='>') {
+ if ( parseFloat(col_value) <= value || col_value==null || col_value=="" || col_value=="n/a")
+ visible = false;
+ } else if(op=='<=' || op=='≤') {
+ if ( parseFloat(col_value) > value || col_value==null || col_value=="" || col_value=="n/a")
+ visible = false;
+ } else if(op=='>=' || op=='≥') {
+ if ( parseFloat(col_value) < value || col_value==null || col_value=="" || col_value=="n/a")
+ visible = false;
+ }else{
+ // How to break out of a loop ?
+ alert("filter not supported");
+ return false; // break
+ }
+
+ });
+
+ // Set the visibility status in the query store
+ self.set_record_state(query_uuid, record_key, STATE_VISIBLE, visible);
+ });
+
+ var end = new Date().getTime();
+ console.log("APPLY FILTERS took", end - start, "ms");
+
+ }
+
}
/*!
}
},
+ /**
+ * Args:
+ * fields: A String instance (field name), or a set of String instances
+ * (field names) # XXX tuple !!
+ * Returns:
+ * If fields is a String, return the corresponding value.
+ * If fields is a set, return a tuple of corresponding value.
+ *
+ * Raises:
+ * KeyError if at least one of the fields is not found
+ */
+ record_get_value: function(record, fields)
+ {
+ if (typeof(fields) === 'string') {
+ if (fields.indexOf('.') != -1) {
+ key_subkey = key.split('.', 2);
+ key = key_subkey[0];
+ subkey = key_subkey[1];
+
+ if (record.indexOf(key) == -1) {
+ return null;
+ }
+ // Tests if the following is an array (typeof would give object)
+ if (Object.prototype.toString.call(record[key]) === '[object Array]') {
+ // Records
+ return $.map(record[key], function(subrecord) { return manifold.record_get_value(subrecord, subkey) });
+ } else if (typeof(record) == 'object') {
+ // Record
+ return manifold.record_get_value(record[key], subkey);
+ } else {
+ console.log('Unknown field');
+ }
+ } else {
+ return record[fields];
+ }
+ } else {
+ // see. get_map_entries
+ if (fields.length == 1)
+ return manifold.record_get_value(record, fields[0])
+
+ // Build a new record
+ var ret = {};
+ $.each(fields, function(i, field) {
+ ret[field] = manifold.record_get_value(record, field);
+ });
+ ret.hashCode = record.hashCode;
+ ret.equals = record.equals;
+ return ret;
+ // this was an array, we want a dictionary
+ //return $.map(fields, function(x) { manifold.record_get_value(record, x) });
+
+ }
+ },
+
+ record_hashcode: function(key_fields)
+ {
+ return function() {
+ ret = "";
+ for (i=0; i < key_fields.length; i++)
+ ret += "@@" + this[key_fields[i]];
+ return ret;
+ };
+ },
+
+ record_equals: function(key_fields)
+ {
+ var self = this;
+
+ return function(other) {
+ for (i=0; i < key_fields.length; i++) {
+ var this_value = this[key_fields[i]];
+ var other_value = other[key_fields[i]];
+
+ var this_type = self.get_type(this_value);
+ var other_type = self.get_type(other_value);
+ if (this_type != other_type)
+ return false;
+
+ switch (this_type) {
+ case TYPE_VALUE:
+ case TYPE_LIST_OF_VALUES:
+ if (this_value != other_value)
+ return false;
+ break;
+ case TYPE_RECORD:
+ if (!(record_equals(this_value, other_value)))
+ return false;
+ break;
+ case TYPE_LIST_OF_RECORDS:
+ if (this_value.length != other_value.length)
+ return false;
+ for (i = 0; i < this_value.length; i++)
+ if (!(record_equals(this_value, other_value)))
+ return false;
+ break;
+ }
+ }
+ return true;
+ };
+ },
+
+
/**************************************************************************
* Metadata management
**************************************************************************/
return (typeof table.column === 'undefined') ? null : table.column;
},
+ get_field_names: function(method)
+ {
+ var columns = this.get_columns(method);
+ if (!columns)
+ return null;
+ return $.map(columns, function (x) { return x.name });
+ },
+
get_key: function(method) {
var table = this.get_table(method);
if (!table)
if (!table)
return null;
+ var match = $.grep(table.column, function(x) { return x.name == name });
+ if (match.length == 0) {
+ return undefined;
+ } else {
+ return match[0].type;
+ }
return (typeof table.type === 'undefined') ? null : table.type;
}
// NEW API
manifold.query_store.insert(query);
+ // Run
+ $(document).ready(function() {
+ manifold.run_query(query);
+ });
+
// FORMER API
if (query.analyzed_query == null) {
query.analyze_subqueries();
}
},
- run_query: function(query, callback) {
+ run_query: function(query, callback)
+ {
// default value for callback = null
if (typeof callback === 'undefined')
callback = null;
+ var query_ext = manifold.query_store.find_query_ext(query.query_uuid);
+ query_ext.query_state = QUERY_STATE_INPROGRESS;
+
var query_json = JSON.stringify(query);
- /* Nothing related to pubsub here... for the moment at least. */
- //query.iter_subqueries(function (sq) {
- // manifold.raise_record_event(sq.query_uuid, IN_PROGRESS);
- //});
+ // Inform plugins about the progress
+ query.iter_subqueries(function (sq) {
+ var sq_query_ext = manifold.query_store.find_analyzed_query_ext(sq.query_uuid);
+ sq_query_ext.query_state = QUERY_STATE_INPROGRESS;
+
+ manifold.raise_record_event(sq.query_uuid, IN_PROGRESS);
+ });
+
$.post(manifold.proxy_url, {'json': query_json} , manifold.success_closure(query, null, callback));
},
+ // XXX DEPRECATED
// Executes all async. queries - intended for the javascript header to initialize queries
// input queries are specified as a list of {'query_uuid': <query_uuid> }
// each plugin is responsible for managing its spinner through on_query_in_progress
messages.debug(".. publish_result (5) END q=" + query.__repr());
},
+ store_records: function(query, records) {
+ // Store records
+ var query_ext = manifold.query_store.find_analyzed_query_ext(query.query_uuid);
+ if (query_ext.set_query_ext) {
+ // We have a domain query
+ // The results are stored in the corresponding set_query
+ manifold.query_store.set_records(query_ext.set_query_ext.query.query_uuid, records)
+
+ } else if (query_ext.domain_query_ext) {
+ // We have a set query, it is only used to determine which objects are in the set, we should only retrieve the key
+ // Has it a domain query, and has it completed ?
+ $.each(records, function(i, record) {
+ var key = manifold.metadata.get_key(query.object);
+ var record_key = manifold.record_get_value(record, key);
+ manifold.query_store.set_record_state(query.query_uuid, record_key, STATE_SET, STATE_SET_IN);
+ });
+
+ } else {
+ // We have a normal query
+ manifold.query_store.set_records(query.query_uuid, records, STATE_SET_IN);
+ }
+ },
+
/*!
* Recursively publish result
* \fn publish_result_rec(query, result)
*
* Note: this function works on the analyzed query
*/
- publish_result_rec: function(query, result) {
+ publish_result_rec: function(query, records) {
/* If the result is not unique, only publish the top query;
* otherwise, publish the main object as well as subqueries
* XXX how much recursive are we ?
*/
if (manifold.pubsub_debug)
- messages.debug (">>>>> publish_result_rec " + query.object);
+ messages.debug (">>>>> publish_result_rec " + query.object);
if (manifold.query_expects_unique_result(query)) {
/* Also publish subqueries */
$.each(query.subqueries, function(object, subquery) {
- manifold.publish_result_rec(subquery, result[0][object]);
+ manifold.publish_result_rec(subquery, records[0][object]);
/* TODO remove object from result */
});
}
if (manifold.pubsub_debug)
messages.debug ("===== publish_result_rec " + query.object);
- manifold.publish_result(query, result);
+ var query_ext = manifold.query_store.find_analyzed_query_ext(query.query_uuid);
+ query_ext.query_state = QUERY_STATE_DONE;
+
+ this.store_records(query, records);
+
+ var pub_query;
+
+ if (query_ext.set_query_ext) {
+ if (query_ext.set_query_ext.query_state != QUERY_STATE_DONE)
+ return;
+ pub_query = query_ext.set_query_ext.query;
+ } else if (query_ext.domain_query_ext) {
+ if (query_ext.domain_query_ext.query_state != QUERY_STATE_DONE)
+ return;
+ pub_query = query;
+ } else {
+ pub_query = query;
+ }
+ // We can only publish results if the query (and its related domain query) is complete
+ manifold.publish_result(pub_query, records);
if (manifold.pubsub_debug)
messages.debug ("<<<<< publish_result_rec " + query.object);
var record = records[0];
var update_query_ext = query_ext.update_query_ext;
+
+ console.log("Update case not handled yet!");
+ if (!update_query_ext)
+ return;
+
var update_query = update_query_ext.query;
var update_query_ext = query_ext.update_query_ext;
var update_query_orig = query_ext.update_query_orig_ext.query;
if (!subrecords)
continue
$.each(subrecords, function (i, subrecord) {
- if (key.length == 1){
- key = key[0];
- sq_keys.push(subrecord[key]);
- }else{
- // more than what's necessary, but should work
- sq_keys.push(subrecord);
- }
+ sq_keys.push(manifold.record_get_value(subrecord, key));
});
update_query.params[method] = sq_keys;
update_query_orig.params[method] = sq_keys.slice();
process_get_query_records: function(query, records) {
this.setup_update_query(query, records);
+
+ var query_ext = manifold.query_store.find_query_ext(query.query_uuid);
+ query_ext.query_state = QUERY_STATE_DONE;
/* Publish full results */
- var tmp_query = manifold.find_query(query.query_uuid);
- manifold.publish_result_rec(tmp_query.analyzed_query, records);
+ var tmp_query = manifold.query_store.find_analyzed_query(query.query_uuid);
+ manifold.publish_result_rec(tmp_query, records);
+ },
+
+ make_records: function(object, records)
+ {
+ $.each(records, function(i, record) {
+ manifold.make_record(object, record);
+ });
+ },
+
+ make_record: function(object, record)
+ {
+ // To make an object a record, we just add the hash function
+ var key = manifold.metadata.get_key(object);
+ record.hashCode = manifold.record_hashcode(key.sort());
+ record.equals = manifold.record_equals(key);
+
+ // Looking after subrecords
+ for (var field in record) {
+ var result_value = record[field];
+
+ switch (this.get_type(result_value)) {
+ case TYPE_RECORD:
+ var subobject = manifold.metadata.get_type(object, field);
+ // if (subobject) XXX Bugs with fields declared string while they are not : network.version is a dict in fact
+ if (subobject && subobject != 'string')
+ manifold.make_record(subobject, result_value);
+ break;
+ case TYPE_LIST_OF_RECORDS:
+ var subobject = manifold.metadata.get_type(object, field);
+ if (subobject)
+ manifold.make_records(subobject, result_value);
+ break;
+ }
+ }
},
/**
* previous 'process_get_query_records' function.
*/
process_update_query_records: function(query, records) {
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
+ // XXX XXX XXX XXX
// First issue: we request everything, and not only what we modify, so will will have to ignore some fields
var query_uuid = query.query_uuid;
var query_ext = manifold.query_store.find_analyzed_query_ext(query_uuid);
// Let's iterate over the object properties
for (var field in record) {
- switch (this.get_type(record[field])) {
+ var result_value = record[field];
+ switch (this.get_type(result_value)) {
case TYPE_VALUE:
// Did we ask for a change ?
var update_value = update_query[field];
// We assume it won't have changed
continue;
- var result_value = record[field];
if (!result_value)
throw "Internal error";
case TYPE_LIST_OF_VALUES:
// Same as list of records, but we don't have to extract keys
- var result_keys = record[field]
// The rest of exactly the same (XXX factorize)
var update_keys = update_query_orig.params[field];
$.each(added_keys, function(i, key) {
- if ($.inArray(key, result_keys) == -1) {
+ if ($.inArray(key, result_value) == -1) {
data = {
request: FIELD_REQUEST_ADD,
key : field,
key = key[0];
/* XXX should be modified for multiple keys */
- var result_keys = $.map(record[field], function(x) { return x[key]; });
+ var result_keys = $.map(record[field], function(x) { return manifold.record_get_value(x, key); });
var update_keys = update_query_orig.params[field];
var query_keys = update_query.params[field];
var result=data.value;
if (result) {
/* Eventually update the content of related queries (update, etc) */
+ manifold.make_records(query.object, result);
this.process_query_records(query, result);
/* Publish results: disabled here, done in the previous call */
raise_event: function(query_uuid, event_type, value) {
+ var query, query_ext;
+
// Query uuid has been updated with the key of a new element
query_ext = manifold.query_store.find_analyzed_query_ext(query_uuid);
query = query_ext.query;
switch(event_type) {
+
case FIELD_STATE_CHANGED:
// value is an object (request, key, value, status)
// update is only possible is the query is not pending, etc
});
value.key = value_key;
+ manifold.query_store.recount(cur_query.query_uuid);
manifold.raise_record_event(cur_query.query_uuid, event_type, value);
+
// XXX make this DOT a global variable... could be '/'
break;
case SET_ADD:
case SET_REMOVED:
-
+
+ /* An object has been added to / removed from a set : its
+ * status become pending or reset to the original state. We
+ * update the record status in the analyzed queries.
+ *
+ * XXX Shall we update something in the main_query ?
+ */
+ var prev_state, new_state;
+
+ prev_state = manifold.query_store.get_record_state(query_uuid, value, STATE_SET);
+ if (prev_state === null)
+ prev_state = STATE_SET_OUT;
+
+ if (event_type == SET_ADD) {
+ switch (prev_state) {
+ case STATE_SET_OUT:
+ case STATE_SET_OUT_SUCCESS:
+ case STATE_SET_IN_FAILURE:
+ new_state = STATE_SET_IN_PENDING;
+ break;
+
+ case STATE_SET_OUT_PENDING:
+ new_state = STATE_SET_IN;
+ break;
+
+ case STATE_SET_IN:
+ case STATE_SET_IN_PENDING:
+ case STATE_SET_IN_SUCCESS:
+ case STATE_SET_OUT_FAILURE:
+ console.log("Inconsistent state: already in");
+ return;
+ }
+ } else { // SET_REMOVE
+ switch (prev_state) {
+ case STATE_SET_IN:
+ case STATE_SET_IN_SUCCESS:
+ case STATE_SET_OUT_FAILURE:
+ new_state = STATE_SET_OUT_PENDING;
+ break;
+
+ case STATE_SET_IN_PENDING:
+ new_state = STATE_SET_OUT;
+ break;
+
+ case STATE_SET_OUT:
+ case STATE_SET_OUT_PENDING:
+ case STATE_SET_OUT_SUCCESS:
+ case STATE_SET_IN_FAILURE:
+ console.log("Inconsistent state: already out");
+ return;
+ }
+ }
+
+
+ var resource_key = value;
+
+ if (event_type == SET_ADD)
+ manifold.query_store.add_record(query_uuid, resource_key, new_state);
+ else
+ manifold.query_store.remove_record(query_uuid, resource_key, new_state);
+
+ var record = manifold.query_store.get_record(query_uuid, resource_key);
+
+ /* CONSTRAINTS */
+
+ // XXX When we add a lease we must update the warnings
+
+ switch(query.object) {
+
+ case 'resource':
+ // CONSTRAINT_RESERVABLE_LEASE
+ //
+ // +) If a reservable node is added to the slice, then it should have a corresponding lease
+ // XXX Not always a resource
+ var is_reservable = (record.exclusive == true);
+ if (is_reservable) {
+ var warnings = manifold.query_store.get_record_state(query_uuid, resource_key, STATE_WARNINGS);
+
+ if (event_type == SET_ADD) {
+ // We should have a lease_query associated
+ var lease_query = query_ext.parent_query_ext.query.subqueries['lease']; // in options
+ var lease_query_ext = manifold.query_store.find_analyzed_query_ext(lease_query.query_uuid);
+ // Do we have lease records with this resource
+ var lease_records = $.grep(lease_query_ext.records, function(lease_key, lease) {
+ return lease['resource'] == value;
+ });
+ if (lease_records.length == 0) {
+ // Sets a warning
+ // XXX Need for a better function to manage warnings
+ var warn = "No lease defined for this reservable resource.";
+ warnings[CONSTRAINT_RESERVABLE_LEASE] = warn;
+ } else {
+ // Lease are defined, delete the warning in case it was set previously
+ delete warnings[CONSTRAINT_RESERVABLE_LEASE];
+ }
+ } else {
+ // Remove warnings attached to this resource
+ delete warnings[CONSTRAINT_RESERVABLE_LEASE];
+ }
+
+ manifold.query_store.set_record_state(query_uuid, resource_key, STATE_WARNINGS, warnings);
+ break;
+ }
+
+ // Signal the change to plugins (even if the constraint does not apply, so that the plugin can display a checkmark)
+ data = {
+ request: null,
+ key : null,
+ value : resource_key,
+ status: STATE_WARNINGS
+ };
+ manifold.raise_record_event(query_uuid, FIELD_STATE_CHANGED, data);
+
+ case 'lease':
+ /*
+ var resource_key = record.resource;
+ var resource_query = query_ext.parent_query_ext.query.subqueries['resource'];
+ var warnings = manifold.query_store.get_record_state(resource_query.query_uuid, resource_key, STATE_WARNINGS);
+
+ if (event_type == SET_ADD) {
+ // A lease is added, it removes the constraint
+ delete warnings[CONSTRAINT_RESERVABLE_LEASE];
+ } else {
+ // A lease is removed, it might trigger the warning
+ var lease_records = $.grep(query_ext.records, function(lease_key, lease) {
+ return lease['resource'] == value;
+ });
+ if (lease_records.length == 0) { // XXX redundant cases
+ // Sets a warning
+ // XXX Need for a better function to manage warnings
+ var warn = "No lease defined for this reservable resource.";
+ warnings[CONSTRAINT_RESERVABLE_LEASE] = warn;
+ } else {
+ // Lease are defined, delete the warning in case it was set previously
+ delete warnings[CONSTRAINT_RESERVABLE_LEASE];
+ }
+
+ }
+
+ // Signal the change to plugins (even if the constraint does not apply, so that the plugin can display a checkmark)
+ data = {
+ request: null,
+ key : null,
+ value : resource_key,
+ status: STATE_WARNINGS
+ };
+ manifold.raise_record_event(resource_query.query_uuid, FIELD_STATE_CHANGED, data);
+ break;
+ */
+ }
+
+
+ // -) When a lease is added, it might remove the warning associated to a reservable node
+
+ // If a NITOS node is reserved, then at least a NITOS channel should be reserved
+ // - When a NITOS channel is added, it might remove a warning associated to all NITOS nodes
+
+ // If a NITOS channel is reserved, then at least a NITOS node should be reserved
+ // - When a NITOS node is added, it might remove a warning associated to all NITOS channels
+
+ // A lease is present while the resource has been removed => Require warnings on nodes not in set !
+
+ /* END CONSTRAINTS */
+
// update is only possible is the query is not pending, etc
// CHECK status !
request: (event_type == SET_ADD) ? FIELD_REQUEST_ADD : FIELD_REQUEST_REMOVE,
key : path,
value : value,
- status: FIELD_REQUEST_PENDING,
+ status: STATE_SET, // XXX used to be FIELD_REQUEST_PENDING, and not new_state
};
this.raise_event(main_query.query_uuid, FIELD_STATE_CHANGED, data);
manifold.run_query(query_ext.main_query_ext.update_query_ext.query);
break;
+ /* FILTERS */
+
case FILTER_ADDED:
+ /* Update internal record state */
+ manifold.query_store.add_filter(query_uuid, value);
+
+ /* Propagate the message to plugins */
manifold.raise_query_event(query_uuid, event_type, value);
+
break;
+
case FILTER_REMOVED:
+ /* Update internal record state */
+ manifold.query_store.remove_filter(query_uuid, value);
+
+ /* Propagate the message to plugins */
manifold.raise_query_event(query_uuid, event_type, value);
+
break;
+
case FIELD_ADDED:
main_query = query_ext.main_query_ext.query;
main_update_query = query_ext.main_query_ext.update_query;