/**
* execute, the static version of executing an update or insert on a table in the database.
*
* @param query a static SQL statement which updates or inserts.
*/
public void execute(String query) {
clearSignals();
Connection con = null;
PreparedStatement ps = null;
try {
con = ds.getConnection();
if (con.isClosed()) {
if (logger.isWarnEnabled()) logger.warn("Connection is closed: EntityDAO.execute!");
throw new SQLException();
}
ps = con.prepareStatement(query);
if (ps.executeUpdate() != 1) {
logger.warn("Problem with executing static query, EntityDAO: " + query);
throw new SQLException();
} else {
signalSuccess();
logger.info("Executing static query, EntityDAO: " + query);
}
} catch (SQLException sqle) {
signalFailure(sqle);
if (logger.isWarnEnabled()) {
logger.warn(
"Exeception while executing static statement, GenericDAO.execute: "
+ query
+ ":message: "
+ sqle.getMessage());
sqle.printStackTrace();
}
} finally {
this.closeIfNecessary(con, ps);
}
}
// Added by YW, 11-26-2007
public ArrayList select(String query, Connection con) {
clearSignals();
ArrayList results = new ArrayList();
ResultSet rs = null;
PreparedStatement ps = null;
try {
if (con.isClosed()) {
if (logger.isWarnEnabled()) logger.warn("Connection is closed: GenericDAO.select!");
throw new SQLException();
}
ps = con.prepareStatement(query);
rs = ps.executeQuery();
if (logger.isInfoEnabled()) {
logger.info("Executing dynamic query, EntityDAO.select:query " + query);
}
signalSuccess();
results = this.processResultRows(rs);
} catch (SQLException sqle) {
signalFailure(sqle);
if (logger.isWarnEnabled()) {
logger.warn(
"Exeception while executing dynamic query, GenericDAO.select: "
+ query
+ ":message: "
+ sqle.getMessage());
sqle.printStackTrace();
}
} finally {
this.closeIfNecessary(rs, ps);
}
return results;
}
/**
* Called immediately after an element has been put into the cache and the element already existed
* in the cache. This is thus an update.
*
* <p>The {@link net.sf.ehcache.Cache#put(net.sf.ehcache.Element)} method will block until this
* method returns.
*
* <p>Implementers may wish to have access to the Element's fields, including value, so the
* element is provided. Implementers should be careful not to modify the element. The effect of
* any modifications is undefined.
*
* @param cache the cache emitting the notification
* @param element the element which was just put into the cache.
*/
public final void notifyElementUpdated(final Ehcache cache, final Element element)
throws CacheException {
if (notAlive()) {
return;
}
if (!replicateUpdates) {
return;
}
if (replicateUpdatesViaCopy) {
if (!element.isSerializable()) {
if (LOG.isWarnEnabled()) {
LOG.warn(
"Object with key "
+ element.getObjectKey()
+ " is not Serializable and cannot be updated via copy.");
}
return;
}
addToReplicationQueue(new CacheEventMessage(EventMessage.PUT, cache, element, null));
} else {
if (!element.isKeySerializable()) {
if (LOG.isWarnEnabled()) {
LOG.warn(
"Object with key "
+ element.getObjectKey()
+ " does not have a Serializable key and cannot be replicated via invalidate.");
}
return;
}
addToReplicationQueue(
new CacheEventMessage(EventMessage.REMOVE, cache, null, element.getKey()));
}
}
public E get(long index) {
RandomAccessFile randomSerializeIndexFile = null;
RandomAccessFile randomSerializeFile = null;
E result = null;
Lock lock = readWriteLock.readLock();
lock.lock();
Throwable throwable = null;
long elementsCount = 0;
try {
if (!dataFile.canRead() || !indexFile.canRead()) {
return null;
}
randomSerializeIndexFile = new RandomAccessFile(indexFile, "r");
randomSerializeFile = new RandomAccessFile(dataFile, "r");
elementsCount = internalGetSize(randomSerializeIndexFile);
if (index >= 0 && index < elementsCount) {
long offset = internalOffsetOfElement(randomSerializeIndexFile, index);
result = internalReadElement(randomSerializeFile, offset);
return result;
}
} catch (Throwable e) {
throwable = e;
} finally {
IOUtilities.closeQuietly(randomSerializeFile);
IOUtilities.closeQuietly(randomSerializeIndexFile);
lock.unlock();
}
// it's a really bad idea to log while locked *sigh*
if (throwable != null) {
if (throwable instanceof ClassNotFoundException
|| throwable instanceof InvalidClassException) {
if (logger.isWarnEnabled())
logger.warn("Couldn't deserialize object at index " + index + "!\n" + throwable);
} else if (throwable instanceof ClassCastException) {
if (logger.isWarnEnabled())
logger.warn("Couldn't cast deserialized object at index " + index + "!\n" + throwable);
} else {
if (logger.isWarnEnabled())
logger.warn("Couldn't retrieve element at index " + index + "!", throwable);
}
IOUtilities.interruptIfNecessary(throwable);
} else if (index < 0 || index >= elementsCount) {
if (logger.isInfoEnabled()) {
logger.info(
"index ("
+ index
+ ") must be in the range [0..<"
+ elementsCount
+ "]. Returning null.");
}
return null;
}
return result;
}
/**
* This method inserts one row for an entity table and gets latestPK of this row.
*
* @param query
* @param variables
* @param nullVars
* @author ywang 11-26-2007
*/
public void executeWithPK(String query, HashMap variables, HashMap nullVars) {
clearSignals();
Connection con = null;
PreparedStatement ps = null;
PreparedStatementFactory psf = new PreparedStatementFactory(variables, nullVars);
try {
con = ds.getConnection();
if (con.isClosed()) {
if (logger.isWarnEnabled()) logger.warn("Connection is closed: EntityDAO.execute!");
throw new SQLException();
}
ps = con.prepareStatement(query);
ps = psf.generate(ps); // enter variables here!
if (ps.executeUpdate() != 1) {
logger.warn("Problem with executing dynamic query, EntityDAO: " + query);
throw new SQLException();
} else {
logger.info("Executing dynamic query, EntityDAO: " + query);
if (getCurrentPKName == null) {
this.latestPK = 0;
}
this.unsetTypeExpected();
this.setTypeExpected(1, TypeNames.INT);
ArrayList al = select(digester.getQuery(getCurrentPKName), con);
if (al.size() > 0) {
HashMap h = (HashMap) al.get(0);
this.latestPK = ((Integer) h.get("key")).intValue();
}
}
} catch (SQLException sqle) {
signalFailure(sqle);
if (logger.isWarnEnabled()) {
logger.warn(
"Exception while executing dynamic statement, EntityDAO.execute: "
+ query
+ ": "
+ sqle.getMessage());
sqle.printStackTrace();
}
} finally {
this.closeIfNecessary(con, ps);
}
}
/**
*
*
* <pre>
* 查询总数
* </pre>
*
* @author jundong.xu_C
* @param page
* @param parameterObject
* @param mappedStatement
* @param connection
* @throws SQLException
*/
protected void queryTotalRecord(
Page<?> page, Object parameterObject, MappedStatement mappedStatement, Connection connection)
throws SQLException {
BoundSql boundSql = mappedStatement.getBoundSql(parameterObject);
String sql = boundSql.getSql();
String countSql = this.buildCountSql(sql);
if (log.isDebugEnabled()) {
log.debug("分页时, 生成countSql: " + countSql);
}
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
BoundSql countBoundSql =
new BoundSql(
mappedStatement.getConfiguration(), countSql, parameterMappings, parameterObject);
ParameterHandler parameterHandler =
new DefaultParameterHandler(mappedStatement, parameterObject, countBoundSql);
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = connection.prepareStatement(countSql);
parameterHandler.setParameters(pstmt);
rs = pstmt.executeQuery();
if (rs.next()) {
long totalRecord = rs.getLong(1);
int pageSize = page.getPageSize();
int totalPage = (int) (totalRecord + pageSize - 1) / pageSize;
page.setTotalSize(totalRecord);
page.setTotalPage(totalPage);
}
} finally {
if (rs != null)
try {
rs.close();
} catch (Exception e) {
if (log.isWarnEnabled()) {
log.warn("关闭ResultSet时异常.", e);
}
}
if (pstmt != null)
try {
pstmt.close();
} catch (Exception e) {
if (log.isWarnEnabled()) {
log.warn("关闭PreparedStatement时异常.", e);
}
}
}
}
public BufferedImage createGraphImage(
long nowInSeconds, SourceIdentifier sourceIdentifier, BufferedImage result, boolean showMax) {
RrdGraphDef graphDef = getGraphDef(nowInSeconds, sourceIdentifier, showMax);
//noinspection SynchronizationOnLocalVariableOrMethodParameter
synchronized (graphDef) {
RrdGraph graph;
try {
graph = new RrdGraph(graphDef);
RrdGraphInfo graphInfo = graph.getRrdGraphInfo();
int width = graphInfo.getWidth();
int height = graphInfo.getHeight();
if (result != null && (result.getWidth() != width || result.getHeight() != height)) {
if (logger.isInfoEnabled()) logger.info("Flushing previous image because of wrong size.");
result.flush();
result = null;
}
if (result == null) {
result = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
if (logger.isInfoEnabled()) logger.info("Created new image.");
}
graph.render(result.getGraphics());
} catch (IOException ex) {
if (logger.isWarnEnabled()) logger.warn("Exception while creating graph!", ex);
if (result != null) {
result.flush();
result = null;
}
}
}
return result;
}
private void connect(
final Integer fromFacebookId,
final Integer toFacebookId,
final ConnectionType connectionType) {
final Transaction transaction = graphDb.beginTx();
try {
final Node fromNode = this.getIndexedNode(fromFacebookId);
final Node toNode = this.getIndexedNode(toFacebookId);
if (fromNode == null || toNode == null) {
if (logger.isWarnEnabled()) {
logger.warn("Can't connect nodes {} <> {} because one or both does not exists.");
}
throw new ResourceNotFoundException("One or both sides of the connection does not exists.");
}
fromNode.createRelationshipTo(toNode, connectionType);
if (logger.isInfoEnabled()) {
logger.info(
"{} is now Connected to {} with the {} relation.",
fromNode.getProperty(Neo4JPersonRepository.PROPERTY_NAME),
toNode.getProperty(Neo4JPersonRepository.PROPERTY_NAME),
connectionType);
}
transaction.success();
} catch (final Exception e) {
transaction.failure();
logger.error("Error connecting " + fromFacebookId + " to " + toFacebookId + ".", e);
throw e;
} finally {
transaction.finish();
}
}
/**
* Converts the given process into an unordered set of ActivityElements
*
* @param processResource
*/
public void removeProcessOrder() {
if (logger.isWarnEnabled()) {
logger.warn(
String.format(
"Giving up all attempts to repair process, %1$s. Treating it as an unordered set of Activities.",
process.getLabel()));
}
Resource startElement = process.getStartElement();
Resource endElement = process.getEndElement();
// make sure start element is ready to go with no arcs
if (null == startElement) {
// create a start element
startElement = createStartElement();
} else {
isolateElement(startElement);
}
// make sure end element is ready to go with no arcs
if (null == endElement) {
// create an end element
endElement = createEndElement();
} else {
isolateElement(endElement);
}
// isolate activity elements
Set<Resource> processElements = process.getProcessElements();
for (Resource r : processElements) {
// isolate will remove in/out links and delete the element if it's
// not Activity, Start, or End
isolateElement(r);
}
finalizeProcess();
}
/**
* Initializes (post construction) DataManager, its LocationMapper and Locators, and Context
*
* @see org.graphity.util.manager.DataManager
* @see org.graphity.util.locator
* @see <a
* href="http://jena.apache.org/documentation/javadoc/jena/com/hp/hpl/jena/util/FileManager.html">FileManager</a>
* @see <a
* href="http://jena.apache.org/documentation/javadoc/jena/com/hp/hpl/jena/util/LocationMapper.html">LocationMapper</a>
* @see <a
* href="http://jena.apache.org/documentation/javadoc/jena/com/hp/hpl/jena/util/Locator.html">Locator</a>
* @see <a
* href="http://jena.apache.org/documentation/javadoc/arq/com/hp/hpl/jena/sparql/util/Context.html">Context</a>
*/
@PostConstruct
public void init() {
if (log.isDebugEnabled())
log.debug(
"Application.init() with ResourceConfig: {} and SerlvetContext: {}",
getResourceConfig(),
getServletContext());
SysRIOT.wireIntoJena(); // enable RIOT parser
// WARNING! ontology caching can cause concurrency/consistency problems
OntDocumentManager.getInstance().setCacheModels(false);
if (getResourceConfig().getProperty(VoID.sparqlEndpoint.getURI()) == null)
throw new IllegalArgumentException("No SPARQL endpoint URI specified in web.xml");
{
String endpointURI = (String) getResourceConfig().getProperty(VoID.sparqlEndpoint.getURI());
String authUser = (String) getResourceConfig().getProperty(Service.queryAuthUser.getSymbol());
String authPwd = (String) getResourceConfig().getProperty(Service.queryAuthPwd.getSymbol());
if (authUser != null && authPwd != null)
configureServiceContext(endpointURI, authUser, authPwd);
}
if (getResourceConfig().getProperty(GS.sparqlGraphStore.getURI()) != null) {
String graphStoreURI = (String) getResourceConfig().getProperty(GS.sparqlGraphStore.getURI());
// reuses SPARQL query endpoint authentication properties -- not ideal
String authUser = (String) getResourceConfig().getProperty(Service.queryAuthUser.getSymbol());
String authPwd = (String) getResourceConfig().getProperty(Service.queryAuthPwd.getSymbol());
if (authUser != null && authPwd != null)
configureServiceContext(graphStoreURI, authUser, authPwd);
} else {
if (log.isWarnEnabled())
log.warn("No SPARQL Graph Store URI specified in web.xml. The server will be read-only.");
}
}
/**
* @see com.eyeq.pivot4j.ui.aggregator.AggregatorFactory#createAggregator(java.lang.String,
* org.olap4j.Axis, java.util.List, org.olap4j.metadata.Level, org.olap4j.metadata.Measure)
*/
@Override
public Aggregator createAggregator(
String name, Axis axis, List<Member> members, Level level, Measure measure) {
if (name == null) {
throw new NullArgumentException("name");
}
if (axis == null) {
throw new NullArgumentException("axis");
}
Aggregator aggregator = null;
if (TotalAggregator.NAME.equals(name)) {
aggregator = new TotalAggregator(axis, members, level, measure);
} else if (AverageAggregator.NAME.equals(name)) {
aggregator = new AverageAggregator(axis, members, level, measure);
} else if (MinimumAggregator.NAME.equals(name)) {
aggregator = new MinimumAggregator(axis, members, level, measure);
} else if (MaximumAggregator.NAME.equals(name)) {
aggregator = new MaximumAggregator(axis, members, level, measure);
} else if (CountAggregator.NAME.equals(name)) {
aggregator = new CountAggregator(axis, members, level, measure);
}
if (aggregator == null) {
Logger logger = LoggerFactory.getLogger(getClass());
if (logger.isWarnEnabled()) {
logger.warn("Unknown aggregator name : " + name);
}
}
return aggregator;
}
@Override
public void testLog(String level) throws IOException {
log.error(
String.format(
"Initiate logging with log set to: error %s, warn: %s, info %s, debug %s, trace %s",
log.isErrorEnabled(),
log.isWarnEnabled(),
log.isInfoEnabled(),
log.isDebugEnabled(),
log.isTraceEnabled()));
String msg = "Now I'm logging at level: %s";
if (level.equalsIgnoreCase("error")) {
log.error(String.format(msg, level));
} else if (level.equalsIgnoreCase("warn")) {
log.warn(String.format(msg, level));
} else if (level.equalsIgnoreCase("info")) {
log.info(String.format(msg, level));
} else if (level.equalsIgnoreCase("debug")) {
log.debug(String.format(msg, level));
} else if (level.equalsIgnoreCase("trace")) {
log.trace(String.format(msg, level));
}
}
@Override
@Deprecated
public void warn(String message, Throwable throwable) {
if (logger.isWarnEnabled()) {
logger.warn(message, throwable);
}
}
private void throwSecurityViolationIfNotAllowed(final IObject i) {
final String type = i.getClass().getName();
final Details d = i.getDetails();
final long user = d.getOwner().getId();
final long group = d.getGroup().getId();
final EventContext ec = getSecuritySystem().getEventContext();
final boolean root = ec.isCurrentUserAdmin();
final List<Long> leaderof = ec.getLeaderOfGroupsList();
final boolean pi = leaderof.contains(group);
final boolean own = ec.getCurrentUserId().equals(user);
if (!own && !root && !pi) {
if (log.isWarnEnabled()) {
log.warn(
String.format(
"User %d attempted to delete " + type + " %d belonging to User %d",
ec.getCurrentUserId(),
i.getId(),
user));
}
throw new SecurityViolation(
String.format("User %s cannot delete %s %d ", ec.getCurrentUserName(), type, i.getId()));
}
}
/**
* Generate header.
*
* @param logEventPack the log event pack
* @return the log header
*/
private RecordHeader generateHeader(LogEventPack logEventPack) {
RecordHeader logHeader = null;
if (header != null) {
logHeader = new RecordHeader();
for (LogHeaderStructureDto field : header) {
switch (field) {
case KEYHASH:
logHeader.setEndpointKeyHash(logEventPack.getEndpointKey());
break;
case TIMESTAMP:
logHeader.setTimestamp(System.currentTimeMillis());
break;
case TOKEN:
logHeader.setApplicationToken(applicationToken);
break;
case VERSION:
logHeader.setHeaderVersion(LOG_HEADER_VERSION);
break;
case LSVERSION:
logHeader.setLogSchemaVersion(logEventPack.getLogSchema().getVersion());
break;
default:
if (LOG.isWarnEnabled()) {
LOG.warn("Current header field [{}] doesn't support", field);
}
break;
}
}
}
return logHeader;
}
@Override
public String toString() {
final StringBuilder result = new StringBuilder();
final String newLine = System.getProperty("line.separator");
result.append(this.getClass().getName());
result.append(" Object {");
result.append(newLine);
// determine fields declared in this class only (no fields of superclass)
final Field[] fields = this.getClass().getDeclaredFields();
// print field names paired with their values
for (final Field field : fields) {
result.append(" ");
try {
result.append(field.getName());
result.append(": ");
// requires access to private field:
result.append(field.get(this));
} catch (final IllegalAccessException ex) {
if (LOGGER.isWarnEnabled()) {
LOGGER.warn("Caught exception while processing field " + field, ex);
}
}
result.append(newLine);
}
result.append("}");
return result.toString();
}
/**
* Gets the xML schema.
*
* @param partMeta the part meta
* @return the xML schema
* @throws Exception the exception
*/
private static File getXMLSchema(ObjectPartType partMeta) throws Exception {
final String FILE_SEPARATOR = System.getProperty("file.separator");
final String XML_SCHEMA_EXTENSION = ".xsd";
final String SCHEMAS_DIR = "schemas";
File schemaFile = null;
//
// Look for an XML Schema (.xsd) file for the incoming part payload
//
String serverRoot = ServiceMain.getInstance().getServerRootDir();
String schemasDir = serverRoot + FILE_SEPARATOR + SCHEMAS_DIR + FILE_SEPARATOR;
//
// Send a warning to the log file if the XML Schema file is missing
//
String schemaName = schemasDir + partMeta.getLabel() + XML_SCHEMA_EXTENSION;
try {
schemaFile = new File(schemaName);
} catch (Exception e) {
if (logger.isWarnEnabled() == true) {
logger.warn("Missing schema file for incoming payload: " + schemaName);
}
}
return schemaFile;
}
public void reduce(
Text key,
Iterator<NutchWritable> values,
OutputCollector<Text, Text> output,
Reporter reporter)
throws IOException {
StringBuffer dump = new StringBuffer();
dump.append("\nRecno:: ").append(recNo++).append("\n");
dump.append("URL:: " + key.toString() + "\n");
while (values.hasNext()) {
Writable value = values.next().get(); // unwrap
if (value instanceof CrawlDatum) {
dump.append("\nCrawlDatum::\n").append(((CrawlDatum) value).toString());
} else if (value instanceof Content) {
dump.append("\nContent::\n").append(((Content) value).toString());
} else if (value instanceof ParseData) {
dump.append("\nParseData::\n").append(((ParseData) value).toString());
} else if (value instanceof ParseText) {
dump.append("\nParseText::\n").append(((ParseText) value).toString());
} else if (LOG.isWarnEnabled()) {
LOG.warn("Unrecognized type: " + value.getClass());
}
}
output.collect(key, new Text(dump.toString()));
}
public void add(E element) {
RandomAccessFile randomSerializeIndexFile = null;
RandomAccessFile randomSerializeFile = null;
Throwable throwable = null;
Lock lock = readWriteLock.writeLock();
lock.lock(); // FindBugs "Multithreaded correctness - Method does not release lock on all
// exception paths" is a false positive
try {
randomSerializeIndexFile = new RandomAccessFile(indexFile, "rw");
randomSerializeFile = new RandomAccessFile(dataFile, "rw");
long elementsCount = internalGetSize(randomSerializeIndexFile);
long offset = 0;
if (elementsCount > 0) {
long prevElement = elementsCount - 1;
offset = internalOffsetOfElement(randomSerializeIndexFile, prevElement);
offset = offset + internalReadElementSize(randomSerializeFile, offset) + 4;
}
internalWriteElement(randomSerializeFile, offset, element);
internalWriteOffset(randomSerializeIndexFile, elementsCount, offset);
} catch (IOException e) {
throwable = e;
} finally {
IOUtilities.closeQuietly(randomSerializeFile);
IOUtilities.closeQuietly(randomSerializeIndexFile);
lock.unlock();
}
if (throwable != null) {
// it's a really bad idea to log while locked *sigh*
if (logger.isWarnEnabled()) logger.warn("Couldn't write element!", throwable);
IOUtilities.interruptIfNecessary(throwable);
}
}
private static boolean isLive(String aServer) {
try {
URL url = new URL(aServer + "health");
HttpURLConnection uc = (HttpURLConnection) url.openConnection();
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(BUNDLE.get("TC_STATUS_CHECK"), url);
}
if (uc.getResponseCode() == 200) {
Document xml = new Builder().build(uc.getInputStream());
Element response = (Element) xml.getRootElement();
Element health = response.getFirstChildElement("health");
String status = health.getValue();
if (status.equals("dying") || status.equals("sick")) {
if (LOGGER.isWarnEnabled()) {
LOGGER.warn(BUNDLE.get("TC_SERVER_STATUS"), status);
}
return true;
} else if (status.equals("ok")) {
return true;
} else {
LOGGER.error(BUNDLE.get("TC_UNEXPECTED_STATUS"), status);
}
}
} catch (UnknownHostException details) {
LOGGER.error(BUNDLE.get("TC_UNKNOWN_HOST"), details.getMessage());
} catch (Exception details) {
LOGGER.error(details.getMessage());
}
return false;
}
public MdsRestFacade getRestFacade(String entityName, String moduleName, String namespace) {
String restId = ClassName.restId(entityName, moduleName, namespace);
MdsRestFacade restFacade = null;
try {
String filter = String.format("(org.eclipse.gemini.blueprint.bean.name=%s)", restId);
Collection<ServiceReference<MdsRestFacade>> refs =
bundleContext.getServiceReferences(MdsRestFacade.class, filter);
if (refs != null && refs.size() > 1 && LOGGER.isWarnEnabled()) {
LOGGER.warn(
"More then one Rest Facade matching for entityName={}, module={}, namespace={}. "
+ "Using first one available.",
entityName,
moduleName,
namespace);
}
if (refs != null && refs.size() > 0) {
ServiceReference<MdsRestFacade> ref = refs.iterator().next();
restFacade = bundleContext.getService(ref);
}
} catch (InvalidSyntaxException e) {
throw new IllegalArgumentException("Invalid Syntax for Rest Facade retrieval", e);
}
if (restFacade == null) {
throw new RestNotSupportedException(entityName, moduleName, namespace);
}
return restFacade;
}
protected void propertyConcurrentModificationCheck(
AuditConfiguration auditConfiguration,
Session session,
AuditEvent e,
Long loadAuditTransactionId,
AuditObject auditObject) {
List<AuditTypeField> fieldsToCheck = new ArrayList<AuditTypeField>();
for (AuditObjectProperty auditObjectProperty : auditObject.getAuditObjectProperties()) {
fieldsToCheck.add(auditObjectProperty.getAuditField());
}
if (fieldsToCheck.isEmpty()) {
// there are no fields that we are going to modify - this means that the event is a delete
// event for the whole object - include all properties
fieldsToCheck.addAll(auditObject.getAuditType().getAuditFields());
}
List<AuditTypeField> modifiedAuditTypeFields =
getModifiedAuditTypeFields(session, e, loadAuditTransactionId, fieldsToCheck);
Iterator<AuditTypeField> modifiedAuditTypeFieldsIterator = modifiedAuditTypeFields.iterator();
if (modifiedAuditTypeFieldsIterator.hasNext()) {
AuditTypeField firstDetectedmodifiedAuditTypeField = modifiedAuditTypeFieldsIterator.next();
if (ConcurrentModificationBehavior.THROW_EXCEPTION.equals(
auditConfiguration
.getExtensionManager()
.getConcurrentModificationProvider()
.getCheckBehavior())) {
if (session.getTransaction().isActive()) {
session.getTransaction().rollback();
}
throw new PropertyConcurrentModificationException(
firstDetectedmodifiedAuditTypeField.getOwnerType().getClassName(),
firstDetectedmodifiedAuditTypeField.getName(),
firstDetectedmodifiedAuditTypeField.getOwnerType().getLabel(),
firstDetectedmodifiedAuditTypeField.getLabel(),
e.getEntityId());
} else if (ConcurrentModificationBehavior.LOG.equals(
auditConfiguration
.getExtensionManager()
.getConcurrentModificationProvider()
.getCheckBehavior())) {
if (log.isWarnEnabled()) {
log.warn(
"Concurrent modification detected: className="
+ firstDetectedmodifiedAuditTypeField.getOwnerType().getClassName()
+ ",field name="
+ firstDetectedmodifiedAuditTypeField.getName()
+ ",class label="
+ firstDetectedmodifiedAuditTypeField.getOwnerType().getLabel()
+ ",field label="
+ firstDetectedmodifiedAuditTypeField.getLabel()
+ ",entity id="
+ e.getEntityId());
}
}
}
}
private void resetConnection() {
_CounterGroup.incrementAndGet(RabbitMQConstants.COUNTER_EXCEPTION);
if (log.isWarnEnabled())
log.warn(this.getName() + " - Closing RabbitMQ connection and channel due to exception.");
RabbitMQUtil.close(_Connection, _Channel);
_Connection = null;
_Channel = null;
}
@Override
public void warn(Throwable t, String format, Object... args) {
if (logger.isWarnEnabled()) {
String message = formatMessage(format, args);
logger.warn(message, t);
}
}
protected void entityConcurrentModificationCheck(
AuditConfiguration auditConfiguration,
Session session,
Long loadAuditTransactionId,
AuditObject auditObject) {
AuditType auditType = null;
String targetEntityId = null;
if (auditObject instanceof EntityAuditObject) {
// only check the entities - the components are
// going to be check on field level check
EntityAuditObject entityAuditObject = (EntityAuditObject) auditObject;
auditType = entityAuditObject.getAuditType();
targetEntityId = entityAuditObject.getTargetEntityId();
} else {
ComponentAuditObject component = (ComponentAuditObject) auditObject;
AuditObject entity = component.getParentAuditObject();
while (entity != null && entity instanceof ComponentAuditObject) {
entity = ((ComponentAuditObject) entity).getParentAuditObject();
}
auditType = component.getAuditType();
targetEntityId = ((EntityAuditObject) entity).getTargetEntityId();
}
Long latestEntityTransactionId =
HibernateAudit.getLatestAuditTransactionIdByEntityAndAfterAuditTransactionId(
session, auditType, targetEntityId, loadAuditTransactionId);
if (latestEntityTransactionId != null
&& !latestEntityTransactionId.equals(loadAuditTransactionId)) {
if (ConcurrentModificationBehavior.THROW_EXCEPTION.equals(
auditConfiguration
.getExtensionManager()
.getConcurrentModificationProvider()
.getCheckBehavior())) {
if (session.getTransaction().isActive()) {
session.getTransaction().rollback();
}
throw new ObjectConcurrentModificationException(
auditType.getClassName(), auditType.getLabel(), targetEntityId);
} else if (ConcurrentModificationBehavior.LOG.equals(
auditConfiguration
.getExtensionManager()
.getConcurrentModificationProvider()
.getCheckBehavior())) {
if (log.isWarnEnabled()) {
log.warn(
"Concurrent modification detected: className="
+ auditType.getClassName()
+ ",label="
+ auditType.getLabel()
+ ",targetEntityId="
+ targetEntityId);
}
}
}
}
/**
* See Interface for functional description.
*
* @see UserAccountDaoInterface #retrieveGrants(java.lang.String, int, int,
* UserGroupHandlerInterface)
*/
@Override
public List<RoleGrant> retrieveGrants(
final String criterias,
final int offset,
final int maxResults,
final UserGroupHandlerInterface userGroupHandler)
throws InvalidSearchQueryException, SystemException {
final List<RoleGrant> result;
if (criterias != null && criterias.length() > 0) {
final RoleGrantFilter filter = new RoleGrantFilter(criterias);
final Set<String> userIds = filter.getUserIds();
final Set<String> groupIds = filter.getGroupIds();
// check if userId and groupId was provided
if (userIds != null && !userIds.isEmpty() && groupIds != null && !groupIds.isEmpty()) {
throw new InvalidSearchQueryException(
"you may not provide a userId and a groupId at the same " + "time");
}
// if userIds or groupIds are provided,
// get all groups the given users/groups belong to
if (userIds != null && !userIds.isEmpty()) {
for (final String userId : userIds) {
try {
groupIds.addAll(userGroupHandler.retrieveGroupsForUser(userId));
} catch (final UserAccountNotFoundException e) {
// Dont do anything because null-query is given
if (LOGGER.isWarnEnabled()) {
LOGGER.warn("Error on retrieving groups for user.");
}
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Error on retrieving groups for user.", e);
}
}
}
filter.setGroupIds(groupIds);
} else if (groupIds != null && !groupIds.isEmpty()) {
for (final String groupId : groupIds) {
groupIds.addAll(userGroupHandler.retrieveGroupsForGroup(groupId));
}
filter.setGroupIds(groupIds);
}
result = getHibernateTemplate().findByCriteria(filter.toSql(), offset, maxResults);
} else {
try {
final DetachedCriteria detachedCriteria =
DetachedCriteria.forClass(RoleGrant.class, "roleGrant");
result = getHibernateTemplate().findByCriteria(detachedCriteria, offset, maxResults);
} catch (final DataAccessException e) {
throw new SqlDatabaseSystemException(e);
}
}
return result;
}
/**
* Run this task through transactions until it succeeds without an optimistic concurrency failure.
*/
public static void repeatInTransaction(Transactable t) {
while (true) {
try {
runInTransaction(t);
break;
} catch (ConcurrentModificationException ex) {
if (log.isWarnEnabled()) log.warn("Optimistic concurrency failure for " + t + ": " + ex);
}
}
}
public byte[] modify(
ClassLoader classLoader,
String javassistClassName,
ProtectionDomain protectedDomain,
byte[] classFileBuffer) {
if (logger.isInfoEnabled()) {
logger.info("Modifying. {}", javassistClassName);
}
try {
InstrumentClass statementClass =
byteCodeInstrumentor.getClass(classLoader, javassistClassName, classFileBuffer);
Interceptor interceptor = new StatementExecuteQueryInterceptor();
statementClass.addGroupInterceptor(
"executeQuery", new String[] {"java.lang.String"}, interceptor, MYSQLScope.SCOPE_NAME);
// FIXME
Interceptor executeUpdateInterceptor1 = new StatementExecuteUpdateInterceptor();
statementClass.addGroupInterceptor(
"executeUpdate",
new String[] {"java.lang.String"},
executeUpdateInterceptor1,
MYSQLScope.SCOPE_NAME);
Interceptor executeUpdateInterceptor2 = new StatementExecuteUpdateInterceptor();
statementClass.addGroupInterceptor(
"executeUpdate",
new String[] {"java.lang.String", "int"},
executeUpdateInterceptor2,
MYSQLScope.SCOPE_NAME);
Interceptor executeUpdateInterceptor3 = new StatementExecuteUpdateInterceptor();
statementClass.addGroupInterceptor(
"execute",
new String[] {"java.lang.String"},
executeUpdateInterceptor3,
MYSQLScope.SCOPE_NAME);
Interceptor executeUpdateInterceptor4 = new StatementExecuteUpdateInterceptor();
statementClass.addGroupInterceptor(
"execute",
new String[] {"java.lang.String", "int"},
executeUpdateInterceptor4,
MYSQLScope.SCOPE_NAME);
statementClass.addTraceValue(DatabaseInfoTraceValue.class);
return statementClass.toBytecode();
} catch (InstrumentException e) {
if (logger.isWarnEnabled()) {
logger.warn("{} modify fail. Cause:{}", this.getClass().getSimpleName(), e.getMessage(), e);
}
return null;
}
}
private void sendEvent(String sessionId, OutputWampEventMessage msg)
throws SerializationException {
WampConnection con = getConnection(sessionId);
if (con != null)
try {
con.sendMessage(msg);
} catch (IOException e) {
if (log.isErrorEnabled()) log.error("Unable to send event message : " + e.getMessage());
}
else if (log.isWarnEnabled()) log.warn("Unable to find connection : " + sessionId);
}
public Iterable<Resource> extractResources(String sourceUrl, String html) {
Set<Resource> resources = Sets.newHashSet();
String prefixForInternalLinks = URLHandler.createPrefixForInternalLinks(sourceUrl);
List<Element> elements = new ArrayList<Element>();
Document doc = Jsoup.parse(html);
Elements scripts = doc.select("script");
elements.addAll(doc.select("iframe[src]"));
elements.addAll(doc.select("link[href]"));
elements.addAll(doc.select("img[src]"));
elements.addAll(scripts);
String uri;
for (Element element : elements) {
uri = element.attr("src").trim();
if (!uri.contains(".")) {
uri = element.attr("href").trim();
}
if (uri.contains(".")) {
uri = URLHandler.expandIfInternalLink(prefixForInternalLinks, uri);
try {
uri = URLHandler.extractHost(uri);
resources.add(new Resource(uri, type(element.tag().toString())));
} catch (MalformedURLException e) {
if (LOG.isWarnEnabled()) {
LOG.warn("Malformed URL: \"" + uri + "\"");
}
}
}
}
List<String> javaScriptUrlCandidates = new ArrayList<String>();
for (Element script : scripts) {
try {
String scriptContents = script.data();
if (scriptContents.length() > 1) {
ParserRunner.ParseResult parseResult = javascriptParser.parse(scriptContents);
findUrlCandidates(parseResult.ast, javaScriptUrlCandidates);
}
} catch (Exception e) {
}
}
List<String> splittedUrlCandidates = findUrlsInCode(javaScriptUrlCandidates);
resources.addAll(resourcesFromCandidates(splittedUrlCandidates));
return resources;
}
