/**
* Retrieves the last scenario used by the user
*
* @param userId
* @return
*/
public int lastUsedScenario(int userId) {
try {
// verifies the last scenario used by the user
int lastScenarioId = 1;
DBCollection usersCollection = getCollection("paprika", "users");
BasicDBObject userQuery = new BasicDBObject();
userQuery.put("userId", userId);
logger.logp(Level.INFO, TAG, "lastUsedScenario", " userQuery:" + userQuery.toString());
List<DBObject> userLastScenario = (List<DBObject>) usersCollection.find(userQuery).toArray();
if (userLastScenario.size() > 0) {
try {
lastScenarioId = (Integer) userLastScenario.get(0).get("scenarioId");
} catch (NullPointerException e) {
logger.logp(
Level.SEVERE, TAG, "verifiesLastScenario", e.getMessage() + " user id" + userId);
e.printStackTrace();
lastScenarioId = 0;
}
}
;
return lastScenarioId;
} catch (Exception e) {
logger.logp(Level.SEVERE, TAG, "verifiesLastScenario", e.getMessage() + " user id" + userId);
e.printStackTrace();
}
return 1; // if no last scenario is returned, uses scenarioId = 1 (paprika)
}
/**
* For testing. Requires the <code>LEDremoteControl.ino</code> Arduino sketch on a USB connected
* UNO.
*
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
final String mn = "main";
st = new SerialTransport(SerialPort.BAUDRATE_115200);
logger.logp(Level.INFO, "SerialTransport", mn, ">");
lastRun = System.currentTimeMillis();
blink(0, 0);
blink(1, 0);
blink(0, 0);
blink(3, 500);
blink(0, 500);
blink(5, 500);
blink(0, 500);
blink(7, 500);
blink(0, 500);
for (int i = 0; i < 1000; i++) {
System.out.print(i + ": ");
blink(1, 500);
blink(0, 500);
}
st.close();
logger.logp(Level.INFO, "SerialTransport", mn, "<");
}
protected StoreConfig() {
final String METHOD_NAME = "StoreConfig";
initialise();
if (logger.isLoggable(Level.FINER)) {
logger.logp(Level.FINER, CLASS_NAME, METHOD_NAME, getAllGeneralProperties().toString());
logger.logp(Level.FINER, CLASS_NAME, METHOD_NAME, getAllEnvironmentProperties().toString());
}
}
/**
* return a collection list.
*
* @param database
* @return collection (the list of collections)
*/
public List<String> getDatabaseNames() {
try {
// get the database
List<String> dbNames = mongo.getDatabaseNames();
logger.logp(Level.INFO, TAG, "getCollectionNames", " databases:" + dbNames);
return dbNames;
} catch (Exception e) {
logger.logp(Level.SEVERE, TAG, "getCollectionNames", e.getMessage());
e.printStackTrace();
}
return null;
}
/**
* return a collection list.
*
* @param database
* @return collection (the list of collections)
*/
public Set<String> getCollectionNames(String database) {
try {
// get the database
DB db = getDB(database);
Set<String> collections = db.getCollectionNames();
logger.logp(Level.INFO, TAG, "getCollectionNames", " database:" + database);
return collections;
} catch (Exception e) {
logger.logp(
Level.SEVERE, TAG, "getCollectionNames", e.getMessage() + " database:" + database);
e.printStackTrace();
}
return null;
}
/**
* Method logs {@code exception}'s message at the logging level specified by the {@code level}
* argument.
*
* <p>If {@code cause} parameter is not {@code null}, it is logged as well and {@code exception}
* original cause is initialized with instance referenced by {@code cause} parameter.
*
* @param exception exception whose message should be logged. Must not be {@code null}.
* @param cause initial cause of the exception that should be logged as well and set as {@code
* exception}'s original cause. May be {@code null}.
* @param level loging level which should be used for logging
* @return the same exception instance that was passed in as the {@code exception} parameter.
*/
public <T extends Throwable> T logException(
final T exception, final Throwable cause, final Level level) {
if (this.logger.isLoggable(level)) {
if (cause == null) {
logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage());
} else {
exception.initCause(cause);
logger.logp(
level, componentClassName, getCallerMethodName(), exception.getMessage(), cause);
}
}
return exception;
}
/**
* compress the database
*
* @return
*/
@SuppressWarnings("unused")
public String compressDB(String database) {
try {
int counter = 0;
StringBuilder result = new StringBuilder();
BasicDBObject cmd = new BasicDBObject();
Set<String> listCollection = getCollectionNames(database);
DB db = getDB(database);
for (String collection : listCollection) {
cmd.put("collStats", collection);
CommandResult beforeCompact = db.command(cmd);
cmd.put("compact", collection);
CommandResult duringCompact = db.command(cmd);
cmd.put("collStats", collection);
CommandResult afterCompact = db.command(cmd);
counter = counter + 1;
result.append("Collection: " + collection + "\n");
result.append("Before compact: " + beforeCompact + "\n");
result.append("After compact: " + afterCompact + "\n");
result.append("---------------------------------------------- \n");
}
result.append("Returned number of documents: " + counter);
return result.toString();
} catch (Exception e) {
logger.logp(Level.SEVERE, TAG, "compressDB", e.getMessage() + " database:" + database);
e.printStackTrace();
}
return null;
}
private JDBCDriverManager() {
logger.logp(
java.util.logging.Level.FINE,
OdaJdbcDriver.class.getName(),
"JDBCDriverManager",
"JDBCDriverManager starts up");
}
private void render(
final List<? extends Spatial> toDrawA,
final Spatial toDrawB,
final Scene toDrawC,
final List<Texture> texs,
final int clear) {
try {
if (_pbuffer == null || _pbuffer.isBufferLost()) {
if (_pbuffer != null && _pbuffer.isBufferLost()) {
logger.warning("PBuffer contents lost - will recreate the buffer");
deactivate();
_pbuffer.destroy();
}
initPbuffer();
}
if (texs.size() == 1
&& _useDirectRender
&& !texs.get(0).getTextureStoreFormat().isDepthFormat()) {
// setup and render directly to a 2d texture.
LwjglTextureStateUtil.doTextureBind(texs.get(0), 0, true);
activate();
switchCameraIn(clear);
_pbuffer.releaseTexImage(Pbuffer.FRONT_LEFT_BUFFER);
if (toDrawA != null) {
doDraw(toDrawA);
} else {
doDraw(toDrawB);
}
switchCameraOut();
deactivate();
_pbuffer.bindTexImage(Pbuffer.FRONT_LEFT_BUFFER);
} else {
// render and copy to a texture
activate();
switchCameraIn(clear);
if (toDrawA != null) {
doDraw(toDrawA);
} else {
doDraw(toDrawB);
}
switchCameraOut();
for (int i = 0; i < texs.size(); i++) {
copyToTexture(texs.get(i), 0, 0, _width, _height, 0, 0);
}
deactivate();
}
} catch (final Exception e) {
logger.logp(
Level.SEVERE, this.getClass().toString(), "render(Spatial, Texture)", "Exception", e);
}
}
public void saveRules() {
try {
OutputHandler.SOP("Saving rules");
if (!rulesFile.exists()) rulesFile.createNewFile();
// create streams
FileOutputStream stream = new FileOutputStream(rulesFile);
OutputStreamWriter streamWriter = new OutputStreamWriter(stream);
BufferedWriter writer = new BufferedWriter(streamWriter);
writer.write("# " + rulesFile.getName() + " | numbers are automatically added");
writer.newLine();
for (String rule : rules) {
writer.write(rule);
writer.newLine();
}
writer.close();
streamWriter.close();
stream.close();
OutputHandler.SOP("Completed saving rules file.");
} catch (Exception e) {
Logger lof = OutputHandler.felog;
lof.logp(
Level.SEVERE,
"FEConfig",
"Saving Rules",
"Error writing the Rules file: " + rulesFile.getName(),
e);
}
}
/**
* @param subElems
* @throws DataException
*/
private void populateDeprecatedAggregations(IConfigurationElement[] subElems)
throws DataException {
if (subElems == null) return;
for (int j = 0; j < subElems.length; j++) {
try {
IAggregation aggrFunc =
(IAggregation) subElems[j].createExecutableExtension(ATTRIBUTE_AGGREGATION_CLASS);
String name = aggrFunc.getName().toUpperCase();
AggrFunctionWrapper aggrWrapper = new AggrFunctionWrapper(aggrFunc);
populateExtendedAggrInfo(name, aggrFunc, subElems[j], aggrWrapper);
if (aggrMap.put(name, aggrWrapper) != null)
throw new DataException(ResourceConstants.DUPLICATE_AGGREGATION_NAME, name);
allAggrNames.add(name);
} catch (Exception e) {
logger.logp(
Level.WARNING,
AggrFunctionWrapper.class.getName(),
"populateDeprecatedAggregations",
"Exception in aggregation extension loading.",
e);
}
}
}
public void log(Level level, String message, Throwable thrown) {
if (isLoggable(level)) {
String[] source = getSource();
logger.logp(
level, source[0], source[1], Thread.currentThread().getName() + ": " + message, thrown);
}
}
private void activate() {
if (_active == 0) {
try {
_oldContext = ContextManager.getCurrentContext();
_pbuffer.makeCurrent();
ContextManager.switchContext(_pbuffer);
ContextManager.getCurrentContext().clearEnforcedStates();
ContextManager.getCurrentContext().enforceStates(_enforcedStates);
if (_bgColorDirty) {
GL11.glClearColor(
_backgroundColor.getRed(),
_backgroundColor.getGreen(),
_backgroundColor.getBlue(),
_backgroundColor.getAlpha());
_bgColorDirty = false;
}
} catch (final LWJGLException e) {
logger.logp(Level.SEVERE, this.getClass().toString(), "activate()", "Exception", e);
throw new Ardor3dException();
}
}
_active++;
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// get the tickerStr
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
// get the user and check for non null
if (user != null) {
PersistenceManager pm = PMF.get().getPersistenceManager();
Collection<UserComparisonTickers> comparisonTickersCollection = null;
try {
comparisonTickersCollection =
getComparisonTickersService().getComparisonTickers(user.getEmail());
} catch (Exception e) {
log.logp(
Level.SEVERE,
GetComparisonTickersServlet.class.getName(),
"method",
"UserComparisonTickers could not be fetched from persistence storage",
e);
} finally {
pm.close();
}
if (comparisonTickersCollection != null) {
resp.getWriter().write(getComparisonTickersService().getJson(comparisonTickersCollection));
}
}
}
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Benchmark
public void param1JulFile() {
// must specify sourceClass or JUL will look it up by walking the stack trace!
julLogger.logp(
Level.INFO, getClass().getName(), "param1JulFile", "This is a debug [{}] message", ++j);
}
/**
* Method logs {@code exception}'s message at the logging level specified by the {@code level}
* argument.
*
* <p>If {@code logCause} parameter is {@code true}, {@code exception}'s original cause is logged
* as well (if exists). This may be used in cases when {@code exception}'s class provides
* constructor to initialize the original cause. In such case you do not need to use {@link
* #logException(Throwable, Throwable, Level) logException(exception, cause, level)} method
* version but you might still want to log the original cause as well.
*
* @param exception exception whose message should be logged. Must not be {@code null}.
* @param logCause deterimnes whether initial cause of the exception should be logged as well
* @param level loging level which should be used for logging
* @return the same exception instance that was passed in as the {@code exception} parameter.
*/
public <T extends Throwable> T logException(
final T exception, final boolean logCause, final Level level) {
if (this.logger.isLoggable(level)) {
if (logCause && exception.getCause() != null) {
logger.logp(
level,
componentClassName,
getCallerMethodName(),
exception.getMessage(),
exception.getCause());
} else {
logger.logp(level, componentClassName, getCallerMethodName(), exception.getMessage());
}
}
return exception;
}
/**
* Same as {@link #logSevereException(Throwable, boolean) logSevereException(exception, true)}.
*/
public <T extends Throwable> T logSevereException(final T exception) {
if (this.logger.isLoggable(Level.SEVERE)) {
if (exception.getCause() == null) {
logger.logp(
Level.SEVERE, componentClassName, getCallerMethodName(), exception.getMessage());
} else {
logger.logp(
Level.SEVERE,
componentClassName,
getCallerMethodName(),
exception.getMessage(),
exception.getCause());
}
}
return exception;
}
@Test
public void testLogParamMarkers() {
final Logger flowLogger = Logger.getLogger("TestFlow");
flowLogger.logp(
java.util.logging.Level.FINER, "sourceClass", "sourceMethod", "ENTRY {0}", "params");
final List<LogEvent> events = flowAppender.getEvents();
assertEquals("ENTRY params", events.get(0).getMessage().getFormattedMessage());
}
/**
* Writes a single byte to the serial transport. Checks if the byte could be written.
*
* @param b
* @throws SerialPortException
* @throws DisplayException if the operation was not successfully completed
*/
public void writeByte(byte b) throws SerialPortException, DisplayException {
final String mn = "writeByte";
boolean result = serialPort.writeByte(b);
if (!result) {
String msg = "Write error";
logger.logp(Level.WARNING, this.getClass().getName(), mn, msg);
throw new DisplayException(msg);
}
}
public final void trace(
RuntimeContext context,
String sourceClass,
String sourceMethod,
String message,
Level level) {
logger.logp(level, sourceClass, sourceMethod, message);
}
/**
* For testing
*
* @param value
* @param time
* @throws DisplayException
* @throws SerialPortException
* @throws InterruptedException
*/
private static void blink(int value, int time)
throws DisplayException, SerialPortException, InterruptedException {
final String mn = "blink";
logger.logp(
Level.INFO, "SerialTransport", mn, "> Sending " + value + ", waiting for " + time + "ms: ");
st.writeByte((byte) value);
String msg = st.getMessage();
Thread.sleep(time);
logger.logp(
Level.INFO,
"SerialTransport",
mn,
"< '" + msg + "' time total = " + (System.currentTimeMillis() - lastRun) + "ms");
lastRun = System.currentTimeMillis();
}
public void close() throws SerialPortException, DisplayException {
final String mn = "close";
if (!serialPort.removeEventListener()) {
String msg = "Could not remove event listener";
logger.logp(Level.WARNING, this.getClass().getName(), mn, msg);
throw new DisplayException(msg);
}
serialPort.closePort();
}
@Override
public void read(final InputCapsule capsule) throws IOException {
super.read(capsule);
try {
setRadius(capsule.readDouble("radius", 0));
} catch (final IOException ex) {
logger.logp(
Level.SEVERE, this.getClass().toString(), "read(Ardor3DImporter)", "Exception", ex);
}
}
@Override
public void write(final OutputCapsule capsule) throws IOException {
super.write(capsule);
try {
capsule.write(getRadius(), "radius", 0);
} catch (final IOException ex) {
logger.logp(
Level.SEVERE, this.getClass().toString(), "write(Ardor3DExporter)", "Exception", ex);
}
}
@Override
public synchronized void flush() throws IOException {
super.flush();
String record = this.toString();
super.reset();
if (record.length() > 0 && !record.equals(separator)) {
logger.logp(level, "LoggerOutputStream", "log" + level, record);
}
}
private void initPbuffer() {
try {
if (_pbuffer != null) {
giveBackContext();
ContextManager.removeContext(_pbuffer);
}
final PixelFormat format =
new PixelFormat(
_settings.getAlphaBits(), _settings.getDepthBits(), _settings.getStencilBits())
.withSamples(_settings.getSamples())
.withBitsPerPixel(_settings.getColorDepth())
.withStereo(_settings.isStereo());
_pbuffer = new Pbuffer(_width, _height, format, _texture, null);
final Object contextKey = _pbuffer;
try {
_pbuffer.makeCurrent();
} catch (final LWJGLException e) {
throw new RuntimeException(e);
}
final LwjglContextCapabilities caps =
new LwjglContextCapabilities(GLContext.getCapabilities());
ContextManager.addContext(
contextKey, new RenderContext(contextKey, caps, ContextManager.getCurrentContext()));
} catch (final Exception e) {
logger.logp(Level.SEVERE, this.getClass().toString(), "initPbuffer()", "Exception", e);
if (_texture != null && _useDirectRender) {
logger.warning(
"Your card claims to support Render to Texture but fails to enact it. Updating your driver might solve this problem.");
logger.warning("Attempting to fall back to Copy Texture.");
_texture = null;
_useDirectRender = false;
initPbuffer();
return;
}
logger.log(Level.WARNING, "Failed to create Pbuffer.", e);
return;
}
try {
activate();
_width = _pbuffer.getWidth();
_height = _pbuffer.getHeight();
deactivate();
} catch (final Exception e) {
logger.log(Level.WARNING, "Failed to initialize created Pbuffer.", e);
return;
}
}
// TODO: set as private
public DB getDB(String database) {
try {
DB db;
// check if we already have this database in the Map
if (dbMap.containsKey(database)) {
db = dbMap.get(database);
} else {
db = mongo.getDB(database);
// add the database to the Map
dbMap.put(database, db);
}
logger.logp(Level.INFO, TAG, "getDB", " database:" + database);
// return the database
return db;
} catch (Exception e) {
logger.logp(Level.SEVERE, TAG, "getDB", e.getMessage() + " database:" + database);
e.printStackTrace();
}
return null;
}
private void deactivate() {
if (_active == 1) {
try {
giveBackContext();
} catch (final LWJGLException e) {
logger.logp(Level.SEVERE, this.getClass().toString(), "deactivate()", "Exception", e);
throw new Ardor3dException();
}
}
_active--;
}
/** Returns null and logs a warning as this is not supported. */
@Override
public ResourceSource getRelativeSource(final String name) {
if (logger.isLoggable(Level.WARNING)) {
logger.logp(
Level.WARNING,
getClass().getName(),
"getRelativeSource(String)",
"StringResourceSource does not support this method.");
}
return null;
}
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Benchmark
public void param3JulFile() {
// must specify sourceClass or JUL will look it up by walking the stack trace!
julLogger.logp(
Level.INFO,
getClass().getName(),
"param3JulFile",
"Val1={}, val2={}, val3={}",
new Object[] {++j, ++k, ++m});
}