/** Implementation of Runnable interface. DO NOT access this method directly. */
public void run() {
GUIUtils.setAnimatedFrameIgnoreRepaint(
true); // animated frames are updated by this thread so no need to repaint
long sleepTime = delayTime;
while (animationThread == Thread.currentThread()) {
long currentTime = System.currentTimeMillis();
for (int i = 0; i < stepsPerDisplay; i++) {
doStep();
stepCounter++;
if (animationThread != Thread.currentThread()) {
break; // check for stop condition
} else {
Thread.yield(); // give other threads a chance to run if needed
}
}
org.opensourcephysics.display.GUIUtils.renderAnimatedFrames();
// adjust the sleep time to try and achieve a constant animation rate
// some VMs will hang if sleep time is less than 10
sleepTime = Math.max(10, delayTime - (System.currentTimeMillis() - currentTime));
try {
Thread.sleep(sleepTime);
} catch (InterruptedException ie) {
}
}
GUIUtils.setAnimatedFrameIgnoreRepaint(
false); // animated frames are updated by this thread so no need to repaint
}
public GameContext getContext() {
if (allContexts == null) {
return mainContext;
}
synchronized (this) {
if (allContexts == null) {
return mainContext;
}
ThreadGroup currentThreadGroup = Thread.currentThread().getThreadGroup();
for (int i = 0; i < allContexts.size(); i++) {
GameContext context = (GameContext) allContexts.get(i);
ThreadGroup contextThreadGroup = context.getThreadGroup();
if (contextThreadGroup == currentThreadGroup
|| contextThreadGroup.parentOf(currentThreadGroup)) {
return context;
}
}
if (initContext != null && Thread.currentThread() == initContextThread) {
return initContext;
}
return (GameContext) (allContexts.get(GameContext.nextContextID - 1));
}
}
@Override
public void run() {
/* Legacy UDP location manager daemon.
*/
DatagramPacket packet;
while (!Thread.currentThread().isInterrupted()) {
try {
packet = new DatagramPacket(new byte[1024], 1024);
socket.receive(packet);
} catch (SocketException e) {
if (!Thread.currentThread().isInterrupted()) {
LOGGER.warn("Exception in Server receive loop (exiting)", e);
}
break;
} catch (Exception ie) {
LOGGER.warn("Exception in Server receive loop (exiting)", ie);
break;
}
try {
process(packet);
socket.send(packet);
} catch (Exception se) {
LOGGER.warn("Exception in send ", se);
}
}
socket.close();
}
/**
* Load the application context using a single classloader
*
* @param ac The spring application context
* @param config a list of configurations represented as List of resources
* @param loader the classloader to use
*/
public void loadComponent(
ConfigurableApplicationContext ac, List<Resource> config, ClassLoader loader) {
ClassLoader current = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(loader);
try {
// make a reader
XmlBeanDefinitionReader reader =
new XmlBeanDefinitionReader((BeanDefinitionRegistry) ac.getBeanFactory());
// In Spring 2, classes aren't loaded during bean parsing unless
// this
// classloader property is set.
reader.setBeanClassLoader(loader);
reader.loadBeanDefinitions(config.toArray(new Resource[0]));
} catch (Throwable t) {
log.warn("loadComponentPackage: exception loading: " + config + " : " + t, t);
} finally {
// restore the context loader
Thread.currentThread().setContextClassLoader(current);
}
}
@SuppressWarnings("unchecked")
private Work openEditor(String editorClassName, WorkDefinition workDefinition) {
IJavaProject javaProject = getProject();
if (javaProject != null) {
try {
ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
ClassLoader newLoader = ProjectClassLoader.getProjectClassLoader(javaProject);
try {
Thread.currentThread().setContextClassLoader(newLoader);
Class<WorkEditor> editorClass = (Class<WorkEditor>) newLoader.loadClass(editorClassName);
Constructor<WorkEditor> constructor = editorClass.getConstructor(Shell.class);
WorkEditor editor = constructor.newInstance(getViewer().getControl().getShell());
editor.setWorkDefinition(workDefinition);
WorkItemNode workItemNode = getWorkItemWrapper().getWorkItemNode();
editor.setWork(workItemNode.getWork());
boolean result = editor.show();
return result ? editor.getWork() : null;
} finally {
Thread.currentThread().setContextClassLoader(oldLoader);
}
} catch (Exception e) {
DroolsEclipsePlugin.log(e);
}
}
return null;
}
/*
* Use PIN or PUK to unlock SIM card
*
* If PUK is null, unlock SIM card with PIN
*
* If PUK is not null, unlock SIM card with PUK and set PIN code
*/
synchronized boolean unlockSim(String puk, String pin) {
while (mHandler == null) {
try {
wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
Message callback = Message.obtain(mHandler, SUPPLY_PIN_COMPLETE);
if (puk == null) {
mSimCard.supplyPin(pin, callback);
} else {
mSimCard.supplyPuk(puk, pin, callback);
}
while (!mDone) {
try {
Log.d(LOG_TAG, "wait for done");
wait();
} catch (InterruptedException e) {
// Restore the interrupted status
Thread.currentThread().interrupt();
}
}
Log.d(LOG_TAG, "done");
return mResult;
}
/**
* Closes all connected clients sockets, then closes the underlying ServerSocketChannel,
* effectively killing the server socket selectorthread, freeing the port the server was bound to
* and stops all internal workerthreads.
*
* <p>If this method is called before the server is started it will never start.
*
* @param timeout Specifies how many milliseconds shall pass between initiating the close
* handshakes with the connected clients and closing the servers socket channel.
* @throws IOException When {@link ServerSocketChannel}.close throws an IOException
* @throws InterruptedException
*/
public void stop(int timeout) throws IOException, InterruptedException {
if (!isclosed.compareAndSet(false, true)) {
return;
}
synchronized (connections) {
for (WebSocket ws : connections) {
ws.close(CloseFrame.GOING_AWAY);
}
}
synchronized (this) {
if (selectorthread != null) {
if (Thread.currentThread() != selectorthread) {}
if (selectorthread != Thread.currentThread()) {
selectorthread.interrupt();
selectorthread.join();
}
}
if (decoders != null) {
for (WebSocketWorker w : decoders) {
w.interrupt();
}
}
if (server != null) {
server.close();
}
}
}
public void send_request(ClientRequestInfo ri) throws ForwardRequest {
try {
org.omg.CORBA.Any any = ri.get_slot(slot_id);
if (any.type().kind().value() == org.omg.CORBA.TCKind._tk_null) {
logger.debug(
"tid="
+ Thread.currentThread().getName()
+ ","
+ "ClientInterceptor.send_request, slot is empty");
} else {
logger.debug(
"tid="
+ Thread.currentThread().getName()
+ ","
+ "ClientInterceptor.send_request, adding ServiceContext");
ServiceContext ctx = new ServiceContext(SERVICE_ID, codec.encode(any));
ri.add_request_service_context(ctx, false);
}
} catch (Exception e) {
throw new INTERNAL("Caught " + e);
}
}
public void receive_request_service_contexts(ServerRequestInfo ri) {
ServiceContext ctx;
try {
ctx = ri.get_request_service_context(SERVICE_ID);
} catch (org.omg.CORBA.BAD_PARAM e) {
logger.debug(
"tid=" + Thread.currentThread().getName() + "," + "**Service context was not specified");
return;
}
if (null == ctx) {
logger.debug("tid=" + Thread.currentThread().getName() + "," + "**Service context is null");
return;
}
try {
Any slotDataAsAny = codec.decode(ctx.context_data);
// Get the slot data as a string
String slotDataAsStr;
if (null == (slotDataAsStr = slotDataAsAny.extract_string())) {
logger.debug("slotDataAsStr=<null>");
} else {
logger.debug("slotDataAsStr=" + slotDataAsStr);
}
slotDataAsStr += ":receive_request_service_contexts";
slotDataAsAny.insert_string(slotDataAsStr);
ri.set_slot(slot_id, slotDataAsAny);
} catch (Exception e) {
throw new INTERNAL("Caught " + e);
}
}
/**
* the usage of getResponseByParams is disencouraged for the embedded Solr connector. Please use
* request(SolrParams) instead. Reason: Solr makes a very complex folding/unfolding including data
* compression for SolrQueryResponses.
*/
@Override
public QueryResponse getResponseByParams(ModifiableSolrParams params) throws IOException {
if (this.server == null) throw new IOException("server disconnected");
// during the solr query we set the thread name to the query string to get more debugging info
// in thread dumps
String threadname = Thread.currentThread().getName();
String ql = "";
try {
ql = URLDecoder.decode(params.toString(), StandardCharsets.UTF_8.name());
} catch (UnsupportedEncodingException e) {
}
Thread.currentThread().setName("solr query: q=" + ql);
ConcurrentLog.info("EmbeddedSolrConnector.getResponseByParams", "QUERY: " + ql);
// System.out.println("EmbeddedSolrConnector.getResponseByParams * QUERY: " + ql);
// System.out.println("STACKTRACE: " + ConcurrentLog.stackTrace());
QueryResponse rsp;
try {
rsp = this.server.query(params);
Thread.currentThread().setName(threadname);
if (rsp != null)
if (log.isFine()) log.fine(rsp.getResults().getNumFound() + " results for " + ql);
return rsp;
} catch (final SolrServerException e) {
throw new IOException(e);
} catch (final Throwable e) {
throw new IOException("Error executing query", e);
}
}
/**
* get the solr document list from a query response This differs from getResponseByParams in such
* a way that it does only create the fields of the response but never search snippets and there
* are also no facets generated.
*
* @param params
* @return
* @throws IOException
* @throws SolrException
*/
@Override
public SolrDocumentList getDocumentListByParams(ModifiableSolrParams params)
throws IOException, SolrException {
SolrQueryRequest req = this.request(params);
SolrQueryResponse response = null;
String q = params.get(CommonParams.Q);
String fq = params.get(CommonParams.FQ);
String sort = params.get(CommonParams.SORT);
String threadname = Thread.currentThread().getName();
try {
if (q != null)
Thread.currentThread()
.setName(
"solr query: q = "
+ q
+ (fq == null ? "" : ", fq = " + fq)
+ (sort == null ? "" : ", sort = " + sort)); // for debugging in Threaddump
response = this.query(req);
if (q != null) Thread.currentThread().setName(threadname);
if (response == null) throw new IOException("response == null");
return SolrQueryResponse2SolrDocumentList(req, response);
} finally {
req.close();
SolrRequestInfo.clearRequestInfo();
}
}
/**
* conversion from a SolrQueryResponse (which is a solr-internal data format) to SolrDocumentList
* (which is a solrj-format) The conversion is done inside the solrj api using the
* BinaryResponseWriter and a very complex unfolding process via
* org.apache.solr.common.util.JavaBinCodec.marshal.
*
* @param request
* @param sqr
* @return
*/
public SolrDocumentList SolrQueryResponse2SolrDocumentList(
final SolrQueryRequest req, final SolrQueryResponse rsp) {
SolrDocumentList sdl = new SolrDocumentList();
NamedList<?> nl = rsp.getValues();
ResultContext resultContext = (ResultContext) nl.get("response");
DocList response =
resultContext == null
? new DocSlice(0, 0, new int[0], new float[0], 0, 0.0f)
: resultContext.docs;
sdl.setNumFound(response == null ? 0 : response.matches());
sdl.setStart(response == null ? 0 : response.offset());
String originalName = Thread.currentThread().getName();
if (response != null) {
try {
SolrIndexSearcher searcher = req.getSearcher();
final int responseCount = response.size();
DocIterator iterator = response.iterator();
for (int i = 0; i < responseCount; i++) {
int docid = iterator.nextDoc();
Thread.currentThread()
.setName("EmbeddedSolrConnector.SolrQueryResponse2SolrDocumentList: " + docid);
Document responsedoc = searcher.doc(docid, (Set<String>) null);
SolrDocument sordoc = doc2SolrDoc(responsedoc);
sdl.add(sordoc);
}
} catch (IOException e) {
ConcurrentLog.logException(e);
}
}
Thread.currentThread().setName(originalName);
return sdl;
}
/*
* (non-Javadoc)
* @see de.tuberlin.dima.minidb.io.ResourceManager#writePageToResource(byte[], de.tuberlin.dima.minidb.io.cache.CacheableData)
*/
@Override
public void writePageToResource(byte[] buffer, CacheableData wrapper) throws IOException {
this.writeRequests.add(wrapper.getPageNumber());
// check if thread is different than the creator
if (Thread.currentThread() == this.creator) {
System.out.println(writingSeparateThread);
throw new IOException(writingSeparateThread);
}
// check if writer thread is already set
if (this.writer == null) {
this.writer = Thread.currentThread();
}
// check if it is always the same writing thread
if (this.writer != Thread.currentThread()) {
System.out.println(writingSameThread);
throw new IOException(writingSameThread);
}
// write contents to specified position
if (wrapper.getPageNumber() < this.pageNumber && wrapper.getPageNumber() >= firstPageNumber) {
// copy contents to "disk"
System.arraycopy(
buffer, 0, this.diskBuffer.get(wrapper.getPageNumber() - 1), 0, buffer.length);
} else {
throw new IOException("This page does not exist.");
}
}
public synchronized void unlockResource(final String id) {
logger.debug("unlockResource: {}", id);
final Entry entry = this.locker.getEntry(id);
if (entry == null) {
return;
}
boolean wakeup = false;
if (entry.readers.remove(Thread.currentThread())) {
wakeup = true;
}
if (entry.writer == Thread.currentThread()) {
entry.writer = null;
wakeup = true;
}
if (checkRemoveEntry(id, entry)) {
wakeup = true;
}
if (wakeup) {
notifyAll();
}
}
public SurefireProvider createProvider(boolean isInsideFork) {
ClassLoader systemClassLoader = java.lang.Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(classLoader);
StartupConfiguration starterConfiguration = startupConfiguration;
// Note: Duplicated in ForkedBooter#createProviderInCurrentClassloader
final Object o =
surefireReflector.createBooterConfiguration(
classLoader, reporterManagerFactory, isInsideFork);
surefireReflector.setTestSuiteDefinitionAware(
o, providerConfiguration.getTestSuiteDefinition());
surefireReflector.setProviderPropertiesAware(o, providerConfiguration.getProviderProperties());
surefireReflector.setReporterConfigurationAware(
o, providerConfiguration.getReporterConfiguration());
surefireReflector.setTestClassLoaderAware(o, classLoader);
surefireReflector.setTestArtifactInfoAware(o, providerConfiguration.getTestArtifact());
surefireReflector.setRunOrderParameters(o, providerConfiguration.getRunOrderParameters());
surefireReflector.setIfDirScannerAware(o, providerConfiguration.getDirScannerParams());
Object provider =
surefireReflector.instantiateProvider(starterConfiguration.getActualClassName(), o);
Thread.currentThread().setContextClassLoader(systemClassLoader);
return new ProviderProxy(provider, classLoader);
}
private void serviceAdded(HttpService service) {
try {
DispatcherServlet dispatcherServlet = new DispatcherServlet();
dispatcherServlet.setContextConfigLocation(CONTEXT_CONFIG_LOCATION);
dispatcherServlet.setContextClass(OpenMrsApplicationContext.class);
ClassLoader old = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
service.registerServlet(SERVLET_URL_MAPPING, dispatcherServlet, null, null);
logger.debug("Servlet registered");
} finally {
Thread.currentThread().setContextClassLoader(old);
}
// register all annotated handlers
EventAnnotationBeanPostProcessor.registerHandlers(
BeanFactoryUtils.beansOfTypeIncludingAncestors(
dispatcherServlet.getWebApplicationContext(), Object.class));
// create tree objects in the database
bootStrap();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static void say() {
System.out.println("blah");
System.out.println(
Thread.currentThread().getName()
+ ":"
+ Arrays.asList(Thread.currentThread().getStackTrace()));
}
public static void main(String[] args)
throws InterruptedException, ExecutionException, TimeoutException {
ExecutorService executor = Executors.newFixedThreadPool(5);
CompletableFuture<String> task1 =
CompletableFuture.supplyAsync(
() -> {
try {
System.out.println(Thread.currentThread().getName() + ": firstTask");
TimeUnit.SECONDS.sleep(2);
} catch (Exception e) {
}
return "1";
});
CompletableFuture<String> task2 =
CompletableFuture.supplyAsync(
() -> {
try {
System.out.println(Thread.currentThread().getName() + ": secondTask");
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
}
return "2";
});
// a new thread from the supplied executor will execute third task
task1.acceptEitherAsync(
task2,
(x) -> {
System.out.println(Thread.currentThread().getName() + ": thirdTask " + x);
},
executor);
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName() + ": " + task1.get());
executor.shutdown();
}
@Override
public void run() {
while (true) {
synchronized (shareData) {
while (shareData.isEmpty()) {
try {
System.out.println(Thread.currentThread().getName() + " 数据为空，等待生产...");
shareData.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Integer obj = shareData.get(0);
shareData.remove(obj);
System.out.println(
Thread.currentThread().getName() + " 消费数据:" + obj + ", 剩余:" + shareData.size());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
shareData.notifyAll();
}
}
}
protected void initInputClassLoader() {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (buildOnlyOutdatedFiles && getBinaryOutputDirectory() != null) {
CompilerClassLoader ccl = getCompilerClassLoader(cl);
if (ccl == null) {
try {
Launcher.LOGGER.debug(
"setting classloader for " + getBinaryOutputDirectory().toURI().toURL());
Thread.currentThread()
.setContextClassLoader(
new CompilerClassLoader(
new URL[] {getBinaryOutputDirectory().toURI().toURL()},
factory.getEnvironment().getInputClassLoader()));
} catch (Exception e) {
Launcher.LOGGER.error(e.getMessage(), e);
}
}
} else {
if (!hasClassLoader(
Thread.currentThread().getContextClassLoader(),
factory.getEnvironment().getInputClassLoader())) {
Thread.currentThread()
.setContextClassLoader(factory.getEnvironment().getInputClassLoader());
}
}
}
private void checkThread() {
// All ops must always be invoked on same thread
if (Thread.currentThread() != th) {
throw new IllegalStateException(
"Invoked with wrong thread, actual: " + Thread.currentThread() + " expected: " + th);
}
}
/* (non-Javadoc)
* @see org.jboss.remoting.ServerInvocationHandler#invoke(org.jboss.remoting.InvocationRequest)
*/
public Object invoke(InvocationRequest invocation) throws Throwable {
Serializable key = (Serializable) invocation.getRequestPayload().get(OID);
Remotable remotable = remotables.get(key);
if (remotable == null)
throw new IllegalArgumentException("Can't find remotable " + key + " in " + remotables);
Object parameters[] = (Object[]) invocation.getParameter();
SerializableMethod method = (SerializableMethod) parameters[0];
Object args[] = (Object[]) parameters[1];
ClassLoader loader = remotable.getClassLoader();
Method realMethod = method.toMethod(loader);
ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(loader);
return realMethod.invoke(remotable.getTarget(), args);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"unable to invoke "
+ realMethod
+ " on "
+ remotable.getTarget()
+ " with "
+ Arrays.toString(args),
e);
} catch (InvocationTargetException e) {
throw e.getCause();
} finally {
Thread.currentThread().setContextClassLoader(oldLoader);
}
}
@Override
public String format(
String projectName,
String path,
String revision,
String abbrRev,
ConfigSection cfg,
InputStream raw)
throws IOException {
// Docx4J tries to load some resources dynamically. This fails if the Gerrit
// core classloader is used since it doesn't see the resources that are
// contained in the plugin jar. To make the resource loading work we
// must set a context classloader on the current thread.
ClassLoader loader = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
WordprocessingMLPackage p = Docx4J.load(raw);
HTMLSettings htmlSettings = Docx4J.createHTMLSettings();
htmlSettings.setWmlPackage(p);
Docx4jProperties.setProperty("docx4j.Convert.Out.HTML.OutputMethodXML", true);
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
Docx4J.toHTML(htmlSettings, out, Docx4J.FLAG_EXPORT_PREFER_XSL);
String html = out.toString(UTF_8.name());
return util.applyCss(html, NAME, projectName);
}
} catch (Docx4JException e) {
throw new IOException(e);
} finally {
Thread.currentThread().setContextClassLoader(loader);
}
}
public void testAddManager() throws Exception {
cacheName = SAMPLE_CACHE1;
if (manager1.getStatus() != Status.STATUS_SHUTDOWN) manager1.shutdown();
Thread.currentThread().sleep(1000);
manager1 =
new CacheManager(
AbstractCacheTest.TEST_CONFIG_DIR
+ "distribution/jgroups/ehcache-distributed-jgroups.xml");
Thread.currentThread().sleep(3000);
manager2.clearAll();
Thread.currentThread().sleep(1000);
manager2.getEhcache(cacheName).put(new Element(new Integer(2), new Date()));
manager1.getEhcache(cacheName).put(new Element(new Integer(3), new Date()));
Thread.currentThread().sleep(2000);
assertTrue(
manager1.getEhcache(cacheName).getKeys().size()
== manager2.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size()
== manager3.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size()
== manager4.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size() == 2);
}
@Test
public void testTestingClient() throws Exception {
final TestingClient testingClient;
testingClient =
new TestingClient(
runner, context, new ClassPathResolver(Thread.currentThread().getContextClassLoader()));
final String baseDirectory = System.getProperty("user.dir");
final FileSet tests = new FileSet();
tests.setDirectory(baseDirectory + "/src/test/resources/org/moyrax/");
tests.addInclude("**/*.html");
context.setFiles(
tests.getDirectory(),
fileSetManager.getIncludedFiles(tests),
fileSetManager.getExcludedFiles(tests));
context.setLookupPackages(new String[] {"classpath:/org/moyrax/javascript/common/**"});
context.setClassLoader(new ContextClassLoader(Thread.currentThread().getContextClassLoader()));
Shell.setResolver("lib", new LibraryResolver("/org/moyrax/javascript/lib"));
Shell.setResolver(
"classpath", new ClassPathResolver(Thread.currentThread().getContextClassLoader()));
loadContextResources(testingClient);
testingClient.runTests();
}
public void testBasicReplication() throws Exception {
for (int i = 0; i < NBR_ELEMENTS; i++) {
manager1.getEhcache(cacheName).put(new Element(new Integer(i), "testdat"));
// Thread.currentThread().sleep(2);
}
Thread.currentThread().sleep(3000);
LOG.debug(
manager1.getEhcache(cacheName).getKeys().size()
+ " "
+ manager2.getEhcache(cacheName).getKeys().size()
+ " "
+ manager3.getEhcache(cacheName).getKeys().size());
assertTrue(
manager1.getEhcache(cacheName).getKeys().size()
== manager2.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size()
== manager3.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size()
== manager4.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size() == NBR_ELEMENTS);
manager1.getEhcache(cacheName).removeAll();
Thread.currentThread().sleep(1000);
assertTrue(
manager1.getEhcache(cacheName).getKeys().size()
== manager2.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size()
== manager3.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size()
== manager4.getEhcache(cacheName).getKeys().size()
&& manager1.getEhcache(cacheName).getKeys().size() == 0);
}
/**
* Enable sharing of the class-loader with 3rd party (e.g. digester).
*
* @return the class-loader user be the helper.
*/
public ClassLoader getClassLoader() {
log.debug(
"Class classloader: {} Thread classloader: {}",
this.getClass().getClassLoader(),
Thread.currentThread().getContextClassLoader());
return Thread.currentThread().getContextClassLoader();
}
/**
* Process a single row (this is repeated for all rows on input). On the first row, we do the
* following:
*
* <ul>
* <li>Setup a class loader that contains the Transformer jar file
* <li>Use this class loader to create a new instance of the transformer
* <li>The transformer will be reused for all subsequent rows
* <li>Open the zos file
* <li>Process the first row (classloader will find custom code if needed)
* <li>Restore the context class loader to avoid interference with PDI
* </ul>
*
* Here we also keep track of how many bytes from the file record were actually consumed by the
* transformers. This allows the leftover to be processed on the next call to this method.
*
* @param smi Step meta
* @param sdi Step data
* @throws KettleException if something goes wrong
*/
public boolean processRow(StepMetaInterface smi, StepDataInterface sdi) throws KettleException {
meta = (ZosFileInputMeta) smi;
data = (ZosFileInputData) sdi;
if (first) {
first = false;
data.outputRowMeta = new RowMeta();
meta.getFields(data.outputRowMeta, getStepname(), null, null, this);
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
try {
Cob2Pdi.setTransformerClassLoader(
getClass(), Cob2Pdi.getJarFileName(data.compositeJaxbClassName));
data.cobolBinding =
Cob2Pdi.newCobolBinding(Cob2Pdi.getJaxbClassName(data.compositeJaxbClassName));
data.fis = ZosFileInputStreamFactory.create(meta, new File(data.filename));
data.hostRecord = Cob2Pdi.newHostRecord(data.cobolBinding);
data.hostCharset = meta.getHostCharset();
data.status = new HostTransformStatus();
logBasic(BaseMessages.getString(PKG, "ZosFileInput.FileOpened.Message", data.filename));
return processRow();
} catch (FileNotFoundException e) {
throw new KettleException(e);
} finally {
Thread.currentThread().setContextClassLoader(tccl);
}
} else {
return processRow();
}
}
/** run do the work. */
public void run() {
int percent = 0;
String msg = "";
System.out.println(
"SimpleWorker.run : Thread " + Thread.currentThread().getName() + " started");
eventQueue = Toolkit.getDefaultToolkit().getSystemEventQueue();
// while (running) {
// count++;
// if (count >= MAXWORK) {
// running = false;
// }
//
// msg = "Message from " + Thread.currentThread().getName()
// + " : " + count;
//
// eventQueue.postEvent(new EventSearchWorker(target, msg, count));
//
// try {
// this.sleep(800);
// } catch (Exception e) {
// System.out.println("E:run : " + e.toString());
// }
// }
// eventQueue.postEvent(new EventSearchWorker(target, "deneme\n", count));
search(searchEngine);
target.dispatchEvent(
new EventSearchWorker(target, "", count, this.searchEngine.getName() + " completed.."));
// eventQueue.postEvent(new EventSearchWorker(target, "Work done..", count));
System.out.println("SimpleWorker.run : Thread " + Thread.currentThread().getName() + " stoped");
} // run
/**
* Verifies that a client timeout will be detected by a Nailgun NGInputStream reading from a
* blocking heartbeat stream.
*/
@Test(expected = InterruptedException.class)
public void whenClientTimeoutDetectedThenMainThreadIsInterrupted()
throws InterruptedException, IOException {
final long timeoutMillis = 100;
final long intervalMillis = timeoutMillis * 2; // Interval > timeout to trigger disconnection.
final ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "exclusive_execution", tmp);
workspace.setUp();
// Build an NGContext connected to an NGInputStream reading from a stream that will timeout.
Thread.currentThread().setName("Test");
try (TestContext context =
new TestContext(
ImmutableMap.copyOf(System.getenv()),
TestContext.createHeartBeatStream(intervalMillis),
timeoutMillis)) {
final Thread commandThread = Thread.currentThread();
context.addClientListener(
new NGClientListener() {
@Override
public void clientDisconnected() throws InterruptedException {
commandThread.interrupt();
}
});
Thread.sleep(1000);
fail("Should have been interrupted.");
}
}