/** Initialize the server */ public static void init() { if (initialized) return; org.apache.commons.logging.LogFactory.getLog(HSQLDBServer.class).info("Creating data base ..."); server = new Server(); server.setDatabaseName(0, "Larbc"); server.setDatabasePath(0, "mem:Residence;sql.enforce_strict_size=true"); server.setLogWriter(null); server.setErrWriter(null); server.setSilent(true); server.start(); initialized = true; try { Class.forName("org.hsqldb.jdbcDriver"); PrintStream out = new PrintStream(new ByteArrayOutputStream()); Connection conn = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/Larbc", "sa", ""); SqlFile file = new SqlFile( new File( FileIO.findFile( "com/googlecode/projeto/larbc/rbccycle/databaseconfig/LaRBCDatabase.sql") .getFile()), false, new HashMap()); file.execute(conn, out, out, true); org.apache.commons.logging.LogFactory.getLog(HSQLDBServer.class) .info("Data base generation finished"); } catch (Exception e) { org.apache.commons.logging.LogFactory.getLog(HSQLDBServer.class).error(e); } }
@Override public void initialize() { final String notificationId = ParametricStudyUtils.createDataIdentifier(study); Long missedNumber; try { missedNumber = notificationService .subscribe(notificationId, notificationSubscriber, platform) .get(notificationId); } catch (RemoteOperationException e) { LogFactory.getLog(getClass()) .error("Failed to subscribe for Parametric Study data source: " + e.getMessage()); return; // preserve the "old" RTE behavior for now } // process missed notifications if (missedNumber > MINUS_ONE) { if (missedNumber > StudyPublisher.BUFFER_SIZE - 1) { missedNumber = new Long(StudyPublisher.BUFFER_SIZE - 1); } try { final List<Notification> missedNotifications = notificationService .getNotifications(notificationId, platform) .get(notificationId) .subList(0, missedNumber.intValue() + 1); notificationSubscriber.receiveBatchedNotifications(missedNotifications); } catch (RemoteOperationException e) { LogFactory.getLog(getClass()).warn("Failed to send notifications: " + e.toString()); } } }
public static String getValueAsString(Object bean, String property) { Object value = null; try { value = PropertyUtils.getProperty(bean, property); } catch (IllegalAccessException e) { Log log = LogFactory.getLog(CustomValidatorRules.class); log.error(e.getMessage(), e); } catch (InvocationTargetException e) { Log log = LogFactory.getLog(CustomValidatorRules.class); log.error(e.getMessage(), e); } catch (NoSuchMethodException e) { Log log = LogFactory.getLog(CustomValidatorRules.class); log.error(e.getMessage(), e); } if (value == null) { return null; } if (value instanceof String[]) { return ((String[]) value).length > 0 ? value.toString() : ""; } else if (value instanceof Collection) { return ((Collection) value).isEmpty() ? "" : value.toString(); } else { return value.toString(); } }
{ ((Log4JLogger) LogFactory.getLog("org.apache.hadoop.hdfs.StateChange")) .getLogger() .setLevel(Level.ERROR); ((Log4JLogger) DataNode.LOG).getLogger().setLevel(Level.ERROR); ((Log4JLogger) LogFactory.getLog(FSNamesystem.class)).getLogger().setLevel(Level.ERROR); ((Log4JLogger) DistCpV1.LOG).getLogger().setLevel(Level.ALL); }
/** * Return a proper URL with lowercase scheme, lowercase domain, stripped hash - used to compare * against other previously seen URLs * * @param href A relative or absolute URL * @param context Null or an absolute URL to use when href is relative * @return */ public static URL getCanonicalURL(String href, String context) { try { URI normalized; if (context != null) { normalized = new URI(context); if (normalized.getPath().equals("")) context += "/"; normalized = new URI(context).resolve(href); } else { normalized = new URI(href); } normalized = normalized.normalize(); return new URI( normalized.getScheme().toLowerCase(), normalized.getUserInfo(), normalized.getHost(), normalized.getPort(), normalized.getPath().equals("") ? "/" : normalized.getPath(), normalized.getQuery(), null) .toURL(); } catch (URISyntaxException e) { LogFactory.getLog(URLCanonicalizer.class) .error("Unable to canonicalize href: " + href + ", context" + context, e); return null; } catch (MalformedURLException e) { LogFactory.getLog(URLCanonicalizer.class) .error("Unable to canonicalize href: " + href + ", context" + context, e); return null; } catch (IllegalArgumentException e) { LogFactory.getLog(URLCanonicalizer.class) .error("Unable to canonicalize href: " + href + ", context" + context, e); return null; } /*if (href.contains("#")) { href = href.substring(0, href.indexOf("#")); } href = href.replace(" ", "%20"); try { URL canonicalURL; if (context == null) { canonicalURL = new URL(href); } else { canonicalURL = new URL(new URL(context), href); } String path = canonicalURL.getPath(); if (path.startsWith("/../")) { path = path.substring(3); canonicalURL = new URL(canonicalURL.getProtocol(), canonicalURL.getHost(), canonicalURL.getPort(), path); } else if (path.contains("..")) { System.out.println("Found path with ..: " + path + " " + href + " " + context); } return canonicalURL; } catch (MalformedURLException ex) { return null; }*/ }
static { String defaultMetrics = System.getProperty(DEFAULT_METRICS_SYSTEM_PROPERTY); defaultMetricsEnabled = defaultMetrics != null; if (defaultMetricsEnabled) { String[] values = defaultMetrics.split(","); boolean excludeMachineMetrics = false; for (String s : values) { String part = s.trim(); if (!excludeMachineMetrics && EXCLUDE_MACHINE_METRICS.equals(part)) { excludeMachineMetrics = true; } else { String[] pair = part.split("="); if (pair.length == 2) { String key = pair[0].trim(); String value = pair[1].trim(); try { if (AWS_CREDENTAIL_PROPERTIES_FILE.equals(key)) { final PropertiesCredentials cred; cred = new PropertiesCredentials(new File(value)); credentialProvider = new AWSCredentialsProvider() { @Override public void refresh() {} @Override public AWSCredentials getCredentials() { return cred; } }; } else if (CLOUDWATCH_REGION.equals(key)) { region = Regions.fromName(value); } else if (METRIC_QUEUE_SIZE.equals(key)) { Integer i = new Integer(value); if (i.intValue() < 1) throw new IllegalArgumentException(METRIC_QUEUE_SIZE + " must be at least 1"); metricQueueSize = i; } else if (QUEUE_POLL_TIMEOUT_MILLI.equals(key)) { Long i = new Long(value); if (i.intValue() < 1000) throw new IllegalArgumentException( QUEUE_POLL_TIMEOUT_MILLI + " must be at least 1000"); queuePollTimeoutMilli = i; } else { LogFactory.getLog(AwsSdkMetrics.class) .debug("Ignoring unrecognized parameter: " + part); } } catch (Exception e) { LogFactory.getLog(AwsSdkMetrics.class).debug("Ignoring failure", e); } } } } machineMetricsExcluded = excludeMachineMetrics; } }
// Test pristine LogFactory instance public void testPristineFactory() { assertNotNull("LogFactory exists", factory); assertEquals( "LogFactory class", "org.apache.commons.logging.impl.LogFactoryImpl", factory.getClass().getName()); String names[] = factory.getAttributeNames(); assertNotNull("Names exists", names); assertEquals("Names empty", 0, names.length); }
public class RedisTaskProcessor implements TaskProcessor { private static final Log log = LogFactory.getLog(RedisTaskProcessor.class); private static final Log failCountLog = LogFactory.getLog("failLog"); private RedisService redisService; public RedisService getRedisService() { return redisService; } public void setRedisService(RedisService redisService) { this.redisService = redisService; } public boolean process(String taskType, Task task) { RedisTask redisTask = (RedisTask) task; String ip = redisTask.getIp(); String content = redisTask.getContent(); int failCount = redisTask.getFailCount(); if (this.addIpToContentPair(ip, content)) { log.info("增加ip与dataId映射到redis成功, ip=" + ip + "dataIds=" + content); redisTask.setFailCount(0); return true; } else { log.warn("增加ip与dataId映射到redis失败, ip=" + ip + "dataIds=" + content); failCount++; redisTask.setFailCount(failCount); if (failCount >= DiamondServerConstants.MAX_REDIS_FAIL_COUNT) { failCountLog.info("redis任务失败次数达到上限: ip=" + ip + ", dataIds=" + content); redisTask.setFailCount(0); return true; } return false; } } private boolean addIpToContentPair(String ip, String content) { try { String[] values = content.split(","); this.redisService.addAll("basestone-" + ip, values); return true; } catch (Exception e) { log.error("增加ip与发布dataId的映射到redis出错, ip为" + ip + ", dataId为" + content); return false; } } }
public class ByteArrayMap extends HashMap<Integer, Class<AbstractHandler>> { private static final Log LOG = LogFactory.getLog(ByteArrayMap.class); private static final long serialVersionUID = 6578961679914231615L; @Override public Class<AbstractHandler> get(Object key) { return super.get(DataFactory.getInt((byte[]) key)); } @Override public Class<AbstractHandler> put(Integer key, Class<AbstractHandler> value) { return super.put(key, value); } public Class<AbstractHandler> put(byte[] key, Class<AbstractHandler> value) { key = Arrays.copyOf(key, 4); return put(DataFactory.getInt(key), value); } public Class<AbstractHandler> put(String cls) { try { @SuppressWarnings("unchecked") Class<AbstractHandler> forName = (Class<AbstractHandler>) Class.forName(cls); byte[] command = forName.newInstance().getCommand(); if (command == null) { throw new RuntimeException("no command return!! " + cls); } return put(command, forName); } catch (Exception e) { LOG.error(e, e); } return null; } }
@Controller public class InventoryController { protected final Log logger = LogFactory.getLog(getClass()); // añadimos el autowired para que Spring pueda inyectar automáticamente // una referencia de la clase ProductManager @Autowired private ProductManager productManager; @RequestMapping(value = "/hello.htm") public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String now = (new Date()).toString(); logger.info("Returning hello view with " + now); // Le el modelo va a ser un Map clave/valor Map<String, Object> myModel = new HashMap<String, Object>(); myModel.put("now", now); myModel.put("products", this.productManager.getProducts()); return new ModelAndView("hello", "model", myModel); } public void setProductManager(ProductManager productManager) { this.productManager = productManager; } }
/** * <a href="UpgradeTags.java.html"><b><i>View Source</i></b></a> * * @author Brian Wing Shun Chan */ public class UpgradeTags extends UpgradeProcess { public void upgrade() throws UpgradeException { _log.info("Upgrading"); try { doUpgrade(); } catch (Exception e) { throw new UpgradeException(e); } } protected void doUpgrade() throws Exception { // TagsAsset UpgradeTable upgradeTable = new DefaultUpgradeTableImpl(TagsAssetImpl.TABLE_NAME, TagsAssetImpl.TABLE_COLUMNS); upgradeTable.setCreateSQL(TagsAssetImpl.TABLE_SQL_CREATE); upgradeTable.updateTable(); } private static Log _log = LogFactory.getLog(UpgradeTags.class); }
public class MasterDaoHibernate extends HibernateDaoSupport implements MasterDao { protected Log log = LogFactory.getLog(getClass()); public void deleteMaster(Master master) { getHibernateTemplate().delete(master); } public Master getMasterById(Long id) { return (Master) getHibernateTemplate().get(Master.class, id); } public void saveMaster(Master master) { getHibernateTemplate().saveOrUpdate(master); } public void updateMaster(Master master) { getHibernateTemplate().merge(master); } public void saveMasterImage(MasterWallpaper masterImage) { getHibernateTemplate().saveOrUpdate(masterImage); } public List<MasterWatermark> getWatermarks() { return getHibernateTemplate().find("from MasterWatermark where is_deleted = false"); } public String toString() { return "MasterDaoHibernate"; } }
/** * Initialize all services define in the {@link #CONF_SERVICE_CLASSES} configuration property. * * @throws ServiceException thrown if any of the services could not initialize. */ @SuppressWarnings("unchecked") public void init() throws ServiceException { XLog log = new XLog(LogFactory.getLog(getClass())); log.trace("Initializing"); SERVICES = this; try { Class<? extends Service>[] serviceClasses = (Class<? extends Service>[]) conf.getClasses(CONF_SERVICE_CLASSES); if (serviceClasses != null) { for (Class<? extends Service> serviceClass : serviceClasses) { setService(serviceClass); } } } catch (RuntimeException ex) { XLog.getLog(getClass()).fatal(ex.getMessage(), ex); throw ex; } catch (ServiceException ex) { SERVICES = null; throw ex; } InstrumentationService instrService = get(InstrumentationService.class); if (instrService != null) { for (Service service : services.values()) { if (service instanceof Instrumentable) { ((Instrumentable) service).instrument(instrService.get()); } } } log.info("Initialized"); log.info("Oozie System ID [{0}] started!", getSystemId()); }
/** * @author tmo * @version $Id$ * @todo description */ public class QueryEvaluate implements EventExecution { /** Logger for this class */ private static final Log LOG = LogFactory.getLog(QueryEvaluate.class); /** @param _parameter */ public Return execute(final Parameter _parameter) throws EFapsException { Return ret = new Return(); Map properties = (Map) _parameter.get(ParameterValues.PROPERTIES); String types = (String) properties.get("Types"); boolean expandChildTypes = "true".equals((String) properties.get("ExpandChildTypes")); if (LOG.isDebugEnabled()) { LOG.debug("types=" + types); } SearchQuery query = new SearchQuery(); query.setQueryTypes(types); query.setExpandChildTypes(expandChildTypes); query.addSelect("OID"); query.execute(); List<List<Instance>> list = new ArrayList<List<Instance>>(); while (query.next()) { List<Instance> instances = new ArrayList<Instance>(1); instances.add(new Instance((String) query.get("OID"))); list.add(instances); } ret.put(ReturnValues.VALUES, list); return ret; } }
/** Exports AwsSdkMetrics for JMX access. */ static { try { MBeans.registerMBean(MBEAN_OBJECT_NAME, new AwsSdkMetrics.Admin()); } catch (Exception ex) { LogFactory.getLog(AwsSdkMetrics.class).warn("", ex); } }
/** * Cleans up committed transactions when they are no longer needed to verify pending transactions. */ public class CleanOldTransactionsChore extends Chore { private final TrxRegionEndpoint trx_Region; static final Log LOG = LogFactory.getLog(CleanOldTransactionsChore.class); /** * @param trx_Region * @param timer * @param stoppable */ public CleanOldTransactionsChore( final TrxRegionEndpoint trx_Region, final int timer, final Stoppable stoppable) { super("CleanOldTransactionsChore", timer, stoppable); this.trx_Region = trx_Region; } @Override public void chore() { trx_Region.removeUnNeededCommitedTransactions(); // if (LOG.isDebugEnabled()) LOG.debug("Trafodion ChoreThread CP Epoch " + // trx_Region.controlPointEpoch.get()); trx_Region.choreThreadDetectStaleTransactionBranch(); // LOG.trace("CleanOldTransactionsChore: region " + this.trx_Region.getRegionNameAsString()); trx_Region.removeUnNeededStaleScanners(); } }
public class HolidayManagerImpl implements HolidayManager { private static Log log = LogFactory.getLog(HolidayManagerImpl.class); private HolidayDao dao; public void setHolidayDao(HolidayDao dao) { this.dao = dao; } @Override public List<Holiday> getHolidays(Date begin, Date end) { return dao.getHolidays(begin, end); } @Override public Holiday get(Integer id) { return dao.getHoliday(id); } @Override public void remove(Integer id) { dao.remove(dao.getHoliday(id)); } @Override public void save(Holiday h) { dao.save(h); } @Override public void applyHolidays() { dao.applyHolidays(); } }
public class Sample0 extends SynapseTestCase { private static final Log log = LogFactory.getLog(Sample0.class); private StockQuoteSampleClient client; public Sample0() { super(0); client = getStockQuoteClient(); } public void testSmartClientMode() { String addUrl = "http://localhost:9000/services/SimpleStockQuoteService"; String trpUrl = "http://localhost:8280/"; log.info("Running test: Smart Client mode"); SampleClientResult result = client.requestStandardQuote(addUrl, trpUrl, null, "IBM", null); assertResponseReceived(result); } public void testSynapseAsHTTPProxy() { String addUrl = "http://localhost:9000/services/SimpleStockQuoteService"; String prxUrl = "http://localhost:8280/"; log.info("Running test: Using Synapse as a HTTP Proxy"); SampleClientResult result = client.requestStandardQuote(addUrl, null, prxUrl, "IBM", null); assertResponseReceived(result); } }
@Component("blCartStateFilter") /** * This filter should be configured after the BroadleafCommerce CustomerStateFilter listener from * Spring Security. Retrieves the cart for the current BroadleafCommerce Customer based using the * authenticated user OR creates an empty non-modifiable cart and stores it in the request. * * @author bpolster */ public class CartStateFilter extends GenericFilterBean implements Ordered { /** Logger for this class and subclasses */ protected final Log LOG = LogFactory.getLog(getClass()); @Resource(name = "blCartStateRequestProcessor") protected CartStateRequestProcessor cartStateProcessor; @Override @SuppressWarnings("unchecked") public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { cartStateProcessor.process( new ServletWebRequest((HttpServletRequest) request, (HttpServletResponse) response)); chain.doFilter(request, response); } @Override public int getOrder() { // FilterChainOrder has been dropped from Spring Security 3 // return FilterChainOrder.REMEMBER_ME_FILTER+1; return 1502; } }
public class ConcurrentAccessReplicator { private static final Log log = LogFactory.getLog(ConcurrentAccessReplicator.class); private ConfigurationContext configContext; public ConcurrentAccessReplicator(ConfigurationContext configContext) { this.configContext = configContext; } public void replicate(String key, ConcurrentAccessController concurrentAccessController) { try { ClusteringAgent clusteringAgent = configContext.getAxisConfiguration().getClusteringAgent(); if (clusteringAgent != null) { if (log.isDebugEnabled()) { log.debug("Replicating ConcurrentAccessController " + key + " in a ClusterMessage."); } clusteringAgent.sendMessage( new ConcurrentAccessUpdateClusterMessage(key, concurrentAccessController), true); } } catch (ClusteringFault e) { if (log.isErrorEnabled()) { log.error("Could not replicate throttle data", e); } } } }
/** Destroy all services. */ public void destroy() { XLog log = new XLog(LogFactory.getLog(getClass())); log.trace("Shutting down"); boolean deleteRuntimeDir = false; if (conf != null) { deleteRuntimeDir = conf.getBoolean(CONF_DELETE_RUNTIME_DIR, false); } if (services != null) { List<Service> list = new ArrayList<Service>(services.values()); Collections.reverse(list); for (Service service : list) { try { log.trace("Destroying service[{0}]", service.getInterface()); if (service.getInterface() == XLogService.class) { log.info("Shutdown"); } service.destroy(); } catch (Throwable ex) { log.error( "Error destroying service[{0}], {1}", service.getInterface(), ex.getMessage(), ex); } } } if (deleteRuntimeDir) { try { IOUtils.delete(new File(runtimeDir)); } catch (IOException ex) { log.error("Error deleting runtime directory [{0}], {1}", runtimeDir, ex.getMessage(), ex); } } services = null; conf = null; SERVICES = null; }
@Service public class AutoDiscoveryService { private static final Log log = LogFactory.getLog(AutoDiscoveryService.class); private final AutoDiscoveryPublisher publisher; @Inject public AutoDiscoveryService(AutoDiscoveryPublisher publisher) { this.publisher = publisher; } @PostConstruct public void init() { new Thread( new Runnable() { @Override public void run() { log.info("Started publishing picture sucker service for auto discovery"); publisher.start(); } }) .start(); } }
@Component @Scope("request") public class SettleStatusAction extends BaseAction { private final transient Log logger = LogFactory.getLog(SettleStatusAction.class); @Autowired @Qualifier("clearStatusService") private ClearStatusService clearStatusService; public InService getService() { return this.clearStatusService; } public int getSettleStatus() { int status = 0; int count = 0; List<ClearStatus> list = this.clearStatusService.getList(null, null); for (ClearStatus clearStatus : list) { if ("Y".equals(clearStatus.getStatus())) { count++; } } if (count == list.size()) { status = 1; } else if ((count != 0) && (count < list.size())) { status = 2; } return status; } }
/** Main Spring boot configuration file. Starts up a Spring boot application. */ @Configuration @EnableAutoConfiguration @EnableTransactionManagement @Import({RepositoryRestMvcConfiguration.class}) @ComponentScan @EnableSwagger public class Application { private static final Log log = LogFactory.getLog(Application.class); public static void main(String[] args) { TimeZone.setDefault(TimeZone.getTimeZone("UTC")); SpringApplication app = new SpringApplication(Application.class); app.addListeners( new ApplicationListener<ApplicationEnvironmentPreparedEvent>() { @Override public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) { MDC.put("appName", event.getEnvironment().getProperty("project.name")); MDC.put("requestId", "N/A"); try { MDC.put("hostName", InetAddress.getLocalHost().getHostName()); } catch (IllegalArgumentException | UnknownHostException e) { log.info(e); } } }); ApplicationContext ctx = app.run(args); log.info("-----------------------------------------------------------------"); log.info("Active profiles:"); Arrays.asList(ctx.getEnvironment().getActiveProfiles()).forEach(log::info); log.info("-----------------------------------------------------------------"); } }
public class LoginInterceptor extends HandlerInterceptorAdapter { private static final Log logger = LogFactory.getLog(LoginInterceptor.class); private static final String showLogin = "******"; private static final String login = "******"; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { Object usrLogin = request.getSession().getAttribute(Constants.SESS_USER_KEY); String sevPath = request.getServletPath(); logger.info("ServletPath: " + sevPath); String rootPath = ""; if (!StringUtil.isBlankOrNull(sevPath) && !sevPath.equals("/" + showLogin) && !sevPath.equals("/" + login)) { int len = sevPath.split("/").length; for (int i = 2; i < len; i++) { rootPath += "../"; } if (usrLogin == null) { // response.sendRedirect(rootPath+showLogin); StringBuffer toLoginScript = new StringBuffer(); toLoginScript.append("<script type=\"text/javascript\">"); toLoginScript.append("top.window.location=\"" + rootPath + showLogin + "\""); toLoginScript.append("</script>"); logger.info(toLoginScript); PrintWriter writer = response.getWriter(); writer.write(toLoginScript.toString()); writer.flush(); } } return true; } }
public final class LaunchHelpAction extends AbstractDesignerContextAction { private static final Log log = LogFactory.getLog(LaunchHelpAction.class); public LaunchHelpAction() { putValue(Action.NAME, ActionMessages.getString("LaunchHelpAction.Text")); putValue(Action.SHORT_DESCRIPTION, ActionMessages.getString("LaunchHelpAction.Description")); putValue(Action.MNEMONIC_KEY, ActionMessages.getOptionalMnemonic("LaunchHelpAction.Mnemonic")); putValue( Action.ACCELERATOR_KEY, ActionMessages.getOptionalKeyStroke("LaunchHelpAction.Accelerator")); } /** Invoked when an action occurs. */ public void actionPerformed(final ActionEvent e) { final Configuration config = ReportDesignerBoot.getInstance().getGlobalConfig(); final String docUrl = config.getConfigProperty( "org.pentaho.reporting.designer.core.documentation.report_designer_user_guide"); try { ExternalToolLauncher.openURL(docUrl); } catch (IOException ex) { log.warn("Could not load " + docUrl, ex); // NON-NLS } } }
public class PropsComponent implements Callable { private static final Log logger = LogFactory.getLog(PropsComponent.class); protected static Apple testObjectProperty = new Apple(); public Object onCall(UMOEventContext context) throws Exception { logger.debug("org.mule.test.usecases.props.PropsComponent"); if ("component1".equals(context.getComponent().getName())) { logger.debug("Adding: " + context.getComponent().getName()); Map props = new HashMap(); props.put("stringParam", "param1"); props.put("objectParam", testObjectProperty); UMOMessage msg = new MuleMessage(context.getMessageAsString(), props); logger.debug("Adding done: " + context.getComponent().getName()); return msg; } else { logger.debug("Verifying: " + context.getComponent().getName()); assertEquals("param1", context.getMessage().getProperty("stringParam")); assertEquals(testObjectProperty, context.getMessage().getProperty("objectParam")); logger.debug("Verifying done: " + context.getComponent().getName()); } return context; } protected static void assertEquals(Object theObject, Object theProperty) { if (!theObject.equals(theProperty)) { logger.error(String.valueOf(theObject) + " does not equal:" + String.valueOf(theProperty)); } else { logger.debug("Woohoo!"); } } }
/** * The <invoke> tag will invoke a given Script instance. It can be used with the * <script> tag which defines scripts as variables that can later be invoked by this * <invoke> tag. * * @author <a href="mailto:[email protected]">James Strachan</a> * @version $Revision: 155420 $ */ public class InvokeTag extends TagSupport { /** The Log to which logging calls will be made. */ private static final Log log = LogFactory.getLog(InvokeTag.class); private Script script; public InvokeTag() {} /** * Sets the Script to be invoked by this tag, which typically has been previously defined by the * use of the <script> tag. */ public void setScript(Script script) { this.script = script; } // Tag interface // ------------------------------------------------------------------------- public void doTag(XMLOutput output) throws MissingAttributeException, JellyTagException { if (script == null) { throw new MissingAttributeException("script"); } script.run(context, output); } }
public class SyncThreadPoolScriptRunnerService extends ThreadPoolScriptRunnerService { private static final Log log = LogFactory.getLog(ThreadPoolScriptRunnerService.class); @Override protected void runInternal(final ScriptRunner scriptRunner, final Binding binding) { createExecutorService(); final Object monitor = new Object(); executorService.execute( new Runnable() { @Override public void run() { try { scriptRunner.callback(webDriverService.getWebDriver(), binding); } catch (Exception e) { log.error(e.getMessage(), e); binding.put(EXCEPTION_KEY, e); } finally { synchronized (monitor) { monitor.notify(); } } } }); synchronized (monitor) { try { monitor.wait(); } catch (InterruptedException e) { /* ignore */ } } } }
/** * This class contains the logic that is run every time this module is either started or stopped. */ public class admintoolsuiActivator implements ModuleActivator { protected Log log = LogFactory.getLog(getClass()); /** @see ModuleActivator#willRefreshContext() */ public void willRefreshContext() { log.info("Refreshing admintoolsui Module"); } /** @see ModuleActivator#contextRefreshed() */ public void contextRefreshed() { log.info("admintoolsui Module refreshed"); } /** @see ModuleActivator#willStart() */ public void willStart() { log.info("Starting admintoolsui Module"); } /** @see ModuleActivator#started() */ public void started() { log.info("admintoolsui Module started"); } /** @see ModuleActivator#willStop() */ public void willStop() { log.info("Stopping admintoolsui Module"); } /** @see ModuleActivator#stopped() */ public void stopped() { log.info("admintoolsui Module stopped"); } }