private void _prepareKey() {
// e.g. keysString = "Test/HelloWorld/Java/-/message_text"
List<String> majorComponents = new ArrayList<String>();
List<String> minorComponents = new ArrayList<String>();
String[] keysArray = keysString.split("/");
boolean isMajor = true;
for (int i = 0; i < keysArray.length; i++) {
if (keysArray[i].equals("-")) {
isMajor = false;
continue;
}
if (isMajor) {
majorComponents.add(keysArray[i]);
} else {
minorComponents.add(keysArray[i]);
}
}
if ((majorComponents.size() > 0) && (minorComponents.size() > 0)) {
myKey = Key.createKey(majorComponents, minorComponents);
} else if ((majorComponents.size() > 0) & (minorComponents.size() <= 0)) {
myKey = Key.createKey(majorComponents);
} else {
errorMessage = "ERROR: The String could not be transformed to a Key.";
_printErrorMessage("False");
return;
}
return;
}
/**
* Change the session id. Note that this will change the session id for all contexts for which the
* session id is in use.
*
* @see org.eclipse.jetty.nosql.NoSqlSessionManager#update(org.eclipse.jetty.nosql.NoSqlSession,
* java.lang.String, java.lang.String)
*/
@Override
protected void update(NoSqlSession session, String newClusterId, String newNodeId)
throws Exception {
__log.debug(
"KVStoreSessionManager:update session {} to {}", session.getClusterId(), newClusterId);
SortedMap<Key, ValueVersion> old_keyvalues =
_kvstorehandler.multiGet(
Key.createKey(Arrays.asList(__storeprefix, session.getClusterId())),
null,
Depth.PARENT_AND_DESCENDANTS);
if (old_keyvalues != null && old_keyvalues.size() > 0) {
this.kvstore_object_ops.clear();
ValueVersion expiry_old_val = null;
for (Entry<Key, ValueVersion> old_entry : old_keyvalues.entrySet()) {
List<String> major_keypart = old_entry.getKey().getMajorPath();
List<String> minor_keypart = old_entry.getKey().getMinorPath();
if (old_entry
.getKey()
.toString()
.startsWith(__storeprefix + "/" + session.getClusterId() + "/" + __EXPIRY)) {
// got expiry value, save it for linkback
expiry_old_val = old_entry.getValue();
}
this.kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(major_keypart, minor_keypart), old_entry.getValue().getValue()));
major_keypart.set(1, newClusterId);
}
if (this.kvstore_object_ops.size() > 0) {
_kvstorehandler.execute(this.kvstore_object_ops);
this.kvstore_object_ops.clear();
_kvstorehandler.multiDelete(
Key.createKey(Arrays.asList(__storeprefix, session.getClusterId())),
null,
Depth.PARENT_AND_DESCENDANTS);
}
if (expiry_old_val != null) {
_kvstorehandler.put(
Key.createKey(
Arrays.asList(
__expirydailyindexprefix,
new String(expiry_old_val.getValue().getValue()),
"UTF-8"),
Arrays.asList(newClusterId)),
Value.EMPTY_VALUE);
_kvstorehandler.delete(
Key.createKey(
Arrays.asList(
__expirydailyindexprefix,
new String(expiry_old_val.getValue().getValue()),
"UTF-8"),
Arrays.asList(session.getClusterId())));
}
}
}
private void getAllKeys(boolean isPrintOutput) {
try {
Iterator iterator = store.storeKeysIterator(Direction.UNORDERED, 0);
while (iterator.hasNext()) {
Object object = iterator.next();
Key thisKey = (Key) object;
String key = new String(thisKey.toString());
if (isPrintOutput) System.out.println(key);
}
positiveMessage = "getAllKeys: passed";
} catch (Exception ex) {
errorMessage = "ERROR in getAllKeys: " + ex.toString();
_printErrorMessage("False");
}
}
/**
* Remove the per-context sub document for this session id.
*
* @see org.eclipse.jetty.nosql.NoSqlSessionManager#remove(org.eclipse.jetty.nosql.NoSqlSession)
*/
@Override
protected boolean remove(NoSqlSession session) {
__log.debug(
"KVStoreSessionManager:remove:session {} for context {}",
session.getClusterId(),
_contextId);
/*
* Check if the session exists and if it does remove the context
* associated with this session
*/
int deleted_count =
_kvstorehandler.multiDelete(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId)),
null,
Depth.PARENT_AND_DESCENDANTS);
if (deleted_count > 0) return true;
else return false;
}
/** @see org.eclipse.jetty.nosql.NoSqlSessionManager#expire(java.lang.String) */
@Override
protected void expire(String idInCluster) {
__log.debug("KVStoreSessionManager:expire session {} ", idInCluster);
// Expire the session for this context
super.expire(idInCluster);
// If the outer session document has not already been marked invalid, do so.
ValueVersion vver_valid =
_kvstorehandler.get(
Key.createKey(Arrays.asList(__storeprefix, idInCluster), Arrays.asList(__VALID)));
try {
if (vver_valid != null
&& vver_valid.getValue() != null
&& vver_valid.getValue().getValue() != null
&& "0".equals(new String(vver_valid.getValue().getValue(), "UTF-8"))) {
if (this.kvstore_opfactory == null)
this.kvstore_opfactory = this._kvstorehandler.getOperationFactory();
kvstore_object_ops.clear();
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(Arrays.asList(__storeprefix, idInCluster), Arrays.asList(__VALID)),
Value.createValue("0".getBytes("UTF-8"))));
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, idInCluster), Arrays.asList(__INVALIDATED)),
Value.createValue(
Base62Converter.fromBase10(System.currentTimeMillis()).getBytes("UTF-8"))));
// update indexes
// delete old entries, if present
ValueVersion old_valid =
_kvstorehandler.get(
Key.createKey(Arrays.asList(__storeprefix, idInCluster), Arrays.asList(__VALID)));
__log.debug("old_valid=" + (old_valid != null ? "notnull" : "null"));
ValueVersion old_accessed =
_kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, idInCluster), Arrays.asList(__ACCESSED)));
__log.debug("old_accessed=" + (old_accessed != null ? "notnull" : "null"));
if (old_valid != null
&& old_valid.getValue() != null
&& old_valid.getValue().getValue() != null
&& old_accessed != null
&& old_accessed.getValue() != null
&& old_accessed.getValue().getValue() != null) {
__log.debug("deleting old purgeindex entry");
_kvstorehandler.delete(
Key.createKey(
Arrays.asList(
__purgeindexprefix,
new String(old_valid.getValue().getValue(), "UTF-8"),
new String(old_accessed.getValue().getValue(), "UTF-8")),
Arrays.asList(idInCluster)));
} else __log.debug("some keys for purge index missing, nothing to delete");
_kvstorehandler.put(
Key.createKey(
Arrays.asList(
__purgeindexprefix,
"0",
new String(old_accessed.getValue().getValue(), "UTF-8")),
Arrays.asList(idInCluster)),
Value.EMPTY_VALUE);
if (kvstore_object_ops.size() > 0) {
_kvstorehandler.execute(kvstore_object_ops);
kvstore_object_ops.clear();
}
}
} catch (UnsupportedEncodingException | OperationExecutionException | FaultException e) {
__log.debug(
"KVStoreSessionManager: expire :: error :: session {} context {} ",
idInCluster,
_contextId);
}
}
/*------------------------------------------------------------ */
@Override
protected synchronized NoSqlSession loadSession(String clusterId) {
__log.debug("KVStoreSessionManager::loadSession id={}", clusterId);
SortedMap<Key, ValueVersion> context_keyvalues =
_kvstorehandler.multiGet(
Key.createKey(Arrays.asList(__storeprefix, clusterId)),
null,
Depth.PARENT_AND_DESCENDANTS);
// DBObject o = _kvstorehandler.findOne(new BasicDBObject(__ID,clusterId));
if (context_keyvalues == null || context_keyvalues.size() == 0) return null;
ValueVersion vver_valid =
context_keyvalues.get(
Key.createKey(Arrays.asList(__storeprefix, clusterId), Arrays.asList(__VALID)));
Boolean valid = null;
if (vver_valid != null
&& vver_valid.getValue() != null
&& vver_valid.getValue().getValue() != null)
try {
valid = "1".equals(new String(vver_valid.getValue().getValue(), "UTF-8"));
} catch (UnsupportedEncodingException e) {
}
__log.debug("KVStoreSessionManager:id={} valid={}", clusterId, valid);
if (valid == null || !valid) return null;
try {
Object version =
new Long(
Base62Converter.toBase10(
new String(
context_keyvalues
.get(
Key.createKey(
Arrays.asList(__storeprefix, clusterId),
Arrays.asList(__CONTEXT, _contextId, __VERSION)))
.getValue()
.getValue(),
"UTF-8")));
Long created =
new Long(
Base62Converter.toBase10(
new String(
context_keyvalues
.get(
Key.createKey(
Arrays.asList(__storeprefix, clusterId),
Arrays.asList(__CREATED)))
.getValue()
.getValue(),
"UTF-8")));
Long accessed =
new Long(
Base62Converter.toBase10(
new String(
context_keyvalues
.get(
Key.createKey(
Arrays.asList(__storeprefix, clusterId),
Arrays.asList(__ACCESSED)))
.getValue()
.getValue(),
"UTF-8")));
NoSqlSession session = null;
for (Entry<Key, ValueVersion> attr_entry : context_keyvalues.entrySet()) {
if (attr_entry
.getKey()
.toString()
.startsWith(__storeprefix + "/" + clusterId + "/" + __CONTEXT + "/" + _contextId)) {
// got our attribute
if (session == null) {
__log.debug(
"KVStoreSessionManager: session {} present for context {}", clusterId, _contextId);
session = new NoSqlSession(this, created, accessed, clusterId, version);
}
List<String> attr_minorpath = attr_entry.getKey().getMinorPath();
String attribute_name = attr_minorpath.get(attr_minorpath.size() - 1);
String attr = decodeName(attribute_name);
Object value = null;
if (attr_entry.getValue() != null
&& attr_entry.getValue().getValue() != null
&& attr_entry.getValue().getValue().getValue() != null) {
value = decodeValue(attr_entry.getValue().getValue().getValue());
session.doPutOrRemove(attr, value);
session.bindValue(attr, value);
}
}
}
if (session != null) session.didActivate();
else
__log.debug(
"KVStoreSessionManager: session {} not present for context {}", clusterId, _contextId);
return session;
} catch (Exception e) {
LOG.warn(e);
}
return null;
}
/*------------------------------------------------------------ */
@Override
protected Object refresh(NoSqlSession session, Object version) {
__log.debug("KVStoreSessionManager:refresh session {}", session.getId());
// check if our in memory version is the same as what is on the disk
if (version != null) {
ValueVersion vval_version =
this._kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId, __VERSION)));
if (vval_version != null && vval_version.getValue().getValue() != null) {
Long saved_version = new Long(-1L);
try {
saved_version =
new Long(
Base62Converter.toBase10(
new String(vval_version.getValue().getValue(), "UTF-8")));
} catch (UnsupportedEncodingException e) {
}
if (saved_version.equals(version)) {
__log.debug("KVStoreSessionManager:refresh not needed, session {}", session.getId());
return version;
}
version = saved_version;
}
}
// If we are here, we have to load the object
ValueVersion vver_valid =
_kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__VALID)));
// If it doesn't exist, invalidate
if (vver_valid == null
|| vver_valid.getValue() == null
|| vver_valid.getValue().getValue() == null) {
__log.debug(
"KVStoreSessionManager:refresh:marking session {} invalid, no object",
session.getClusterId());
session.invalidate();
return null;
}
try {
// If it has been flagged invalid, invalidate
String valid_str = new String(vver_valid.getValue().getValue(), "UTF-8");
Boolean valid = valid_str == "1" ? true : false;
if (!valid) {
__log.debug(
"KVstoreSessionManager:refresh:marking session {} invalid, valid flag {}",
session.getClusterId(),
valid);
session.invalidate();
return null;
}
// We need to update the attributes. We will model this as a passivate,
// followed by bindings and then activation.
session.willPassivate();
SortedMap<Key, ValueVersion> context_keyvalues =
_kvstorehandler.multiGet(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId)),
null,
Depth.CHILDREN_ONLY);
// if disk version now has no attributes, get rid of them
if (context_keyvalues == null || context_keyvalues.size() == 0) {
session.clearAttributes();
} else {
// iterate over the names of the attributes on the disk version, updating the value
ArrayList<String> stored_attrs = new ArrayList<String>();
for (Entry<Key, ValueVersion> attr_entry : context_keyvalues.entrySet()) {
List<String> attr_minorpath = attr_entry.getKey().getMinorPath();
String attribute_name = attr_minorpath.get(attr_minorpath.size() - 1);
String attr = decodeName(attribute_name);
Object value = null;
if (attr_entry.getValue() != null
&& attr_entry.getValue().getValue() != null
&& attr_entry.getValue().getValue().getValue() != null)
value = decodeValue(attr_entry.getValue().getValue().getValue());
// session does not already contain this attribute, so bind it
if (value != null) {
stored_attrs.add(attr);
if (session.getAttribute(attr) == null) {
session.doPutOrRemove(attr, value);
session.bindValue(attr, value);
} else // session already contains this attribute, update its value
session.doPutOrRemove(attr, value);
}
}
// cleanup, remove values from session, that don't exist in data anymore:
for (String sess_attr_entry : session.getNames()) {
if (!stored_attrs.contains(sess_attr_entry)) {
session.doPutOrRemove(sess_attr_entry, null);
session.unbindValue(sess_attr_entry, session.getAttribute(sess_attr_entry));
}
}
}
/*
* We are refreshing so we should update the last accessed time.
*/
// update purge index too, if we here we assume valid is set to 1, so we do not need to check
// for old value
ValueVersion old_accessed =
_kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__ACCESSED)));
if (old_accessed != null
&& old_accessed.getValue() != null
&& old_accessed.getValue().getValue() != null) {
_kvstorehandler.delete(
Key.createKey(
Arrays.asList(
__purgeindexprefix,
"1",
new String(old_accessed.getValue().getValue(), "UTF-8")),
Arrays.asList(session.getClusterId())));
}
String new_accessed = Base62Converter.longToLexiSortableBase62(System.currentTimeMillis());
_kvstorehandler.put(
Key.createKey(
Arrays.asList(__purgeindexprefix, "1", new_accessed),
Arrays.asList(session.getClusterId())),
Value.EMPTY_VALUE);
_kvstorehandler.put(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__ACCESSED)),
Value.createValue(new_accessed.getBytes("UTF-8")));
session.didActivate();
return version;
} catch (Exception e) {
LOG.warn(e);
}
return null;
}
/* ------------------------------------------------------------ */
@Override
protected synchronized Object save(
NoSqlSession session, Object version, boolean activateAfterSave) {
try {
__log.debug("KVStoreSessionManager:save session {}", session.getClusterId());
session.willPassivate();
this.kvstore_object_ops.clear();
if (this.kvstore_opfactory == null)
this.kvstore_opfactory = this._kvstorehandler.getOperationFactory();
/*
// Form query for upsert
BasicDBObject key = new BasicDBObject(__ID,session.getClusterId());
// Form updates
BasicDBObject update = new BasicDBObject();
BasicDBObject sets = new BasicDBObject();
BasicDBObject unsets = new BasicDBObject();
*/
boolean upsert = false;
boolean need_to_purge_attributes = false;
// handle valid or invalid
String new_valid = null;
String new_expiry = null;
String new_accessed = Base62Converter.longToLexiSortableBase62(session.getAccessed());
if (session.isValid()) {
new_valid = "1";
long expiry =
(session.getMaxInactiveInterval() > 0
? (session.getAccessed() + (1000L * getMaxInactiveInterval()))
: 0);
new_expiry = Base62Converter.longToLexiSortableBase62(expiry);
__log.debug(
"KVStoreSessionManager: calculated expiry {} for session {}", expiry, session.getId());
// handle new or existing
if (version == null) {
__log.debug("New session");
upsert = true;
version = new Long(1);
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CREATED)),
Value.createValue(
Base62Converter.fromBase10(session.getCreationTime()).getBytes("UTF-8"))));
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__VALID)),
Value.createValue(new_valid.getBytes("UTF-8"))));
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId, __VERSION)),
Value.createValue(
Base62Converter.fromBase10(((Long) version).longValue()).getBytes("UTF-8"))));
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__MAX_IDLE)),
Value.createValue(
Base62Converter.fromBase10(getMaxInactiveInterval()).getBytes("UTF-8"))));
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__EXPIRY)),
Value.createValue(new_expiry.getBytes("UTF-8"))));
} else {
version = new Long(((Number) version).longValue() + 1);
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId, __VERSION)),
Value.createValue(
Base62Converter.fromBase10(((Long) version).longValue()).getBytes("UTF-8"))));
// if max idle time and/or expiry is smaller for this context, then choose that for the
// whole session doc
ValueVersion vval_max_idle =
this._kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__MAX_IDLE)));
ValueVersion vval_expiry =
this._kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__EXPIRY)));
if (vval_max_idle != null && vval_max_idle.getValue().getValue() != null) {
long currentMaxIdle =
Base62Converter.toBase10(new String(vval_max_idle.getValue().getValue(), "UTF-8"));
if (getMaxInactiveInterval() > 0 && getMaxInactiveInterval() < currentMaxIdle)
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__MAX_IDLE)),
Value.createValue(
Base62Converter.fromBase10(getMaxInactiveInterval()).getBytes("UTF-8"))));
}
if (vval_expiry != null && vval_expiry.getValue().getValue() != null) {
long currentExpiry =
Base62Converter.toBase10(new String(vval_expiry.getValue().getValue(), "UTF-8"));
if (expiry > 0 && expiry != currentExpiry) {
new_expiry = Base62Converter.longToLexiSortableBase62(expiry);
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__EXPIRY)),
Value.createValue(new_expiry.getBytes("UTF-8"))));
}
}
}
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__ACCESSED)),
Value.createValue(new_accessed.getBytes("UTF-8"))));
__log.debug(
"session.isDirty=" + session.isDirty() + ";getSavePeriod=" + this.getSavePeriod());
Set<String> names = session.takeDirty();
if (isSaveAllAttributes() || upsert) {
names.addAll(session.getNames()); // note dirty may include removed names
}
for (String name : names) {
Object value = session.getAttribute(name);
if (value == null)
kvstore_object_ops.add(
this.kvstore_opfactory.createDelete(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId, name))));
else
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__CONTEXT, _contextId, name)),
Value.createValue(encodeValue(value))));
}
} else {
need_to_purge_attributes = true;
new_valid = "0";
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__VALID)),
Value.createValue(new_valid.getBytes("UTF-8"))));
kvstore_object_ops.add(
this.kvstore_opfactory.createPut(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()),
Arrays.asList(__INVALIDATED)),
Value.createValue(
Base62Converter.fromBase10(System.currentTimeMillis()).getBytes("UTF-8"))));
// unsets.put(getContextKey(),1);
}
// update indexes
// delete old entries, if present
ValueVersion old_valid =
_kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__VALID)));
ValueVersion old_accessed =
_kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__ACCESSED)));
ValueVersion old_expiry =
_kvstorehandler.get(
Key.createKey(
Arrays.asList(__storeprefix, session.getClusterId()), Arrays.asList(__EXPIRY)));
if (old_valid != null
&& old_valid.getValue() != null
&& old_valid.getValue().getValue() != null
&& old_accessed != null
&& old_accessed.getValue() != null
&& old_accessed.getValue().getValue() != null) {
__log.debug(
"delete purgeindex entry for old_valid="
+ new String(old_valid.getValue().getValue(), "UTF-8")
+ ";old_accessed="
+ new String(old_accessed.getValue().getValue(), "UTF-8"));
_kvstorehandler.delete(
Key.createKey(
Arrays.asList(
__purgeindexprefix,
new String(old_valid.getValue().getValue(), "UTF-8"),
new String(old_accessed.getValue().getValue(), "UTF-8")),
Arrays.asList(session.getClusterId())));
} else
__log.debug(
"nothing to delete from purge index, either accessed or valid keys are missing");
__log.debug(
"new_valid=" + new_valid + ";new_accessed=" + new_accessed + ";new_expiry=" + new_expiry);
_kvstorehandler.put(
Key.createKey(
Arrays.asList(__purgeindexprefix, new_valid, new_accessed),
Arrays.asList(session.getClusterId())),
Value.EMPTY_VALUE);
if (new_expiry != null) {
if (old_expiry != null
&& old_expiry.getValue() != null
&& old_expiry.getValue().getValue() != null) {
_kvstorehandler.delete(
Key.createKey(
Arrays.asList(
__expirydailyindexprefix,
new String(old_expiry.getValue().getValue(), "UTF-8")),
Arrays.asList(session.getClusterId())));
} else __log.debug("nothing to delete from expiry index, old expiry entry key is missing");
_kvstorehandler.put(
Key.createKey(
Arrays.asList(__expirydailyindexprefix, new_expiry),
Arrays.asList(session.getClusterId())),
Value.EMPTY_VALUE);
}
// Done with indexes, do the upsert
if (!kvstore_object_ops.isEmpty()) {
_kvstorehandler.execute(kvstore_object_ops);
kvstore_object_ops.clear();
}
if (need_to_purge_attributes) {
/*
__log.debug("before need to purge attrubutes");
Iterator<Key> it = _kvstorehandler.multiGetKeysIterator(Direction.FORWARD, 10,
Key.createKey(Arrays.asList(
__storeprefix,
session.getClusterId())),
null,//new KeyRange("minorpart1",true,"minorpart1",true),
Depth.PARENT_AND_DESCENDANTS);
while (it.hasNext()) {
Key key = it.next();
__log.debug("key="+key.toString());
}
*/
_kvstorehandler.multiDelete(
Key.createKey(Arrays.asList(__storeprefix, session.getClusterId())),
new KeyRange(__CONTEXT, true, __CONTEXT, true),
Depth.PARENT_AND_DESCENDANTS);
/*
__log.debug("after need to purge attrubutes");
Iterator<Key> it = _kvstorehandler.multiGetKeysIterator(Direction.FORWARD, 10,
Key.createKey(Arrays.asList(
__storeprefix,
session.getClusterId())),
null,//new KeyRange("minorpart1",true,"minorpart1",true),
Depth.PARENT_AND_DESCENDANTS);
while (it.hasNext()) {
Key key = it.next();
__log.debug("key="+key.toString());
}
*/
}
if (__log.isDebugEnabled()) __log.debug("KVStoreSessionManager:save:db.sessions.updated");
if (activateAfterSave) session.didActivate();
return version;
} catch (Exception e) {
LOG.warn(e);
}
return null;
}