/**
* Merge the results of two request processor. The primary RequestProcessor overrules the
* secondary RP. The request is made using the CRRequest.
*
* @param uniquemergeattribute
* @param primaryRP
* @param secondaryRP
* @param request
* @throws CRException
*/
public static Collection<CRResolvableBean> merge(
String uniquemergeattribute,
RequestProcessor primaryRP,
RequestProcessor secondaryRP,
CRRequest request)
throws CRException {
Collection<CRResolvableBean> rp1res = primaryRP.getObjects(request);
ArrayList<CRResolvableBean> result = new ArrayList<CRResolvableBean>();
LinkedHashMap<Object, CRResolvableBean> resultMap =
new LinkedHashMap<Object, CRResolvableBean>();
LinkedHashMap<Object, CRResolvableBean> resultMap2 =
new LinkedHashMap<Object, CRResolvableBean>();
String mergefilter = "";
boolean first = true;
for (CRResolvableBean crBean : rp1res) {
Object id = crBean.get(uniquemergeattribute);
if (first) {
first = false;
mergefilter += "\"" + id + "\"";
} else {
mergefilter += "," + "\"" + id + "\"";
}
resultMap.put(id, crBean);
}
rp1res = null;
CRRequest request2 = new CRRequest();
request2.setAttributeArray(request.getAttributeArray());
request2.setDoReplacePlinks(request.getDoReplacePlinks());
request2.setDoVelocity(request.getDoVelocity());
request2.setRequestFilter(
"object." + uniquemergeattribute + " CONTAINSONEOF [" + mergefilter + "]");
Collection<CRResolvableBean> rp2res = secondaryRP.getObjects(request2);
String[] attributes = request.getAttributeArray();
for (CRResolvableBean crBean : rp2res) {
Object id = crBean.get(uniquemergeattribute);
resultMap2.put(id, crBean);
}
String secMerge = (String) request.get("secondary");
if (Boolean.parseBoolean(secMerge)) {
// Resolvable from second RP will be used
useSecondaryMerge(result, resultMap, resultMap2, attributes);
} else {
// Resolvable from first RP will be used
useFirstMerge(result, resultMap, resultMap2, attributes);
}
return result;
}
/**
* 登録されたRequestProcessorのprocessINFCを全て呼び出す。
*
* @param subnet 受信したフレームの送受信が行なわれたサブネット
* @param frame 受信したフレーム
* @return 指定されたフレームを処理した場合にはtrue、そうでなければfalse
*/
public boolean processINFC(Subnet subnet, Frame frame) {
logger.entering(className, "processINFC", new Object[] {subnet, frame});
boolean processed = false;
for (RequestProcessor processor : cloneProcessors()) {
processed |= processor.processINFC(subnet, frame, processed);
}
logger.exiting(className, "processINFC", processed);
return processed;
}
/**
* Abort current transaction and rollback operations.
*
* @param fireEvent
*/
public void abort(boolean fireEvent) {
if (!aborted && active) {
if (transaction != null) {
transaction.executeSQL(
"invalid sql statement",
null,
null,
new SQLTransaction.SQLStatementErrorCallback() {
@Override
public boolean onError(SQLTransaction tx, SQLError error) {
return true; // tell web sql to rollback transaction
}
});
transaction = null;
}
aborted = true;
active = false;
requestProcessor.stop();
if (fireEvent) {
if (LogConfiguration.loggingIsEnabled()) {
logger.log(Level.INFO, db.messages.databaseTransactionAborted(db.getName()));
}
if (transactionCallback != null) {
try {
transactionCallback.onAbort();
} catch (Exception e) {
String message = db.messages.databaseTransactionError(db.getName(), e.getMessage());
reportError(transactionCallback, message, e);
}
}
}
}
}
/**
* Fills the attributes defined in the requests attribute array to each element of the collection
* col.
*
* @param rp
* @param col
* @param request
* @param idAttribute
* @throws CRException
*/
public static void fillAttributes(
RequestProcessor rp, Collection<CRResolvableBean> col, CRRequest request, String idAttribute)
throws CRException {
LinkedHashMap<Object, CRResolvableBean> resultMap =
new LinkedHashMap<Object, CRResolvableBean>();
StringBuilder mergefilter = new StringBuilder();
boolean first = true;
for (CRResolvableBean crBean : col) {
Object id = crBean.get(idAttribute);
String key = "";
if (id instanceof String) {
key = (String) id;
} else {
key = id.toString();
}
if (first) {
first = false;
mergefilter.append("\"");
mergefilter.append(key);
mergefilter.append("\"");
} else {
mergefilter.append(",");
mergefilter.append("\"");
mergefilter.append(key);
mergefilter.append("\"");
}
resultMap.put(key, crBean);
}
request.setRequestFilter(
"object." + idAttribute + " CONTAINSONEOF [" + mergefilter.toString() + "]");
Collection<CRResolvableBean> res = rp.getObjects(request);
String[] attributes = request.getAttributeArray();
// MERGE
for (Iterator<CRResolvableBean> resBeanIterator = res.iterator(); resBeanIterator.hasNext(); ) {
CRResolvableBean resBean = resBeanIterator.next();
Object keyObject = resBean.get(idAttribute);
String key = "";
if (keyObject instanceof String) {
key = (String) keyObject;
} else {
key = keyObject.toString();
}
CRResolvableBean finishedBean = resultMap.get(key);
if (finishedBean != null) {
for (String att : attributes) {
Object val = resBean.get(att);
if (val != null) {
finishedBean.set(att, val);
}
}
resBeanIterator.remove();
}
}
}
public void onError(String errorMessage) {
String message = db.messages.databaseTransactionError(db.getName(), errorMessage);
active = false;
requestProcessor.stop();
if (LogConfiguration.loggingIsEnabled()) {
logger.log(Level.SEVERE, message);
}
if (transactionCallback != null) {
transactionCallback.onError(message);
}
}
@Path("/listadmins")
@GET
public Response listadmins() {
Subject subject = SecurityUtils.getSubject();
if (subject.isAuthenticated() && subject.hasRole(RegAuthorizationInfo.ADMINSTRATOR_ROLE)) {
UserStore userstore = Registry.get().getUserStore();
return RequestProcessor.render(
"admin-list.vm", uriInfo, servletContext, request, "admins", userstore.listAdminUsers());
} else {
return error("You must be logged in as an administrator to do this");
}
}
public void addRequest(RequestOperation operation, Mode[] supportedMode) {
if (!active || aborted) {
onError(db.messages.databaseTransactionInactive(db.getName()));
return;
}
boolean supported = checkSupportedModes(supportedMode);
if (!supported) {
onError(db.messages.databaseTransactionNotSupportedOperation(db.getName()));
return;
}
requestProcessor.addRequest(operation).executeRequests();
}
@POST
@Path("/mst/{type}")
public Response createMst(final JsonObject body, @PathParam("type") String type) {
Response response = null;
try {
int id = processor.processRequest(body, type);
response = Response.created(new URI(URL_TO_RESOURCES + id)).build();
} catch (IOException | URISyntaxException ex) {
logger.error("Exception while processing REST call", ex);
response = Response.status(Status.BAD_REQUEST).build();
}
return response;
}
public void onSuccess() {
if (LogConfiguration.loggingIsEnabled()) {
logger.log(Level.INFO, db.messages.databaseTransactionCompleted(db.getName()));
}
active = false;
requestProcessor.stop();
if (transactionCallback != null) {
try {
transactionCallback.onComplete();
} catch (Exception e) {
String message = db.messages.databaseTransactionError(db.getName(), e.getMessage());
reportError(transactionCallback, message, e);
}
}
}
@GET
@Path("/mst/{id}")
public Response getMST(@PathParam("id") int id) {
Response response = null;
try {
JsonObject graph = processor.processRequest(id);
if (graph == null) {
response = Response.status(Status.NOT_FOUND).build();
} else {
response = Response.ok(graph).build();
}
} catch (IOException ex) {
logger.error("Exception while processing REST call", ex);
response = Response.status(Status.BAD_REQUEST).build();
}
return response;
}
private void initListening(final int level) {
CollabManager man = CollabManager.getDefault();
if (man == null) {
// manager not yet registered. This is a transient condition during
// module enablement because of manager registration mechanism.
// Retry 5s later
assert level < 10;
RequestProcessor.getDefault()
.post(
new Runnable() {
public void run() {
initListening(level + 1);
}
},
level * 5000);
} else {
man.addPropertyChangeListener(helper);
attachListeners();
updateStatus();
}
}
public synchronized void validate() {
// S ystem.out.println("=========================================================");
// S ystem.out.println(this);
// T hread.dumpStack ();
Iterator i = new ArrayList(objects.keySet()).iterator();
while (i.hasNext()) {
final Object o = (Object) i.next();
synchronized (o) {
Task task = (Task) tasks.get(o);
if (task != null) {
// S ystem.out.println ("Validator.task living! " + ((AbstractVariable) o).getVariableName
// () + " : " + o);
continue;
}
task =
RequestProcessor.postRequest(
new Runnable() {
public void run() {
synchronized (o) {
if (!o.canValidate()) {
// S ystem.out.println ("Validator.kill task! " + ((AbstractVariable)
// o).getVariableName () + " : " + o);
removeTask(o);
return;
}
o.validate();
// S ystem.out.println ("Validator.done task! " + ((AbstractVariable)
// o).getVariableName () + " : " + o);
removeTask(o);
}
}
});
// S ystem.out.println ("Validator.add task! " + ((AbstractVariable) o).getVariableName () +
// " : " + o);
addTask(o, task);
}
}
// S ystem.out.println("=========================================================");
}
@Path("/listusers")
@GET
@Produces(MediaType.TEXT_HTML)
public Response listusers(
@QueryParam("query") String query,
@QueryParam("grant") String action,
@QueryParam("uri") String uri) {
if (SecurityUtils.getSubject().isPermitted("Grant:" + uri)) {
List<UserInfo> users = Registry.get().getUserStore().listUsers(query);
return RequestProcessor.render(
"user-list.vm",
uriInfo,
servletContext,
request,
"grant",
action,
"uri",
uri,
"users",
users);
} else {
return error("You do not have sufficient privileges to grant further access");
}
}
@Path("/createpassword")
@POST
public Response ungrant(@FormParam("minstolive") String minstolive) {
int mins = 0;
try {
mins = Integer.parseInt(minstolive);
} catch (Exception e) {
return error("Minutes to live must be an integer");
}
Subject subject = SecurityUtils.getSubject();
if (subject.isAuthenticated()) {
UserStore userstore = Registry.get().getUserStore();
try {
String id = ((UserInfo) subject.getPrincipal()).getOpenid();
String pwd = userstore.createCredentials(id, mins);
return RequestProcessor.render(
"api-key-result.vm", uriInfo, servletContext, request, "password", pwd, "id", id);
} catch (Exception e) {
return error("Permission grant failed: " + e);
}
} else {
return error("You must be logged in to do this");
}
}
private Response error(String message) {
return RequestProcessor.render(
"error.vm", uriInfo, servletContext, request, "message", message);
}
@Override
protected void configureSelectDialog(SelectDialog<SearchResult> selectDialog) {
super.configureSelectDialog(selectDialog);
selectDialog.getMessageLabel().setText("Select a Show / Movie:");
}
@SuppressWarnings({"unchecked"})
public Response verifyResponse(HttpServletRequest request, HttpServletResponse httpresponse) {
try {
HttpSession session = request.getSession();
// extract the parameters from the authentication response
// (which comes in as a HTTP request from the OpenID provider)
ParameterList response = new ParameterList(request.getParameterMap());
// retrieve the previously stored discovery information
DiscoveryInformation discovered = (DiscoveryInformation) session.getAttribute("openid-disc");
// extract the receiving URL from the HTTP request
StringBuffer receivingURL = request.getRequestURL();
String queryString = request.getQueryString();
if (queryString != null && queryString.length() > 0)
receivingURL.append("?").append(request.getQueryString());
// verify the response; ConsumerManager needs to be the same
// (static) instance used to place the authentication request
VerificationResult verification =
manager.verify(receivingURL.toString(), response, discovered);
// examine the verification result and extract the verified identifier
Identifier verified = verification.getVerifiedId();
if (verified != null) {
AuthSuccess authSuccess = (AuthSuccess) verification.getAuthResponse();
String name = null;
if (authSuccess.hasExtension(AxMessage.OPENID_NS_AX)) {
FetchResponse fetchResp =
(FetchResponse) authSuccess.getExtension(AxMessage.OPENID_NS_AX);
Map<String, List<String>> attributes = fetchResp.getAttributes();
if (attributes.containsKey(AP_FULL_NAME)) {
name = attributes.get(AP_FULL_NAME).get(0);
} else {
name = attributes.get(AP_FIRST_NAME).get(0) + " " + attributes.get(AP_LAST_NAME).get(0);
}
}
log.info(String.format("Verified identity %s = %s", verified.getIdentifier(), name));
UserStore userstore = Registry.get().getUserStore();
boolean isRegistration = ((Boolean) session.getAttribute(SA_REGISTRATION)).booleanValue();
String registrationStatus = RS_LOGIN;
if (isRegistration) {
UserInfo userinfo = new UserInfo(verified.getIdentifier(), name);
if (userstore.register(userinfo)) {
registrationStatus = RS_NEW;
} else {
registrationStatus = RS_ALREADY_REGISTERED;
}
}
RegToken token = new RegToken(verified.getIdentifier(), true);
Subject subject = SecurityUtils.getSubject();
try {
subject.login(token);
session.setAttribute(VN_REGISTRATION_STATUS, registrationStatus);
String provider = (String) session.getAttribute(SA_OPENID_PROVIDER);
if (provider != null && !provider.isEmpty()) {
Cookie cookie = new Cookie(PROVIDER_COOKIE, provider);
cookie.setComment(
"Records the openid provider you last used to log in to a UKGovLD registry");
cookie.setMaxAge(60 * 60 * 24 * 30);
cookie.setHttpOnly(true);
cookie.setPath("/");
httpresponse.addCookie(cookie);
}
return redirectTo(session.getAttribute(SA_RETURN_URL).toString());
// return RequestProcessor.render("admin.vm", uriInfo, servletContext,
// request, VN_SUBJECT, subject, VN_REGISTRATION_STATUS, registrationStatus);
} catch (Exception e) {
log.error("Authentication failure: " + e);
return RequestProcessor.render(
"error.vm",
uriInfo,
servletContext,
request,
"message",
"Could not find a registration for you.");
}
}
} catch (Exception e) {
throw new WebApplicationException(e);
}
return RequestProcessor.render(
"error.vm", uriInfo, servletContext, request, "message", "OpenID login failed");
}
/**
* This method will be called inside the ProcessRequestThread, which is a singleton, so there will
* be a single thread calling this code.
*
* @param request
*/
@SuppressWarnings("unchecked")
protected void pRequest(Request request) throws RequestProcessorException {
// LOG.info("Prep>>> cxid = " + request.cxid + " type = " +
// request.type + " id = 0x" + Long.toHexString(request.sessionId));
TxnHeader txnHeader = null;
Record txn = null;
try {
switch (request.type) {
case OpCode.create:
txnHeader =
new TxnHeader(
request.sessionId, request.cxid, zks.getNextZxid(), zks.getTime(), OpCode.create);
zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
CreateRequest createRequest = new CreateRequest();
ZooKeeperServer.byteBuffer2Record(request.request, createRequest);
String path = createRequest.getPath();
int lastSlash = path.lastIndexOf('/');
if (lastSlash == -1 || path.indexOf('\0') != -1 || failCreate) {
LOG.info(
"Invalid path " + path + " with session 0x" + Long.toHexString(request.sessionId));
throw new KeeperException.BadArgumentsException(path);
}
if (!fixupACL(request.authInfo, createRequest.getAcl())) {
throw new KeeperException.InvalidACLException(path);
}
String parentPath = path.substring(0, lastSlash);
ChangeRecord parentRecord = getRecordForPath(parentPath);
checkACL(zks, parentRecord.acl, ZooDefs.Perms.CREATE, request.authInfo);
int parentCVersion = parentRecord.stat.getCversion();
CreateMode createMode = CreateMode.fromFlag(createRequest.getFlags());
if (createMode.isSequential()) {
path = path + String.format(Locale.ENGLISH, "%010d", parentCVersion);
}
try {
PathUtils.validatePath(path);
} catch (IllegalArgumentException ie) {
LOG.info(
"Invalid path " + path + " with session 0x" + Long.toHexString(request.sessionId));
throw new KeeperException.BadArgumentsException(path);
}
try {
if (getRecordForPath(path) != null) {
throw new KeeperException.NodeExistsException(path);
}
} catch (KeeperException.NoNodeException e) {
// ignore this one
}
boolean ephemeralParent = parentRecord.stat.getEphemeralOwner() != 0;
if (ephemeralParent) {
throw new KeeperException.NoChildrenForEphemeralsException(path);
}
txn =
new CreateTxn(
path, createRequest.getData(), createRequest.getAcl(), createMode.isEphemeral());
StatPersisted s = new StatPersisted();
if (createMode.isEphemeral()) {
s.setEphemeralOwner(request.sessionId);
}
parentRecord = parentRecord.duplicate(txnHeader.getZxid());
parentRecord.childCount++;
parentRecord.stat.setCversion(parentRecord.stat.getCversion() + 1);
addChangeRecord(parentRecord);
addChangeRecord(
new ChangeRecord(txnHeader.getZxid(), path, s, 0, createRequest.getAcl()));
break;
case OpCode.delete:
txnHeader =
new TxnHeader(
request.sessionId, request.cxid, zks.getNextZxid(), zks.getTime(), OpCode.delete);
zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
DeleteRequest deleteRequest = new DeleteRequest();
ZooKeeperServer.byteBuffer2Record(request.request, deleteRequest);
path = deleteRequest.getPath();
lastSlash = path.lastIndexOf('/');
if (lastSlash == -1
|| path.indexOf('\0') != -1
|| zks.getZKDatabase().isSpecialPath(path)) {
throw new KeeperException.BadArgumentsException(path);
}
parentPath = path.substring(0, lastSlash);
parentRecord = getRecordForPath(parentPath);
ChangeRecord nodeRecord = getRecordForPath(path);
checkACL(zks, parentRecord.acl, ZooDefs.Perms.DELETE, request.authInfo);
int version = deleteRequest.getVersion();
if (version != -1 && nodeRecord.stat.getVersion() != version) {
throw new KeeperException.BadVersionException(path);
}
if (nodeRecord.childCount > 0) {
throw new KeeperException.NotEmptyException(path);
}
txn = new DeleteTxn(path);
parentRecord = parentRecord.duplicate(txnHeader.getZxid());
parentRecord.childCount--;
parentRecord.stat.setCversion(parentRecord.stat.getCversion() + 1);
addChangeRecord(parentRecord);
addChangeRecord(new ChangeRecord(txnHeader.getZxid(), path, null, -1, null));
break;
case OpCode.setData:
txnHeader =
new TxnHeader(
request.sessionId,
request.cxid,
zks.getNextZxid(),
zks.getTime(),
OpCode.setData);
zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
SetDataRequest setDataRequest = new SetDataRequest();
ZooKeeperServer.byteBuffer2Record(request.request, setDataRequest);
path = setDataRequest.getPath();
nodeRecord = getRecordForPath(path);
checkACL(zks, nodeRecord.acl, ZooDefs.Perms.WRITE, request.authInfo);
version = setDataRequest.getVersion();
int currentVersion = nodeRecord.stat.getVersion();
if (version != -1 && version != currentVersion) {
throw new KeeperException.BadVersionException(path);
}
version = currentVersion + 1;
txn = new SetDataTxn(path, setDataRequest.getData(), version);
nodeRecord = nodeRecord.duplicate(txnHeader.getZxid());
nodeRecord.stat.setVersion(version);
addChangeRecord(nodeRecord);
break;
case OpCode.setACL:
txnHeader =
new TxnHeader(
request.sessionId, request.cxid, zks.getNextZxid(), zks.getTime(), OpCode.setACL);
zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
SetACLRequest setAclRequest = new SetACLRequest();
ZooKeeperServer.byteBuffer2Record(request.request, setAclRequest);
path = setAclRequest.getPath();
if (!fixupACL(request.authInfo, setAclRequest.getAcl())) {
throw new KeeperException.InvalidACLException(path);
}
nodeRecord = getRecordForPath(path);
checkACL(zks, nodeRecord.acl, ZooDefs.Perms.ADMIN, request.authInfo);
version = setAclRequest.getVersion();
currentVersion = nodeRecord.stat.getAversion();
if (version != -1 && version != currentVersion) {
throw new KeeperException.BadVersionException(path);
}
version = currentVersion + 1;
txn = new SetACLTxn(path, setAclRequest.getAcl(), version);
nodeRecord = nodeRecord.duplicate(txnHeader.getZxid());
nodeRecord.stat.setAversion(version);
addChangeRecord(nodeRecord);
break;
case OpCode.createSession:
txnHeader =
new TxnHeader(
request.sessionId,
request.cxid,
zks.getNextZxid(),
zks.getTime(),
OpCode.createSession);
request.request.rewind();
int to = request.request.getInt();
txn = new CreateSessionTxn(to);
request.request.rewind();
zks.sessionTracker.addSession(request.sessionId, to);
zks.setOwner(request.sessionId, request.getOwner());
break;
case OpCode.closeSession:
txnHeader =
new TxnHeader(
request.sessionId,
request.cxid,
zks.getNextZxid(),
zks.getTime(),
OpCode.closeSession);
// We don't want to do this check since the session expiration thread
// queues up this operation without being the session owner.
// this request is the last of the session so it should be ok
// zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
HashSet<String> es = zks.getZKDatabase().getEphemerals(request.sessionId);
synchronized (zks.outstandingChanges) {
for (ChangeRecord c : zks.outstandingChanges) {
if (c.stat == null) {
// Doing a delete
es.remove(c.path);
} else if (c.stat.getEphemeralOwner() == request.sessionId) {
es.add(c.path);
}
}
for (String path2Delete : es) {
addChangeRecord(new ChangeRecord(txnHeader.getZxid(), path2Delete, null, 0, null));
}
zks.sessionTracker.setSessionClosing(request.sessionId);
}
LOG.info(
"Processed session termination for sessionid: 0x"
+ Long.toHexString(request.sessionId));
break;
case OpCode.sync:
case OpCode.exists:
case OpCode.getData:
case OpCode.getACL:
case OpCode.getChildren:
case OpCode.getChildren2:
case OpCode.ping:
case OpCode.setWatches:
zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
break;
}
} catch (KeeperException e) {
if (txnHeader != null) {
txnHeader.setType(OpCode.error);
txn = new ErrorTxn(e.code().intValue());
}
LOG.info(
"Got user-level KeeperException when processing "
+ request.toString()
+ " Error Path:"
+ e.getPath()
+ " Error:"
+ e.getMessage());
request.setException(e);
} catch (Exception e) {
// log at error level as we are returning a marshalling
// error to the user
LOG.error("Failed to process " + request, e);
StringBuilder sb = new StringBuilder();
ByteBuffer bb = request.request;
if (bb != null) {
bb.rewind();
while (bb.hasRemaining()) {
sb.append(Integer.toHexString(bb.get() & 0xff));
}
} else {
sb.append("request buffer is null");
}
LOG.error("Dumping request buffer: 0x" + sb.toString());
if (txnHeader != null) {
txnHeader.setType(OpCode.error);
txn = new ErrorTxn(Code.MARSHALLINGERROR.intValue());
}
}
request.hdr = txnHeader;
request.txn = txn;
request.zxid = zks.getZxid();
nextProcessor.processRequest(request);
}
public void shutdown() {
submittedRequests.clear();
submittedRequests.add(Request.requestOfDeath);
nextProcessor.shutdown();
}
public void onTransaction(SQLTransaction tx) {
transaction = tx;
requestProcessor.executeRequests();
}
