rik/mimis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Snapshot of base part

Browse Source
This commit is contained in:
Rik Veenboer
2016-06-20 11:11:57 +01:00
parent 84f3da2941
commit 1317047268
6 changed files with 365 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

204
java/base/src/main/java/base/work/Listen.java
View File

@@ -1,108 +1,96 @@
package base.work;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import base.exception.worker.ActivateException;
import base.worker.ForegroundListener;
import base.worker.BackgroundListener;
import base.worker.Worker;
import base.worker.pool.Listener;
import base.worker.pool.ListenerPool;
import base.worker.pool.PooledListener;
public abstract class Listen<E> extends Work implements Listener<E> {
protected static final Worker.Type WORKER_TYPE = Worker.Type.DIRECT;
protected Listener<E> listener;
protected Worker.Type workerType;
public Queue<E> queue;
public Listen() {
this(WORKER_TYPE);
}
protected Listen(Worker.Type workerType) {
this.workerType = workerType;
switch (workerType) {
case DIRECT:
return;
case FOREGROUND:
listener = new ForegroundListener<E>(this);
break;
default:
listener = new BackgroundListener<E>(this);
break;
}
queue = new ConcurrentLinkedQueue<E>();
}
protected Listen(Worker worker) {
this.worker = worker;
queue = new ConcurrentLinkedQueue<E>();
}
protected Listen(ListenerPool<E> listenerPool) {
listener = new PooledListener<E>(this);
listenerPool.add((PooledListener<E>) listener);
queue = new ConcurrentLinkedQueue<E>();
}
public synchronized void add(E element) {
if (workerType.equals(Worker.Type.DIRECT)) {
input(element);
} else {
listener.add(element);
}
}
public void start() {
if (workerType.equals(Worker.Type.DIRECT)) {
try {
activate();
} catch (ActivateException e) {
logger.error("Failed to start directly", e);
}
} else {
super.start();
}
}
public void stop() {
super.stop();
synchronized (this) {
notifyAll();
}
}
public void work() {
while (!queue.isEmpty()) {
logger.debug("Listen: work() > input");
input(queue.poll());
}
synchronized (this) {
logger.debug("Listen: work() > wait");
try {
wait();
} catch (InterruptedException e) {}
logger.debug("Listen: work() > notified");
}
}
public void input(Object object) {
MethodType methodType = MethodType.methodType(void.class, object.getClass());
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle methodHandle;
try {
methodHandle = lookup.findVirtual(getClass(), "input", methodType);
methodHandle.invoke(this, object);
} catch (Exception e) {
logger.error("", e);
} catch (Throwable e) {
logger.error("", e);
}
}
}
package base.work;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import base.exception.worker.ActivateException;
import base.worker.BackgroundListener;
import base.worker.ForegroundListener;
import base.worker.Worker;
import base.worker.pool.Listener;
import base.worker.pool.ListenerPool;
import base.worker.pool.PooledListener;
public abstract class Listen<E> extends Work implements Listener<E> {
protected static final Worker.Type WORKER_TYPE = Worker.Type.DIRECT;
protected Listener<E> listener;
protected Worker.Type workerType;
public Queue<E> queue;
public Listen() {
this(WORKER_TYPE);
}
protected Listen(Worker.Type workerType) {
queue = new ConcurrentLinkedQueue<E>();
this.workerType = workerType;
switch (workerType) {
case DIRECT:
return;
case FOREGROUND:
listener = new ForegroundListener<E>(this);
break;
default:
listener = new BackgroundListener<E>(this);
break;
}
}
protected Listen(Worker worker) {
this.worker = worker;
queue = new ConcurrentLinkedQueue<E>();
}
protected Listen(ListenerPool<E> listenerPool) {
listener = new PooledListener<E>(this);
listenerPool.add((PooledListener<E>) listener);
queue = new ConcurrentLinkedQueue<E>();
}
public synchronized void add(E element) {
if (workerType.equals(Worker.Type.DIRECT)) {
input(element);
} else {
queue.add(element);
listener.add(element);
}
}
public void start() {
if (workerType.equals(Worker.Type.DIRECT)) {
try {
activate();
} catch (ActivateException e) {
logger.error("Failed to start directly", e);
}
} else {
super.start();
}
}
public void stop() {
super.stop();
synchronized (this) {
notifyAll();
}
}
public void work() {
while (!queue.isEmpty()) {
logger.debug("Listen: work() > input");
input(queue.poll());
}
synchronized (this) {
logger.debug("Listen: work() > wait");
try {
wait();
} catch (InterruptedException e) {}
logger.debug("Listen: work() > notified");
}
}
public void input(E element) {
System.err.println(element);
}
}

146
java/base/src/main/java/base/work/Work.java
View File

@@ -1,73 +1,73 @@
package base.work;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import base.Control;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.worker.DirectWorker;
import base.worker.ThreadWorker;
import base.worker.Worker;
import base.worker.pool.PooledWorker;
import base.worker.pool.WorkerPool;
public abstract class Work implements Control {
protected static final Worker.Type WORKER_TYPE = Worker.Type.BACKGROUND;
protected Logger logger = LoggerFactory.getLogger(getClass());
protected Worker worker;
protected Work() {
this(WORKER_TYPE);
}
protected Work(Worker.Type workerType) {
switch (workerType) {
case FOREGROUND:
worker = new DirectWorker(this);
break;
default:
worker = new ThreadWorker(this);
break;
}
}
protected Work(Worker worker) {
this.worker = worker;
}
protected Work(WorkerPool workerPool) {
worker = new PooledWorker(this);
workerPool.add((PooledWorker) worker);
}
protected void sleep(int time) {
worker.sleep(time);
}
public void start() {
logger.debug("Work: start()");
worker.start();
}
public void stop() {
logger.debug("Work: stop()");
worker.stop();
}
public boolean active() {
logger.debug("Work: active()");
return worker.active();
}
public void exit() {
logger.debug("Work: exit()");
worker.exit();
}
public void activate() throws ActivateException {}
public void deactivate() throws DeactivateException {}
public abstract void work();
}
package base.work;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import base.Control;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.worker.DirectWorker;
import base.worker.ThreadWorker;
import base.worker.Worker;
import base.worker.pool.PooledWorker;
import base.worker.pool.WorkerPool;
public abstract class Work implements Control {
protected static final Worker.Type WORKER_TYPE = Worker.Type.BACKGROUND;
protected Logger logger = LoggerFactory.getLogger(getClass());
protected Worker worker;
protected Work() {
this(WORKER_TYPE);
}
protected Work(Worker.Type workerType) {
switch (workerType) {
case FOREGROUND:
worker = new DirectWorker(this);
break;
default:
worker = new ThreadWorker(this);
break;
}
}
protected Work(Worker worker) {
this.worker = worker;
}
protected Work(WorkerPool workerPool) {
worker = new PooledWorker(this);
workerPool.add((PooledWorker) worker);
}
protected void sleep(int time) {
worker.sleep(time);
}
public void start() {
logger.trace("Work: start()");
worker.start();
}
public void stop() {
logger.trace("Work: stop()");
worker.stop();
}
public boolean active() {
logger.trace("Work: active()");
return worker.active();
}
public void exit() {
logger.debug("Work: exit()");
worker.exit();
}
public void activate() throws ActivateException {}
public void deactivate() throws DeactivateException {}
public abstract void work();
}

43
java/base/src/main/java/base/worker/BackgroundListener.java
View File

@@ -1,22 +1,21 @@
package base.worker;
import base.work.Listen;
import base.worker.pool.Listener;
public class BackgroundListener<E> extends ThreadWorker implements Listener<E> {
protected Listen<E> listen;
public BackgroundListener(Listen<E> listen) {
super(listen);
this.listen = listen;
}
public BackgroundListener(Listen<E> listen, boolean start) {
super(listen);
}
public void add(E element) {
listen.queue.add(element);
listen.notify();
}
}
package base.worker;
import base.work.Listen;
import base.worker.pool.Listener;
public class BackgroundListener<E> extends ThreadWorker implements Listener<E> {
protected Listen<E> listen;
public BackgroundListener(Listen<E> listen) {
this(listen, true);
}
public BackgroundListener(Listen<E> listen, boolean thread) {
super(listen, thread);
this.listen = listen;
}
public void add(E element) {
listen.notify();
}
}

90
java/base/src/main/java/base/worker/ThreadWorker.java
View File

@@ -1,45 +1,45 @@
package base.worker;
import base.work.Work;
public class ThreadWorker extends Worker implements Runnable {
protected static final boolean THREAD = true;
protected boolean thread = true;
public ThreadWorker(Work work, boolean thread) {
this(work);
this.thread = thread;
}
public ThreadWorker(Work work) {
super(work);
}
public synchronized void start(boolean thread) {
if (!active) {
activate = true;
}
if (!run) {
run = true;
if (thread) {
logger.debug("Start thread");
new Thread(this, work.getClass().getName()).start();
} else {
logger.debug("Run directly");
run();
}
} else {
notifyAll();
}
}
public synchronized void start() {
start(thread);
}
public void exit() {
work.stop();
run = false;
}
}
package base.worker;
import base.work.Work;
public class ThreadWorker extends Worker implements Runnable {
protected static final boolean THREAD = true;
protected boolean thread = true;
public ThreadWorker(Work work, boolean thread) {
this(work);
this.thread = thread;
}
public ThreadWorker(Work work) {
super(work);
}
public synchronized void start(boolean thread) {
if (!active) {
activate = true;
}
if (!run) {
run = true;
if (thread) {
logger.debug("Start thread");
new Thread(this, work.getClass().getName()).start();
} else {
logger.debug("Run directly");
run();
}
} else {
notifyAll();
}
}
public synchronized void start() {
start(thread);
}
public void exit() {
run = false;
work.stop();
}
}

228
java/base/src/main/java/base/worker/Worker.java
View File

@@ -1,114 +1,114 @@
package base.worker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.work.Work;
public abstract class Worker {
public enum Type {
DIRECT, FOREGROUND, BACKGROUND, POOLED
}
public static final int SLEEP = 100;
protected Logger logger;
protected boolean run = false;
protected boolean active = false;
protected boolean activate = false;
protected boolean deactivate = false;
protected Work work;
public Worker(Work work) {
this.work = work;
logger = LoggerFactory.getLogger(work.getClass());
}
public boolean active() {
logger.debug("Worker: active()");
return deactivate || active;
}
public final void run() {
logger.debug("Worker: run()");
while (run || deactivate) {
runActivate();
runDeactivate();
runWork();
}
}
public void runActivate() {
if (activate && !active) {
logger.debug("Worker: runActivate()");
try {
work.activate();
active = true;
} catch (ActivateException e) {
logger.error("", e);
} finally {
activate = false;
}
}
}
public void runDeactivate() {
if (deactivate && active) {
logger.debug("Worker: runDeactivate()");
try {
work.deactivate();
} catch (DeactivateException e) {
logger.error("", e);
} finally {
deactivate = false;
active = false;
}
}
}
public void runWork() {
if (active) {
logger.debug("Worker: runWork() > work");
work.work();
} else if (run) {
try {
logger.debug("Worker: runWork() > wait");
synchronized (this) {
wait();
}
} catch (InterruptedException e) {
logger.info("", e);
}
}
}
public void sleep() {
sleep(SLEEP);
}
public void sleep(int time) {
try {
if (time > 0) {
Thread.sleep(time);
}
} catch (InterruptedException e) {
logger.info("", e);
}
}
public abstract void start();
public void stop() {
logger.debug("Worker: stop()");
if (active && !activate) {
deactivate = true;
}
activate = false;
}
abstract public void exit();
}
package base.worker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import base.exception.worker.ActivateException;
import base.exception.worker.DeactivateException;
import base.work.Work;
public abstract class Worker {
public enum Type {
DIRECT, FOREGROUND, BACKGROUND, POOLED
}
public static final int SLEEP = 100;
protected Logger logger;
protected boolean run = false;
protected boolean active = false;
protected boolean activate = false;
protected boolean deactivate = false;
protected Work work;
public Worker(Work work) {
this.work = work;
logger = LoggerFactory.getLogger(work.getClass());
}
public boolean active() {
logger.trace("Worker: active()");
return deactivate || active;
}
public final void run() {
logger.debug("Worker: run()");
while (run || deactivate) {
runActivate();
runDeactivate();
runWork();
}
}
public void runActivate() {
if (activate && !active) {
logger.trace("Worker: runActivate()");
try {
work.activate();
active = true;
} catch (ActivateException e) {
logger.error("", e);
} finally {
activate = false;
}
}
}
public void runDeactivate() {
if (deactivate && active) {
logger.trace("Worker: runDeactivate()");
try {
work.deactivate();
} catch (DeactivateException e) {
logger.error("", e);
} finally {
deactivate = false;
active = false;
}
}
}
public void runWork() {
if (active) {
logger.trace("Worker: runWork() > work");
work.work();
} else if (run) {
try {
logger.trace("Worker: runWork() > wait");
synchronized (this) {
wait();
}
} catch (InterruptedException e) {
logger.info("", e);
}
}
}
public void sleep() {
sleep(SLEEP);
}
public void sleep(int time) {
try {
if (time > 0) {
Thread.sleep(time);
}
} catch (InterruptedException e) {
logger.info("", e);
}
}
public abstract void start();
public void stop() {
logger.trace("Worker: stop()");
if (active && !activate) {
deactivate = true;
}
activate = false;
}
abstract public void exit();
}

31
java/base/src/test/java/junit/AllTests.java
View File

@@ -1,16 +1,17 @@
package junit;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({
TestTcpSocketCommunication.class,
TestTcpChannelCommunication.class,
TestUdpUnicastCommunication.class,
TestUdpMulticastCommunication.class
})
public class AllTests {}
package junit;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({
TestTcpSocketCommunication.class,
TestTcpChannelCommunication.class,
TestUdpUnicastCommunication.class,
TestUdpMulticastCommunication.class,
TestUdpDuplexCommunication.class
})
public class AllTests {}
// Should test start()/stop() of components, check implementation