private void logToChat(Level l, String message) {
if (chatLevel.intValue() <= l.intValue()) {
for (Player player : getServer().getOnlinePlayers()) {
if (hasPermission(player, PermissionData.PERMISSION_NOTIFY, false)) {
player.sendMessage("[" + l.getName() + "] " + message);
}
}
}
}
public void assertDeserialized(Serializable initial, Serializable deserialized) {
Level init = (Level) initial;
Level dser = (Level) deserialized;
assertEquals("Class", init.getClass(), dser.getClass());
assertEquals("Name", init.getName(), dser.getName());
assertEquals("Value", init.intValue(), dser.intValue());
assertEquals(
"ResourceBundleName", init.getResourceBundleName(), dser.getResourceBundleName());
}
public synchronized void setOutputStream(OutputStream out) {
if (out != null) {
if (VERBOSE.intValue() < levelValue) {
levelValue = VERBOSE.intValue();
}
stream.setOutputStream(out);
} else {
/* ensure that messages are not logged */
levelValue = Level.OFF.intValue();
}
}
private static void setVlog(Logger logger, LogLevel logLevel) {
final Level newLevel = logLevel.getLevel();
logger.setLevel(newLevel);
do {
for (Handler handler : logger.getHandlers()) {
Level handlerLevel = handler.getLevel();
if (newLevel.intValue() < handlerLevel.intValue()) {
handler.setLevel(newLevel);
}
}
} while (logger.getUseParentHandlers() && (logger = logger.getParent()) != null);
}
protected static void Log(Level loglevel, String txt, boolean sendReport) {
logger.log(loglevel, String.format("[%s] %s", name, txt == null ? "" : txt));
if (config != null) {
if (sendReport && loglevel.intValue() > Level.WARNING.intValue() && config.sendErrorReports) {
sendErrorReport(txt, null);
}
if (messenger != null
&& loglevel.intValue() > Level.INFO.intValue()
&& config.sendLogOnError) {
messenger.sendNotify(String.format("[%s] %s", name, txt == null ? "" : txt));
}
}
}
public ChatArguments colorizeLevel(Level level) {
ChatStyle color;
if (level.intValue() >= Level.SEVERE.intValue()) {
color = ChatStyle.RED;
} else if (level.intValue() >= Level.WARNING.intValue()) {
color = ChatStyle.YELLOW;
} else if (level.intValue() >= Level.INFO.intValue()) {
color = ChatStyle.DARK_GREEN;
} else {
color = ChatStyle.GRAY;
}
return new ChatArguments(color, level, ChatStyle.RESET);
}
public static void log(Level pLevel, Exception pExp) {
if (pLevel.intValue() >= Catalog.LOG_LEVEL.intValue()) {
StringWriter pMsg = new StringWriter();
pExp.printStackTrace(new PrintWriter(pMsg));
log("[" + pLevel.getName() + "] " + pMsg.toString());
}
}
protected static void setupSidlogger(Level lvl) {
if (!Level.OFF.equals(lvl)) {
Filter bslf = new BoshSidLoggerFilter();
Logger BoshConnectionManagerLogger = Logger.getLogger(BoshConnectionManager.class.getName());
Logger BoshSessionLogger = Logger.getLogger(BoshSession.class.getName());
if (BoshConnectionManagerLogger.getLevel() == null
|| BoshSessionLogger.getLevel() == null
|| BoshConnectionManagerLogger.getLevel().intValue() < lvl.intValue()) {
BoshConnectionManagerLogger.setLevel(lvl);
BoshConnectionManagerLogger.setFilter(bslf);
BoshSessionLogger.setLevel(lvl);
BoshSessionLogger.setFilter(bslf);
BoshConnectionManagerLogger.getParent().setFilter(bslf);
}
try {
if (null == sidFilehandler) {
sidFilehandler = new FileHandler("logs/bosh_sid.log", 10000000, 5, false);
sidFilehandler.setLevel(lvl);
sidFilehandler.setFilter(bslf);
BoshConnectionManagerLogger.getParent().addHandler(sidFilehandler);
}
} catch (IOException ex) {
log.log(Level.CONFIG, "Error creating BOSH SID logger" + ex);
}
}
}
/**
* The launcher allows for the following logging levels: "FINEST", "FINE", "INFO", "WARNING",
* "SEVERE". Since the launcher is unusually chatty, we don't want it to use the same logging
* level as OperaDriver. Besides, it doesn't have the same logging levels as Java. This method
* accepts a Java logging level and converts it to something sensible to pass on to the launcher.
*
* @param level the Java logging level
* @return a sensible, non-chatty logging level
*/
protected static Level toLauncherLoggingLevel(Level level) {
// ALL -2147483648
// FINEST 300
// FINER 400
// FINE 500
// CONFIG 700
// INFO 800
// WARNING 900
// SEVERE 1000
// OFF 2147483647
switch (level.intValue()) {
case 1000: // SEVERE
return Level.SEVERE;
case 900: // WARNING
return Level.WARNING;
case 800: // INFO
case 700: // CONFIG
case 500: // FINE
case 400: // FINER
return Level.FINE;
case 300: // FINEST
case -2147483648: // ALL
return Level.FINEST;
default: // OFF
return Level.OFF;
}
}
public void setLogLevel(int newLevel) {
int currentLevel = 0;
if (getLogger().getLevel() != null) {
currentLevel = getLogger().getLevel().intValue();
}
Level lLevel = null;
if (newLevel == LOG_TRACEDEBUG_LEVEL) {
lLevel = Level.FINEST;
} else if (newLevel == LOG_TRACEENTRY_LEVEL
|| newLevel == LOG_TRACEEXIT_LEVEL
|| newLevel == LOG_TRACEENTRYEXIT_LEVEL) {
lLevel = Level.FINER;
} else if (newLevel == LOG_TRACEEVENT_LEVEL) {
lLevel = Level.FINE;
} else if (newLevel == LOG_INFO_LEVEL) {
lLevel = Level.INFO;
} else if (newLevel == LOG_WARN_LEVEL) {
lLevel = Level.WARNING;
} else if (newLevel == LOG_ERROR_LEVEL) {
lLevel = Level.SEVERE;
}
if (lLevel != null && lLevel.intValue() != currentLevel) {
resetLevels(getLogger(), lLevel);
}
}
@Override
public void publish(LogRecord record) {
Level level = record.getLevel();
Throwable t = record.getThrown();
AttributeSet attributes = defaultAttributes;
if (level.intValue() >= Level.WARNING.intValue()) {
attributes = errorAttributes;
} else if (level.intValue() < Level.INFO.intValue()) {
attributes = debugAttributes;
}
log(record.getMessage() + "\n", attributes);
if (t != null) {
log(getStackTrace(t) + "\n", attributes);
}
}
@Override
public void log(final Object msg, final Level level, final int depth) {
if (level.intValue() >= debugLevel.intValue()) {
final StringBuilder tabBuffer = new StringBuilder();
tabBuffer.append(':');
for (int i = 0; i < depth; i++) {
tabBuffer.append(INDENTATION_CHAR);
}
final StringBuilder buffer = new StringBuilder();
buffer.append(tabBuffer);
buffer.append(
msg.toString().replaceAll(NEW_LINE_STRING, NEW_LINE_STRING + tabBuffer.toString()));
System.out.println(buffer);
}
}
/**
* Store a LogRecord in the ring buffer
*
* @param record Description of the log event. A null record is silently ignored and is not
* published
*/
@Override
public void publish(LogRecord record) {
if (record != null
&& record.getLevel().intValue() >= level.intValue()
&& level.intValue() != OFF_VALUE) {
synchronized (buffer) {
int ix = (start + count) % buffer.length;
buffer[ix] = record;
if (count < buffer.length) {
count++;
} else {
start++;
start %= buffer.length;
}
}
}
}
private LogStreamLog(LogStream stream, Level level) {
if ((stream != null) && (level != null)) {
/* if the stream or level is null, dont log any
* messages
*/
levelValue = level.intValue();
}
this.stream = stream;
}
/*
* (non-Javadoc)
*
* @see com.jcraft.jsch.Logger#isEnabled(int)
*/
public boolean isEnabled(int level) {
Level jdkLogLevel = null;
if (logger == null || (jdkLogLevel = toJDKLogLevel(level)) == Level.OFF) {
return false;
}
// Return true if the JDK logger level emcompasses the given JSch log
// level
return logger.getLevel().intValue() <= jdkLogLevel.intValue();
}
/**
* @param level {@link Level} The level to filter the log entries.
* @return all log entries for that level and above.
*/
public List<LogEntry> filter(Level level) {
List<LogEntry> toReturn = new ArrayList<LogEntry>();
for (LogEntry entry : entries) {
if (entry.getLevel().intValue() >= level.intValue()) {
toReturn.add(entry);
}
}
return toReturn;
}
/**
* Method to avoid creating duplicate instances when deserializing the object.
*
* @return the singleton instance of this <code>Level</code> value in this classloader
* @throws ObjectStreamException If unable to deserialize
*/
protected Object readResolve() throws ObjectStreamException {
if (this.intValue() == INFO.intValue()) {
return INFO;
}
if (this.intValue() == STDERR.intValue()) {
return STDERR;
}
throw new InvalidObjectException("Unknown instance :" + this);
}
/**
* Starts to listen on given log and collect parameters of messages that were send to it. This is
* supposed to be called at the begining of a test, to get messages from the programs that use <a
* href="http://wiki.netbeans.org/wiki/view/FitnessViaTimersCounters">timers/counters</a>
* infrastructure. At the end one should call {@link #assertInstances}.
*
* @param log logger to listen on, if null, it uses the standard timers/counters one
* @param msg name of messages to collect, if null, all messages will be recorded
* @param level level of messages to record
* @since 1.44
*/
public static void enableInstances(Logger log, String msg, Level level) {
if (log == null) {
log = Logger.getLogger("TIMER"); // NOI18N
}
log.addHandler(new InstancesHandler(msg, level));
if (log.getLevel() == null || log.getLevel().intValue() > level.intValue()) {
log.setLevel(level);
}
}
protected static void Log(Level loglevel, Exception err, boolean sendReport) {
logger.log(
loglevel,
String.format("[%s] %s", name, err == null ? "? unknown exception ?" : err.getMessage()),
err);
if (config != null) {
if (sendReport && loglevel.intValue() > Level.WARNING.intValue() && config.sendErrorReports) {
sendErrorReport(null, err);
}
if (messenger != null
&& loglevel.intValue() > Level.INFO.intValue()
&& config.sendLogOnError) {
messenger.sendNotify(
String.format(
"[%s] %s%n%s",
name,
err == null ? "? unknown exception ?" : err.getMessage(),
Str.getStackStr(err)));
}
}
}
private synchronized void setLogging() throws IOException {
int consoleLevel = config.getPropertyAsInt("log.consoleLevel", 0);
int fileLevel = config.getPropertyAsInt("log.fileLevel", 0);
Level consoleLogLevel = LogFormatter.getLogLevel(consoleLevel);
Level fileLogLevel = LogFormatter.getLogLevel(fileLevel);
Level logLevel =
consoleLogLevel.intValue() < fileLogLevel.intValue() ? consoleLogLevel : fileLogLevel;
boolean showThreads = config.getPropertyAsBoolean("log.threads", false);
String[] packages = config.getPropertyAsArray("log.packages", "se.sics");
if (packages != null && packages.length > 0) {
for (int i = 0, n = packages.length; i < n; i++) {
Logger.getLogger(packages[i]).setLevel(logLevel);
}
} else {
Logger awRoot = Logger.getLogger("se.sics");
awRoot.setLevel(logLevel);
}
formatter.setShowingThreads(showThreads);
LogFormatter.setConsoleLevel(consoleLogLevel);
// LogFormatter.setLevelForAllHandlers(logLevel);
Logger root = Logger.getLogger("");
if (fileLogLevel != Level.OFF) {
if (rootFileHandler == null) {
rootFileHandler = new FileHandler(logFilePrefix + "%g.log", 1000000, 10);
rootFileHandler.setFormatter(formatter);
root.addHandler(rootFileHandler);
}
rootFileHandler.setLevel(fileLogLevel);
if (simLogHandler != null) {
simLogHandler.setLevel(fileLogLevel);
}
} else if (rootFileHandler != null) {
exitSimulationLog();
root.removeHandler(rootFileHandler);
rootFileHandler.close();
rootFileHandler = null;
}
}
protected static void Log(Level loglevel, String txt, Exception params, boolean sendReport) {
if (txt == null) {
Log(loglevel, params);
} else {
logger.log(
loglevel, String.format("[%s] %s", name, txt == null ? "" : txt), (Exception) params);
if (config != null) {
if (sendReport
&& loglevel.intValue() > Level.WARNING.intValue()
&& config.sendErrorReports) {
sendErrorReport(txt, params);
}
if (messenger != null
&& loglevel.intValue() > Level.INFO.intValue()
&& config.sendLogOnError) {
messenger.sendNotify(
String.format(
"[%s] %s%n%s", name, txt, params.getMessage(), Str.getStackStr(params)));
}
}
}
}
public Level setLevel(final String iLevel, final Class<? extends Handler> iHandler) {
final Level level =
iLevel != null ? Level.parse(iLevel.toUpperCase(Locale.ENGLISH)) : Level.INFO;
if (level.intValue() < minimumLevel.intValue()) {
// UPDATE MINIMUM LEVEL
minimumLevel = level;
if (level.equals(Level.FINER) || level.equals(Level.FINE) || level.equals(Level.FINEST))
debug = info = warn = error = true;
else if (level.equals(Level.INFO)) {
info = warn = error = true;
debug = false;
} else if (level.equals(Level.WARNING)) {
warn = error = true;
debug = info = false;
} else if (level.equals(Level.SEVERE)) {
error = true;
debug = info = warn = false;
}
}
Logger log = Logger.getLogger(DEFAULT_LOG);
while (log != null) {
log.setLevel(level);
for (Handler h : log.getHandlers()) {
if (h.getClass().isAssignableFrom(iHandler)) {
h.setLevel(level);
break;
}
}
log = log.getParent();
}
return level;
}
public void recordCondition(Plugin plugin, boolean shouldPrefix, String condition, Level level) {
String content = ChatColor.AQUA + condition;
String message = content;
String prefix = ChatColor.GRAY + plugin.getName() + ChatColor.GRAY + "] ";
if (shouldPrefix) {
message = prefix + content;
}
if (level.intValue() <= this.broadcastLevel.intValue()) {
Bukkit.broadcast(message, "pulse.observe");
}
System.out.println(
"[Pulse] " + level.getLocalizedName() + "] " + plugin.getName() + "] " + condition);
}
/** Renders the given log recorders as RSS. */
/*package*/ static void doRss(StaplerRequest req, StaplerResponse rsp, List<LogRecord> logs)
throws IOException, ServletException {
// filter log records based on the log level
String level = req.getParameter("level");
if (level != null) {
Level threshold = Level.parse(level);
List<LogRecord> filtered = new ArrayList<LogRecord>();
for (LogRecord r : logs) {
if (r.getLevel().intValue() >= threshold.intValue()) filtered.add(r);
}
logs = filtered;
}
RSS.forwardToRss(
"Hudson log",
"",
logs,
new FeedAdapter<LogRecord>() {
public String getEntryTitle(LogRecord entry) {
return entry.getMessage();
}
public String getEntryUrl(LogRecord entry) {
return "log"; // TODO: one URL for one log entry?
}
public String getEntryID(LogRecord entry) {
return String.valueOf(entry.getSequenceNumber());
}
public String getEntryDescription(LogRecord entry) {
return Functions.printLogRecord(entry);
}
public Calendar getEntryTimestamp(LogRecord entry) {
GregorianCalendar cal = new GregorianCalendar();
cal.setTimeInMillis(entry.getMillis());
return cal;
}
public String getEntryAuthor(LogRecord entry) {
return Mailer.descriptor().getAdminAddress();
}
},
req,
rsp);
}
/**
* Enables logging for given logger name and given severity. Everything logged to the object is
* going to go to the returned CharSequence object which can be used to check the content or
* converted <code>toString</code>.
*
* <p>The logging stops when the returned object is garbage collected.
*
* @param loggerName the name to capture logging for
* @param level the level of details one wants to get
* @return character sequence which can be check or converted to string
* @since 1.27
*/
public static CharSequence enable(String loggerName, Level level) {
IL il = new IL(false);
class MyPs extends PrintStream implements CharSequence {
private ByteArrayOutputStream os;
public MyPs() {
this(new ByteArrayOutputStream());
}
private MyPs(ByteArrayOutputStream arr) {
super(arr);
os = arr;
}
public int length() {
return toString().length();
}
public char charAt(int index) {
return toString().charAt(index);
}
public CharSequence subSequence(int start, int end) {
return toString().subSequence(start, end);
}
@Override
public String toString() {
return os.toString();
}
}
Logger l = Logger.getLogger(loggerName);
if (l.getLevel() == null || l.getLevel().intValue() > level.intValue()) {
l.setLevel(level);
}
MyPs ps = new MyPs();
Log log = new Log(l, ps);
log.setLevel(level);
l.addHandler(log);
return ps;
}
static void configure(Level lev, String root, NbTestCase current) {
IL il = new IL(false);
String c = "handlers=" + Log.class.getName() + "\n" + root + ".level=" + lev.intValue() + "\n";
ByteArrayInputStream is = new ByteArrayInputStream(c.getBytes());
try {
LogManager.getLogManager().readConfiguration(is);
} catch (IOException ex) {
// exception
ex.printStackTrace();
}
Log.current = current;
Log.messages.setLength(0);
Log.messages.append("Starting test ");
Log.messages.append(current.getName());
Log.messages.append('\n');
Log.initialMessages = Log.messages.length();
}
/**
* Flushes the log buffer, logging each buffered log message using the reef-bridge log function.
*/
private void logAll() {
synchronized (this) {
final StringBuilder sb = new StringBuilder();
Level highestLevel = Level.FINEST;
for (final LogRecord record : this.logs) {
sb.append(formatter.format(record));
sb.append("\n");
if (record.getLevel().intValue() > highestLevel.intValue()) {
highestLevel = record.getLevel();
}
}
try {
final int level = getLevel(highestLevel);
NativeInterop.clrBufferedLog(level, sb.toString());
} catch (Exception e) {
System.err.println("Failed to perform CLRBufferedLogHandler");
}
this.logs.clear();
}
}
protected static void enableTraceOptionIfSetOnConfiguration(
ILaunchConfiguration configuration, ProjectLauncher launcher) throws CoreException {
if (configuration.hasAttribute(LaunchConstants.ATTR_TRACE)) {
launcher.setTrace(
configuration.getAttribute(LaunchConstants.ATTR_TRACE, LaunchConstants.DEFAULT_TRACE));
}
String logLevelStr = configuration.getAttribute(ATTR_LOGLEVEL, (String) null);
if (logLevelStr != null) {
Plugin.getDefault()
.getLog()
.log(
new Status(
IStatus.WARNING,
Plugin.PLUGIN_ID,
0,
MessageFormat.format(
"The {0} attribute is no longer supported, use {1} instead.",
ATTR_LOGLEVEL, LaunchConstants.ATTR_TRACE),
null));
Level logLevel = Level.parse(logLevelStr);
launcher.setTrace(launcher.getTrace() || logLevel.intValue() <= Level.FINE.intValue());
}
}
/** Returns the Log4J level for the given Java level. */
@SuppressWarnings("fallthrough")
private static org.apache.log4j.Level toLog4JLevel(final Level level) {
final int n = level.intValue();
switch (n / 100) {
default:
{
// MAX_VALUE is a special value for Level.OFF. Otherwise and
// if positive, log to fatal since we are greater than SEVERE.
switch (n) {
default:
if (n >= 0) return org.apache.log4j.Level.FATAL; // fallthrough ALL otherwise.
case Integer.MIN_VALUE:
return org.apache.log4j.Level.ALL;
case Integer.MAX_VALUE:
return org.apache.log4j.Level.OFF;
}
}
case 10:
return org.apache.log4j.Level.ERROR; // SEVERE
case 9:
return org.apache.log4j.Level.WARN; // WARNING
case 8: // INFO
case 7:
return org.apache.log4j.Level.INFO; // CONFIG
case 6: // (not allocated)
case 5:
return org.apache.log4j.Level.DEBUG; // FINE
case 4:
return org.apache.log4j.Level.TRACE; // FINER
case 3: // FINEST
case 2: // (not allocated)
case 1: // (not allocated)
case 0:
return org.apache.log4j.Level.ALL; // ALL
}
}
/** @author Kamnev Georgiy */
public class LocalRepoCommands extends BaseCLIFun {
// <editor-fold defaultstate="collapsed" desc="log Функции">
private static final Logger logger = Logger.getLogger(LocalRepoCommands.class.getName());
private static final Level logLevel = logger.getLevel();
private static final boolean isLogSevere =
logLevel == null ? true : logLevel.intValue() <= Level.SEVERE.intValue();
private static final boolean isLogWarning =
logLevel == null ? true : logLevel.intValue() <= Level.WARNING.intValue();
private static final boolean isLogInfo =
logLevel == null ? true : logLevel.intValue() <= Level.INFO.intValue();
private static final boolean isLogFine =
logLevel == null ? true : logLevel.intValue() <= Level.FINE.intValue();
private static final boolean isLogFiner =
logLevel == null ? true : logLevel.intValue() <= Level.FINER.intValue();
private static final boolean isLogFinest =
logLevel == null ? true : logLevel.intValue() <= Level.FINEST.intValue();
private static void logFine(String message, Object... args) {
logger.log(Level.FINE, message, args);
}
private static void logFiner(String message, Object... args) {
logger.log(Level.FINER, message, args);
}
private static void logFinest(String message, Object... args) {
logger.log(Level.FINEST, message, args);
}
private static void logInfo(String message, Object... args) {
logger.log(Level.INFO, message, args);
}
private static void logWarning(String message, Object... args) {
logger.log(Level.WARNING, message, args);
}
private static void logSevere(String message, Object... args) {
logger.log(Level.SEVERE, message, args);
}
private static void logException(Throwable ex) {
logger.log(Level.SEVERE, null, ex);
}
// </editor-fold>
// public final UpMain upmain;
//
// public LocalRepoCommands( UpMain upmain ){
// if( upmain==null )throw new IllegalArgumentException( "upmain==null" );
// this.upmain = upmain;
// }
// public void println(){
// upmain.getOutput().println();
// }
//
// public void println(Object obj){
// upmain.getOutput().println(obj);
// }
//
// public BasicTemplate.EasyTemplate template(String template){
// return upmain.getOutput().template(template);
// }
@Fun
@Name(name = "localRepo")
@Help(shortDesc = "create local repo")
public LocalUplaunchRepo localRepo(
@Name(name = "path") @Help(shortDesc = "location of repo") String path) {
if (path == null) return null;
File froot = FileSystems.get(path);
File dir = froot;
if (dir != null && !dir.isExists()) {
dir.mkdirs();
}
LocalUplaunchRepo luprepo = new LocalUplaunchRepo();
luprepo.setRoot(froot);
return luprepo;
}
public static final Map<RepoConfig, LocalUplaunchRepo> configRepoMap =
new WeakHashMap<RepoConfig, LocalUplaunchRepo>();
// TODO doc it
@Fun(operator = true)
@Name(name = "config")
public RepoConfig getConfig(LocalUplaunchRepo repo) {
if (repo == null) throw new IllegalArgumentException("repo==null");
RepoConfig rc = repo.getConfig();
if (rc != null) {
configRepoMap.put(rc, repo);
}
return rc;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "print")
public void print(RepoConfig config) {
if (config == null) throw new IllegalArgumentException("config==null");
String title = "";
LocalUplaunchRepo urepo = configRepoMap.get(config);
if (urepo != null) {
String repoName = RepositoriesCommands.repoNameMap.get(urepo);
if (repoName != null) {
title = template("repo ${repoName} config\n").bind("repoName", repoName).eval();
} else {
title = "repo config\n";
}
}
println(title);
try {
BeanInfo bi = Introspector.getBeanInfo(config.getClass());
for (PropertyDescriptor pd : bi.getPropertyDescriptors()) {
if (pd.getPropertyType() == null) continue;
Method m = pd.getReadMethod();
if (m == null) continue;
try {
Object val = m.invoke(config);
template("${property:40} = ${value}")
.bind("property", pd.getName())
.bind("value", val)
.println();
} catch (IllegalAccessException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalArgumentException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
} catch (InvocationTargetException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
}
}
} catch (IntrospectionException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
}
// template(
// "${title}"
// + "checkDepsOnInstall = ${conf.checkDepsOnInstall}\n"
// + "checkDepsOnUnInstall = ${conf.checkDepsOnUnInstall}\n"
// + "useFileLock = ${conf.useFileLock}\n"
// + "updateIndex = ${conf.updateIndex}\n"
// + "checkExistsComponentDir = ${conf.checkExistsComponentDir}\n"
// + "emptyDirAsComponent = ${conf.emptyDirAsComponent}\n"
// + "deleteEmptyDirsOnUnInstall = ${conf.deleteEmptyDirsOnUnInstall}\n"
// + "checkConfigChanges = ${conf.checkConfigChanges}\n"
// + "refreshConfigOnChangeRoot = ${conf.refreshConfigOnChangeRoot}\n"
// )
// .align()
// .bind("conf", config)
// .bind("title", title)
// .println();
}
public static class ConfigSet {
public RepoConfig config;
public String property;
public ConfigSet(RepoConfig config, String property) {
this.config = config;
this.property = property;
}
}
@Fun(operator = true)
@Name(name = "set")
public ConfigSet configSet_set(RepoConfig config, String property) {
if (config == null) throw new IllegalArgumentException("config==null");
if (property == null) throw new IllegalArgumentException("property==null");
return new ConfigSet(config, property);
}
@Fun(operator = true)
@Name(name = "=")
public LocalUplaunchRepo configSet_apply(ConfigSet confSet, String value) {
if (confSet == null) throw new IllegalArgumentException("confSet==null");
if (value == null) throw new IllegalArgumentException("value==null");
RepoConfig conf = confSet.config;
String prop = confSet.property;
TypeCastGraph tcast = new ExtendedCastGraph();
try {
BeanInfo bi = Introspector.getBeanInfo(conf.getClass());
for (PropertyDescriptor pd : bi.getPropertyDescriptors()) {
if (pd.getPropertyType() == null) continue;
if (!pd.getName().equals(prop)) continue;
Method m = pd.getWriteMethod();
if (m == null) continue;
Class t = pd.getPropertyType();
Object val = tcast.cast(value, t);
m.invoke(conf, val);
}
} catch (IntrospectionException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalArgumentException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
} catch (InvocationTargetException ex) {
Logger.getLogger(LocalRepoCommands.class.getName()).log(Level.SEVERE, null, ex);
}
return configRepoMap.get(conf);
}
// TODO doc it
@Fun(operator = true)
@Name(name = "refreshConfigOnChangeRoot")
public LocalUplaunchRepo configSet_refreshConfigOnChangeRoot(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setRefreshConfigOnChangeRoot(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "checkConfigChanges")
public LocalUplaunchRepo configSet_checkConfigChanges(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setCheckConfigChanges(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "deleteEmptyDirsOnUnInstall")
public LocalUplaunchRepo configSet_deleteEmptyDirsOnUnInstall(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setDeleteEmptyDirsOnUnInstall(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "emptyDirAsComponent")
public LocalUplaunchRepo configSet_emptyDirAsComponent(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setEmptyDirAsComponent(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "checkExistsComponentDir")
public LocalUplaunchRepo configSet_checkExistsComponentDir(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setCheckExistsComponentDir(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "checkDepsOnInstall")
public LocalUplaunchRepo configSetCDepsOnInst(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setCheckDepsOnInstall(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "checkDepsOnUnInstall")
public LocalUplaunchRepo configSetCDepsOnUnInst(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setCheckDepsOnUnInstall(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "deps")
public LocalUplaunchRepo configSetCDeps(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setCheckDepsOnUnInstall(val);
config.setCheckDepsOnInstall(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "updateIndex")
public LocalUplaunchRepo configSet_updateIndex(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setUpdateIndex(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "useFileLock")
public LocalUplaunchRepo configSet_useFileLock(RepoConfig config, boolean val) {
if (config == null) throw new IllegalArgumentException("config==null");
config.setUseFileLock(val);
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
// TODO doc it
@Fun(operator = true)
@Name(name = "commit")
public LocalUplaunchRepo configCommit(RepoConfig config) {
if (config == null) throw new IllegalArgumentException("config==null");
config.commit();
LocalUplaunchRepo repo = configRepoMap.get(config);
return repo;
}
}
