/**
* Configures the Logger (log4j) class used by the entire library to log what happens at run time.
*
* @param logToConsole determines if log4j engine should log to the standard output or not.
* @return a Logger class used to log events and functional meanings of the application.
*/
public Logger configure(boolean logToConsole) {
Logger log = Logger.getLogger(clazz);
boolean loadDefaults = false;
String logPath = null;
PatternLayout layout = null;
Strings str = Strings.getOne();
String logLevel = "", logConsoleLevel = "", logFileLevel = "";
try {
Constants c = Constants.getOne(clazz);
Properties log4j = c.getLog4j();
loadDefaults = log4j.isEmpty();
if (!loadDefaults) {
PropertyConfigurator.configure(log4j);
} else {
logLevel = c.getConstant("log.level");
logConsoleLevel = c.getConstant("log.console.level");
logFileLevel = c.getConstant("log.file.level");
logPath = str.safeConcatPaths(c.getConstant("log.dir"), c.getConstant("log.file"));
if (!str.checkPathExistence(logPath)) {
str.createPath(logPath);
new File(logPath).createNewFile();
}
layout = new PatternLayout(c.getConstant("log.pattern"));
}
} catch (Throwable e) {
logPath = str.safeConcatPaths(Constants.USER_HOME, "." + Constants.FPM_DIR);
if (!str.checkPathExistence(logPath)) {
str.createPath(logPath);
}
logPath = str.safeConcatPaths(logPath, Constants.MAIN_LOG_FILE);
layout = new PatternLayout(Constants.DEFAULT_LOG_PATTERN);
loadDefaults = true;
}
if (loadDefaults) {
log.setLevel(Level.toLevel(logLevel));
if (logToConsole) {
ConsoleAppender consapp = new ConsoleAppender(layout);
consapp.setTarget("System.out");
consapp.setThreshold(Level.toLevel(logConsoleLevel));
log.addAppender(consapp);
}
FileAppender fileapp;
try {
fileapp = new FileAppender(layout, logPath);
fileapp.setThreshold(Level.toLevel(logFileLevel));
log.addAppender(fileapp);
} catch (IOException e) {
log.warn("FileAppender not initialized! ".concat(e.getMessage()));
}
}
log.trace("Logger initialized!");
return log;
}
/* (non-Javadoc)
* @see org.apache.log4j.Level#toLevel(java.lang.String, org.apache.log4j.Level)
*/
public static Level toLevel(String arg0, Level arg1) {
if (NOTICE.toString().equals(arg0)) return NOTICE;
if (FINEST.toString().equals(arg0)) return FINEST;
if (FINER.toString().equals(arg0)) return FINER;
if (FINE.toString().equals(arg0)) return FINE;
return Level.toLevel(arg0, arg1);
}
public static void main(String[] args) throws Exception {
// tell jetty to use SLF4J for logging instead of its own stuff
System.setProperty("VERBOSE", "false");
System.setProperty("org.mortbay.log.class", "org.mortbay.log.Slf4jLog");
// tell macosx to keep the menu associated with the screen and what the app title is
System.setProperty("apple.laf.useScreenMenuBar", "true");
System.setProperty("com.apple.eawt.CocoaComponent.CompatibilityMode", "false");
System.setProperty("com.apple.mrj.application.apple.menu.about.name", "OpenRefine");
// tell the signpost library to log
// System.setProperty("debug","true");
// set the log verbosity level
org.apache.log4j.Logger.getRootLogger()
.setLevel(Level.toLevel(Configurations.get("refine.verbosity", "info")));
port = Configurations.getInteger("refine.port", DEFAULT_PORT);
host = Configurations.get("refine.host", DEFAULT_HOST);
Refine refine = new Refine();
refine.init(args);
}
/**
* set a logger's level
*
* @param name the name of the logger
* @param level the level to set
*/
public void setLoggerLevel(String name, String level) {
org.apache.log4j.Logger logger = org.apache.log4j.LogManager.getLogger(name);
if (logger != null) {
logger.setLevel(org.apache.log4j.Level.toLevel(level));
}
}
/**
* Converts a standard or custom priority level to a Level object.
*
* <p>If <code>value</code> is of form "level#classname", then the specified class' toLevel method
* is called to process the specified level string; if no '#' character is present, then the
* default {@link org.apache.log4j.Level} class is used to process the level value.
*
* <p>As a special case, if the <code>value</code> parameter is equal to the string "NULL", then
* the value <code>null</code> will be returned.
*
* <p>If any error occurs while converting the value to a level, the <code>defaultValue</code>
* parameter, which may be <code>null</code>, is returned.
*
* <p>Case of <code>value</code> is insignificant for the level level, but is significant for the
* class name part, if present.
*
* @since 1.1
*/
public static Level toLevel(String value, Level defaultValue) {
if (value == null) return defaultValue;
value = value.trim();
int hashIndex = value.indexOf('#');
if (hashIndex == -1) {
if ("NULL".equalsIgnoreCase(value)) {
return null;
} else {
// no class name specified : use standard Level class
return (Level) Level.toLevel(value, defaultValue);
}
}
Level result = defaultValue;
String clazz = value.substring(hashIndex + 1);
String levelName = value.substring(0, hashIndex);
// This is degenerate case but you never know.
if ("NULL".equalsIgnoreCase(levelName)) {
return null;
}
LogLog.debug("toLevel" + ":class=[" + clazz + "]" + ":pri=[" + levelName + "]");
try {
Class customLevel = Loader.loadClass(clazz);
// get a ref to the specified class' static method
// toLevel(String, org.apache.log4j.Level)
Class[] paramTypes = new Class[] {String.class, org.apache.log4j.Level.class};
java.lang.reflect.Method toLevelMethod = customLevel.getMethod("toLevel", paramTypes);
// now call the toLevel method, passing level string + default
Object[] params = new Object[] {levelName, defaultValue};
Object o = toLevelMethod.invoke(null, params);
result = (Level) o;
} catch (ClassNotFoundException e) {
LogLog.warn("custom level class [" + clazz + "] not found.");
} catch (NoSuchMethodException e) {
LogLog.warn(
"custom level class ["
+ clazz
+ "]"
+ " does not have a constructor which takes one string parameter",
e);
} catch (java.lang.reflect.InvocationTargetException e) {
LogLog.warn("custom level class [" + clazz + "]" + " could not be instantiated", e);
} catch (ClassCastException e) {
LogLog.warn("class [" + clazz + "] is not a subclass of org.apache.log4j.Level", e);
} catch (IllegalAccessException e) {
LogLog.warn("class [" + clazz + "] cannot be instantiated due to access restrictions", e);
} catch (Exception e) {
LogLog.warn("class [" + clazz + "], level [" + levelName + "] conversion failed.", e);
}
return result;
}
/**
* Parse first 2 arguments, corresponding to the "-op" option.
*
* @param args
* @return true if operation is all, which means that options not related to this operation
* should be ignored, or false otherwise, meaning that usage should be printed when an
* unrelated option is encountered.
* @throws IOException
*/
protected boolean verifyOpArgument(List<String> args) {
if (args.size() < 2 || !args.get(0).startsWith("-op")) printUsage();
// process common options
int krIndex = args.indexOf("-keepResults");
keepResults = (krIndex >= 0);
if (keepResults) {
args.remove(krIndex);
}
int llIndex = args.indexOf("-logLevel");
if (llIndex >= 0) {
if (args.size() <= llIndex + 1) printUsage();
logLevel = Level.toLevel(args.get(llIndex + 1), Level.ERROR);
args.remove(llIndex + 1);
args.remove(llIndex);
}
int ugrcIndex = args.indexOf("-UGCacheRefreshCount");
if (ugrcIndex >= 0) {
if (args.size() <= ugrcIndex + 1) printUsage();
int g = Integer.parseInt(args.get(ugrcIndex + 1));
if (g > 0) ugcRefreshCount = g;
args.remove(ugrcIndex + 1);
args.remove(ugrcIndex);
}
String type = args.get(1);
if (OP_ALL_NAME.equals(type)) {
type = getOpName();
return true;
}
if (!getOpName().equals(type)) printUsage();
return false;
}
public static void log(String level, Object msg, Throwable e) {
try {
StringBuilder sb = new StringBuilder();
Throwable t = new Throwable();
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
String input = sw.getBuffer().toString();
StringReader sr = new StringReader(input);
BufferedReader br = new BufferedReader(sr);
for (int i = 0; i < 4; i++) br.readLine();
String line = br.readLine();
int paren = line.indexOf("at ");
line = line.substring(paren + 3);
paren = line.indexOf('(');
String invokeInfo = line.substring(0, paren);
int period = invokeInfo.lastIndexOf('.');
sb.append('[');
sb.append(invokeInfo.substring(0, period));
sb.append(':');
sb.append(invokeInfo.substring(period + 1));
sb.append("():");
paren = line.indexOf(':');
period = line.lastIndexOf(')');
sb.append(line.substring(paren + 1, period));
sb.append(']');
sb.append(" - ");
sb.append(msg);
getLogger().log((Priority) Level.toLevel(level), sb.toString(), e);
} catch (Exception ex) {
LogUtil.info(ex.getLocalizedMessage());
}
}
// com.feilong.spring.aspects.UserManager
@Around(value = "pointcut()")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
// LoggerFactory.
// log.
Method method = getMethod(joinPoint, Log.class);
String methodName = method.getName();
Date begin = new Date();
// 通过反射执行目标对象的连接点处的方法
joinPoint.proceed();
// 在来得到方法名吧，就是通知所要织入目标对象中的方法名称
Date end = new Date();
Object[] args = joinPoint.getArgs();
// for (Object arg : args){
// log.info("arg:{}", arg.toString());
// }
// log.info("{},{}", begin, end);
_log = (Log) getAnnotation(joinPoint, Log.class);
String level = _log.level();
// log.debug("level:{}", level);
// 输出的日志 怪怪的 02:13:10 INFO (NativeMethodAccessorImpl.java:?) [invoke0()] method:addUser([1018,
// Jummy]),耗时:0
// ReflectUtil.invokeMethod(log, level, "method:{}({}),耗时:{}", objects);
String format = "method:%s(%s),耗时:%s";
Object[] objects = {methodName, args, DateUtil.getIntervalForView(begin, end)};
Object message = StringUtil.format(format, objects);
log.log(Level.toLevel(level), message);
}
/** Test that dotted lower I + "nfo" is recognized as INFO even in Turkish locale. */
@Test
public void testDottedLowerI() {
final Locale defaultLocale = Locale.getDefault();
final Locale turkey = new Locale("tr", "TR");
Locale.setDefault(turkey);
final Level level = Level.toLevel("info");
Locale.setDefault(defaultLocale);
assertEquals("INFO", level.toString());
}
/** 设置Logger的日志级别. 如果日志级别名称错误, 设为DEBUG. */
@ManagedOperation(description = "Set new logging level to the logger")
@ManagedOperationParameters({
@ManagedOperationParameter(name = "loggerName", description = "Logger name"),
@ManagedOperationParameter(name = "newlevel", description = "New level")
})
public void setLoggerLevel(String loggerName, String newLevel) {
Logger logger = Logger.getLogger(loggerName);
Level level = Level.toLevel(newLevel);
logger.setLevel(level);
mbeanLogger.info("设置{}级别为{}", loggerName, newLevel);
}
private void updateCustomLevelDefinitionMap() {
if (customLevelDefinitions != null) {
StringTokenizer entryTokenizer = new StringTokenizer(customLevelDefinitions, ",");
customLevelDefinitionMap.clear();
while (entryTokenizer.hasMoreTokens()) {
StringTokenizer innerTokenizer = new StringTokenizer(entryTokenizer.nextToken(), "=");
customLevelDefinitionMap.put(
innerTokenizer.nextToken(), Level.toLevel(innerTokenizer.nextToken()));
}
}
}
@Managed(description = "Set the log level on a per logger basis")
public void setLevel(final String loggerName, final String levelString) {
final Logger logger;
if (!StringUtils.isEmpty(loggerName)) {
logger = LogManager.getLogger(loggerName);
} else {
logger = LogManager.getRootLogger();
}
logger.setLevel(Level.toLevel(levelString));
}
/**
* @param level string representation of Logging-levels as used in log4j
* @return true if specified logging-level is enabled
*/
public static boolean isEnabledFor(String level) {
// go from level-string to log4j-level-object
org.apache.log4j.Level log4jLevel = org.apache.log4j.Level.toLevel(level);
if (forceJuli || log4j == null) {
// must translate from log4j-level to jul-level
java.util.logging.Level julLevel = toJuliLevel(log4jLevel.toString());
// check level against jul
return juli.isLoggable(julLevel);
} else {
// check level against log4j
return log4j.isEnabledFor(log4jLevel);
}
}
/* (non-Javadoc)
* @see org.apache.log4j.Level#toLevel(int, org.apache.log4j.Level)
*/
public static Level toLevel(int arg0, Level arg1) {
switch (arg0) {
case NOTICE_INT:
return NOTICE;
case FINEST_INT:
return FINEST;
case FINER_INT:
return FINER;
case FINE_INT:
return FINE;
default:
return Level.toLevel(arg0, arg1);
}
}
@Override
public void init() {
org.apache.log4j.Logger.getRootLogger().removeAllAppenders();
org.apache.log4j.Logger.getRootLogger()
.addAppender(new ConsoleAppender(new PatternLayout("%-5p %30.30c{2} %m%n")));
final String levelName = System.getProperty(PROPERTY_LOGGING_LEVEL);
final Level level;
if (levelName == null) {
level = Level.INFO;
} else {
level = Level.toLevel(levelName);
}
org.apache.log4j.Logger.getLogger("org.trancecode").setLevel(level);
LOG.trace("{@method} servlet = {}", getServletName());
}
public static void setLevel(Logger logger, Level level, String... allLoggers) {
Appender app = Logger.getLogger("jrds").getAppender(JrdsLoggerConfiguration.APPENDERNAME);
// The system property override the code log level
if (System.getProperty("jrds.testloglevel") != null) {
level = Level.toLevel(System.getProperty("jrds.testloglevel"));
logger.setLevel(level);
}
logger.setLevel(level);
for (String loggerName : allLoggers) {
Logger l = Logger.getLogger(loggerName);
l.setLevel(level);
if (l.getAppender(JrdsLoggerConfiguration.APPENDERNAME) != null) {
l.addAppender(app);
}
}
}
public static Map<String, Object> addOrUpdateLogger(
DispatchContext dctc, Map<String, ?> context) {
String name = (String) context.get("name");
String level = (String) context.get("level");
boolean additivity = "Y".equalsIgnoreCase((String) context.get("additivity"));
Logger logger = null;
if ("root".equals(name)) {
logger = Logger.getRootLogger();
} else {
logger = Logger.getLogger(name);
}
logger.setLevel(Level.toLevel(level));
logger.setAdditivity(additivity);
return ServiceUtil.returnSuccess();
}
/**
* Force logger to a new level.
*
* @param level TRACE,DEBUG,INFO,WARN,ERROR,FATAL
*/
public static void setUp(String level) {
if (forceJuli || log4j == null) {
Logger.juli.setLevel(toJuliLevel(level));
} else {
Logger.log4j.setLevel(org.apache.log4j.Level.toLevel(level));
if (redirectJuli) {
java.util.logging.Logger rootLogger = java.util.logging.Logger.getLogger("");
for (Handler handler : rootLogger.getHandlers()) {
rootLogger.removeHandler(handler);
}
Handler activeHandler = new JuliToLog4jHandler();
java.util.logging.Level juliLevel = toJuliLevel(level);
activeHandler.setLevel(juliLevel);
rootLogger.addHandler(activeHandler);
rootLogger.setLevel(juliLevel);
}
}
}
static void initializeLogging() throws SipXOpenfirePluginException {
try {
String javaClassPaths = System.getProperty("java.class.path");
String openfireHome = System.getProperty("openfire.home");
StringBuilder sb =
new StringBuilder(javaClassPaths).append(":" + openfireHome + "/lib/sipxcommons.jar");
System.setProperty("java.class.path", sb.toString());
String log4jPropertiesFile = configurationPath + "/log4j.properties";
if (new File(log4jPropertiesFile).exists()) {
/*
* Override the file configuration setting.
*/
Properties props = new Properties();
props.load(new FileInputStream(log4jPropertiesFile));
String level = props.getProperty("log4j.category.org.sipfoundry.openfire");
if (level != null) {
watcherConfig.setLogLevel(level);
}
}
setLogAppender(new SipFoundryAppender(new SipFoundryLayout(), logFile));
// TODO -- this should be org.sipfoundry.openfire.
Logger applicationLogger = Logger.getLogger("org.sipfoundry");
/*
* Set the log level.
*/
if (watcherConfig.getLogLevel().equals("TRACE")) {
applicationLogger.setLevel(org.apache.log4j.Level.DEBUG);
} else {
applicationLogger.setLevel(org.apache.log4j.Level.toLevel(watcherConfig.getLogLevel()));
}
applicationLogger.addAppender(getLogAppender());
if (System.getProperty("output.console") != null) {
applicationLogger.addAppender(new ConsoleAppender(new PatternLayout()));
}
CallWatcher.setLogAppender(getLogAppender());
} catch (Exception ex) {
throw new SipXOpenfirePluginException(ex);
}
}
/** @see DefaultHandler * */
public void startElement(
String aNamespaceURI, String aLocalName, String aQName, Attributes aAtts) {
mBuf.setLength(0);
if (TAG_EVENT.equals(aQName)) {
mThreadName = aAtts.getValue("thread");
mTimeStamp = Long.parseLong(aAtts.getValue("timestamp"));
mCategoryName = aAtts.getValue("logger");
mLevel = Level.toLevel(aAtts.getValue("level"));
} else if (TAG_LOCATION_INFO.equals(aQName)) {
mLocationDetails =
aAtts.getValue("class")
+ "."
+ aAtts.getValue("method")
+ "("
+ aAtts.getValue("file")
+ ":"
+ aAtts.getValue("line")
+ ")";
}
}
// TODO jz: log4j.properties should be used instead
private static void configureLog4J(Properties properties) {
// TODO Add a file appender for the logs
// TODO Need to create a property in the properties file for it.
// sgroschupf, 25Feb2008: this method will be obsolete with PIG-115.
String log4jconf = properties.getProperty(LOG4J_CONF);
String trueString = "true";
boolean brief = trueString.equalsIgnoreCase(properties.getProperty(BRIEF));
Level logLevel = Level.INFO;
String logLevelString = properties.getProperty(DEBUG);
if (logLevelString != null) {
logLevel = Level.toLevel(logLevelString, Level.INFO);
}
if (log4jconf != null) {
PropertyConfigurator.configure(log4jconf);
} else if (!brief) {
// non-brief logging - timestamps
Properties props = new Properties();
props.setProperty("log4j.rootLogger", "INFO, PIGCONSOLE");
props.setProperty("log4j.appender.PIGCONSOLE", "org.apache.log4j.ConsoleAppender");
props.setProperty("log4j.appender.PIGCONSOLE.layout", "org.apache.log4j.PatternLayout");
props.setProperty(
"log4j.appender.PIGCONSOLE.layout.ConversionPattern", "%d [%t] %-5p %c - %m%n");
props.setProperty("log4j.appender.PIGCONSOLE.target", "System.err");
PropertyConfigurator.configure(props);
} else {
// brief logging - no timestamps
Properties props = new Properties();
props.setProperty("log4j.rootLogger", "INFO, PIGCONSOLE");
props.setProperty("log4j.appender.PIGCONSOLE", "org.apache.log4j.ConsoleAppender");
props.setProperty("log4j.appender.PIGCONSOLE.layout", "org.apache.log4j.PatternLayout");
props.setProperty("log4j.appender.PIGCONSOLE.layout.ConversionPattern", "%m%n");
props.setProperty("log4j.appender.PIGCONSOLE.target", "System.err");
PropertyConfigurator.configure(props);
}
}
private static Level setLogLevel() {
final String LOGGER_PREFIX = "log4j.logger.";
for (String propertyName : System.getProperties().stringPropertyNames()) {
if (propertyName.startsWith(LOGGER_PREFIX)) {
String loggerName = propertyName.substring(LOGGER_PREFIX.length());
String levelName = System.getProperty(propertyName, "");
Level level = Level.toLevel(levelName); // defaults to DEBUG
if (!"".equals(levelName) && !levelName.toUpperCase().equals(level.toString())) {
logger.error(
"Skipping unrecognized log4j log level "
+ levelName
+ ": -D"
+ propertyName
+ "="
+ levelName);
continue;
}
return level;
}
}
return Level.ERROR;
}
public void setLevel(int level) {
_level = Level.toLevel(level);
}
/**
* Convert a keyword-to-values map to a LoggingEvent
*
* @param fieldMap
* @param exception
* @return logging event
*/
private LoggingEvent convertToEvent(Map fieldMap, String[] exception) {
if (fieldMap == null) {
return null;
}
// a logger must exist at a minimum for the event to be processed
if (!fieldMap.containsKey(LOGGER)) {
fieldMap.put(LOGGER, "Unknown");
}
if (exception == null) {
exception = emptyException;
}
Logger logger = null;
long timeStamp = 0L;
String level = null;
String threadName = null;
Object message = null;
String ndc = null;
String className = null;
String methodName = null;
String eventFileName = null;
String lineNumber = null;
Hashtable properties = new Hashtable();
logger = Logger.getLogger((String) fieldMap.remove(LOGGER));
if ((dateFormat != null) && fieldMap.containsKey(TIMESTAMP)) {
try {
timeStamp = dateFormat.parse((String) fieldMap.remove(TIMESTAMP)).getTime();
} catch (Exception e) {
e.printStackTrace();
}
}
// use current time if timestamp not parseable
if (timeStamp == 0L) {
timeStamp = System.currentTimeMillis();
}
message = fieldMap.remove(MESSAGE);
if (message == null) {
message = "";
}
level = (String) fieldMap.remove(LEVEL);
Level levelImpl;
if (level == null) {
levelImpl = Level.DEBUG;
} else {
// first try to resolve against custom level definition map, then fall back to regular levels
levelImpl = (Level) customLevelDefinitionMap.get(level);
if (levelImpl == null) {
levelImpl = Level.toLevel(level.trim());
if (!level.equals(levelImpl.toString())) {
// check custom level map
if (levelImpl == null) {
levelImpl = Level.DEBUG;
getLogger()
.debug(
"found unexpected level: "
+ level
+ ", logger: "
+ logger.getName()
+ ", msg: "
+ message);
// make sure the text that couldn't match a level is added to the message
message = level + " " + message;
}
}
}
}
threadName = (String) fieldMap.remove(THREAD);
ndc = (String) fieldMap.remove(NDC);
className = (String) fieldMap.remove(CLASS);
methodName = (String) fieldMap.remove(METHOD);
eventFileName = (String) fieldMap.remove(FILE);
lineNumber = (String) fieldMap.remove(LINE);
properties.put(Constants.HOSTNAME_KEY, host);
properties.put(Constants.APPLICATION_KEY, path);
properties.put(Constants.RECEIVER_NAME_KEY, getName());
// all remaining entries in fieldmap are properties
properties.putAll(fieldMap);
LocationInfo info = null;
if ((eventFileName != null)
|| (className != null)
|| (methodName != null)
|| (lineNumber != null)) {
info = new LocationInfo(eventFileName, className, methodName, lineNumber);
} else {
info = LocationInfo.NA_LOCATION_INFO;
}
LoggingEvent event =
new LoggingEvent(
null,
logger,
timeStamp,
levelImpl,
message,
threadName,
new ThrowableInformation(exception),
ndc,
info,
properties);
return event;
}
@Expose("set_level")
@Help("Sets the level")
public void set_level(@Argument(type = "String", name = "level") String level) {
object.setLevel(Level.toLevel(level));
}
public static void main(String[] args) throws Exception {
Logging.setLoggingDefaults(Level.WARN);
CommandLineParser parser = new PosixParser();
Options options = createCommandLineOptions();
String deviceType = null;
String port = null;
Map<String, String> configuration = newHashMap();
DeviceMacReferenceMap deviceMacReferenceMap = null;
boolean use16BitMode = true;
try {
CommandLine line = parser.parse(options, args, true);
if (line.hasOption('h')) {
printUsageAndExit(DeviceMacReaderCLI.class, options, 0);
}
if (line.hasOption('v')) {
org.apache.log4j.Logger.getRootLogger().setLevel(Level.DEBUG);
}
if (line.hasOption('l')) {
Level level = Level.toLevel(line.getOptionValue('l'));
org.apache.log4j.Logger.getRootLogger().setLevel(level);
}
if (line.hasOption('c')) {
final String configurationFileString = line.getOptionValue('c');
final File configurationFile = new File(configurationFileString);
final Properties configurationProperties = new Properties();
configurationProperties.load(new FileReader(configurationFile));
for (Map.Entry<Object, Object> entry : configurationProperties.entrySet()) {
configuration.put((String) entry.getKey(), (String) entry.getValue());
}
}
if (line.hasOption('r')) {
deviceMacReferenceMap = readDeviceMacReferenceMap(line.getOptionValue('r'));
}
assertParametersPresent(line, 't', 'p');
deviceType = line.getOptionValue('t');
port = line.getOptionValue('p');
use16BitMode = !line.hasOption('x');
} catch (Exception e) {
log.error("Invalid command line: " + e);
printUsageAndExit(DeviceMacReaderCLI.class, options, EXIT_CODE_INVALID_ARGUMENTS);
}
ExecutorService executorService =
Executors.newCachedThreadPool(
new ThreadFactoryBuilder().setNameFormat("DeviceMacReader %d").build());
final Injector injector =
Guice.createInjector(
new DeviceFactoryModule(),
new DeviceMacReaderModule(executorService, deviceMacReferenceMap, use16BitMode));
final DeviceMacReader deviceMacReader = injector.getInstance(DeviceMacReader.class);
String reference = null;
if (deviceMacReferenceMap != null) {
final DeviceObserver deviceObserver = injector.getInstance(DeviceObserver.class);
final ImmutableList<DeviceEvent> events = deviceObserver.getEvents(null);
for (DeviceEvent event : events) {
final boolean samePort = port.equals(event.getDeviceInfo().getPort());
if (samePort) {
reference = event.getDeviceInfo().getReference();
}
}
}
try {
final MacAddress macAddress =
deviceMacReader.readMac(port, deviceType, configuration, reference);
log.info(
"Read MAC address of {} device at port {}: {}",
new Object[] {deviceType, port, macAddress});
System.out.println(macAddress.toHexString());
System.exit(0);
} catch (Exception e) {
log.error("Reading MAC address failed with Exception: " + e, e);
System.exit(1);
}
}
/**
* Get current log level for module XSD Importer. On error, or by default this method returns root
* log level.
*
* @return Current log level for XSD Importer.
*/
public static Level getLogLevel() {
return Level.toLevel(
PROPERTIES.getProperty(
XSDImportPropertiesPanel.LOG_LEVEL_PROP, XSDImportPropertiesPanel.LOG_LEVEL_DEFAULT),
Logger.getRootLogger().getLevel());
}
public void setLogLevels(Map<String, String> logLevels) {
this.logLevels = new HashMap<>();
for (String name : logLevels.keySet())
this.logLevels.put(name, Level.toLevel(logLevels.get(name)));
}
public void setLevel(String level) {
_level = Level.toLevel(level);
}
public void setLevel(String classname, String level) {
Logger log4j = Logger.getLogger(classname);
Level logLevel = Level.toLevel(level);
log4j.setLevel(logLevel);
}
