@Override
protected void setUp() throws Exception {
tmp = IO.getFile("generated/tmp");
tmp.mkdirs();
IO.copy(IO.getFile("testdata/ws"), tmp);
workspace = Workspace.getWorkspace(tmp);
workspace.refresh();
InfoRepository repo = workspace.getPlugin(InfoRepository.class);
t1 = create("bsn-1", new Version(1, 0, 0));
t2 = create("bsn-2", new Version(1, 0, 0));
repo.put(new FileInputStream(t1), null);
repo.put(new FileInputStream(t2), null);
t1 = repo.get("bsn-1", new Version(1, 0, 0), null);
t2 = repo.get("bsn-2", new Version(1, 0, 0), null);
repo.put(new FileInputStream(IO.getFile("generated/biz.aQute.remote.launcher.jar")), null);
workspace.getPlugins().add(repo);
File storage = IO.getFile("generated/storage-1");
storage.mkdirs();
configuration = new HashMap<String, Object>();
configuration.put(
Constants.FRAMEWORK_STORAGE_CLEAN, Constants.FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT);
configuration.put(Constants.FRAMEWORK_STORAGE, storage.getAbsolutePath());
configuration.put(
Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, "org.osgi.framework.launch;version=1.2");
framework = new org.apache.felix.framework.FrameworkFactory().newFramework(configuration);
framework.init();
framework.start();
context = framework.getBundleContext();
location = "reference:" + IO.getFile("generated/biz.aQute.remote.agent.jar").toURI().toString();
agent = context.installBundle(location);
agent.start();
thread =
new Thread() {
@Override
public void run() {
try {
Main.main(
new String[] {
"-s", "generated/storage", "-c", "generated/cache", "-p", "1090", "-et"
});
} catch (Exception e) {
e.printStackTrace();
}
}
};
thread.setDaemon(true);
thread.start();
super.setUp();
}
/**
* Get Tab with ID
*
* @param AD_Tab_ID
* @return tab or null
*/
public UITab getTab(int AD_Tab_ID) {
Integer tabKey = Integer.valueOf(AD_Tab_ID);
UITab tab = m_tabs.get(tabKey);
if (tab == null) {
// Check added for referenced tabs
if (m_referencetabs.get(tabKey) != null) return m_referencetabs.get(tabKey);
throw new CompiereStateException("No such tab:" + AD_Tab_ID);
} // find in window
return tab;
} // getTab
public boolean startProxy(long from, long to) {
// lazy init for proxy support check quickly in isReadable
if (ProxyConnections == null) {
ProxyConnections = new HashMap<Long, EventableChannel>();
}
EventableChannel target = Connections.get(to);
if (target != null) {
ProxyConnections.put(from, target);
return true;
} else {
return false;
}
}
void close() {
try {
if (mySelector != null) mySelector.close();
} catch (IOException e) {
}
mySelector = null;
// run down open connections and sockets.
Iterator<ServerSocketChannel> i = Acceptors.values().iterator();
while (i.hasNext()) {
try {
i.next().close();
} catch (IOException e) {
}
}
// 29Sep09: We create an ArrayList of the existing connections, then iterate over
// that to call unbind on them. This is because an unbind can trigger a reconnect,
// which will add to the Connections HashMap, causing a ConcurrentModificationException.
// XXX: The correct behavior here would be to latch the various reactor methods to return
// immediately if the reactor is shutting down.
ArrayList<EventableChannel> conns = new ArrayList<EventableChannel>();
Iterator<EventableChannel> i2 = Connections.values().iterator();
while (i2.hasNext()) {
EventableChannel ec = i2.next();
if (ec != null) {
conns.add(ec);
}
}
Connections.clear();
ListIterator<EventableChannel> i3 = conns.listIterator(0);
while (i3.hasNext()) {
EventableChannel ec = i3.next();
eventCallback(ec.getBinding(), EM_CONNECTION_UNBOUND, null);
ec.close();
EventableSocketChannel sc = (EventableSocketChannel) ec;
if (sc != null && sc.isAttached()) DetachedConnections.add(sc);
}
ListIterator<EventableSocketChannel> i4 = DetachedConnections.listIterator(0);
while (i4.hasNext()) {
EventableSocketChannel ec = i4.next();
ec.cleanup();
}
DetachedConnections.clear();
}
void isReadable(SelectionKey k) {
EventableChannel ec = (EventableChannel) k.attachment();
long b = ec.getBinding();
if (ec.isWatchOnly()) {
if (ec.isNotifyReadable()) eventCallback(b, EM_CONNECTION_NOTIFY_READABLE, null);
} else {
myReadBuffer.clear();
try {
ec.readInboundData(myReadBuffer);
myReadBuffer.flip();
if (myReadBuffer.limit() > 0) {
if (ProxyConnections != null) {
EventableChannel target = ProxyConnections.get(b);
if (target != null) {
ByteBuffer myWriteBuffer = ByteBuffer.allocate(myReadBuffer.limit());
myWriteBuffer.put(myReadBuffer);
myWriteBuffer.flip();
target.scheduleOutboundData(myWriteBuffer);
} else {
eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
}
} else {
eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
}
}
} catch (IOException e) {
UnboundConnections.add(b);
}
}
}
/**
* Get Field
*
* @param AD_Field_ID id
* @param windowNo relative windowNo
* @return field or null
*/
public UIField getField(int AD_Field_ID, int windowNo) {
Integer key = Integer.valueOf(AD_Field_ID);
UIField field = m_fields.get(key);
if (field == null) {
UIFieldVOFactory fieldFactory = new UIFieldVOFactory();
UIFieldVO vo = fieldFactory.get(m_context, AD_Field_ID);
// m_context.setSOTrx(windowNo, isSOTrx);
if (vo != null) {
field = new UIField(vo);
field.initialize(m_context, windowNo);
log.warning("Loaded directly: " + field); // SOTrx may not
// be correct
m_fields.put(key, field); // save in cache
}
} // create new
return field;
} // getField
public SocketChannel detachChannel(long sig) {
EventableSocketChannel ec = (EventableSocketChannel) Connections.get(sig);
if (ec != null) {
UnboundConnections.add(sig);
return ec.getChannel();
} else {
return null;
}
}
public long openUdpSocket(InetSocketAddress address) throws IOException {
// TODO, don't throw an exception out of here.
DatagramChannel dg = DatagramChannel.open();
dg.configureBlocking(false);
dg.socket().bind(address);
long b = createBinding();
EventableChannel ec = new EventableDatagramChannel(dg, b, mySelector);
dg.register(mySelector, SelectionKey.OP_READ, ec);
Connections.put(b, ec);
return b;
}
void removeUnboundConnections() {
if (UnboundConnections.size() == 0) {
return;
}
ArrayList<Long> currentUnboundConnections = UnboundConnections;
// fix concurrent modification exception
UnboundConnections = new ArrayList<Long>();
for (long b : currentUnboundConnections) {
EventableChannel ec = Connections.remove(b);
if (ec != null) {
if (ProxyConnections != null) {
ProxyConnections.remove(b);
}
eventCallback(b, EM_CONNECTION_UNBOUND, null);
ec.close();
EventableSocketChannel sc = (EventableSocketChannel) ec;
if (sc != null && sc.isAttached()) DetachedConnections.add(sc);
}
}
}
/** Fill Tab and Field arrays */
private void fillTabsFieldsAndInitFieldsAndCreateDependencyRelations(UIWindow win, int windowNO) {
ArrayList<UITab> tabs = win.getTabs();
for (int j = 0; j < tabs.size(); j++) {
UITab winTab = tabs.get(j);
Integer tabKey = Integer.valueOf(winTab.getAD_Tab_ID());
Integer ReferencetabKey = Integer.valueOf(winTab.getReferenced_Tab_ID());
m_tabs.put(tabKey, winTab);
m_referencetabs.put(ReferencetabKey, winTab);
//
ArrayList<UIField> fields = winTab.getFields();
for (int k = 0; k < fields.size(); k++) {
UIField field = fields.get(k);
field.initialize(m_context, windowNO);
Integer fieldKey = Integer.valueOf(field.getAD_Field_ID());
// set the correct value
if (field.isLookup()) field.getLookup().setContext(m_context, windowNO);
m_fields.put(fieldKey, field);
}
winTab.createDependencyRelations();
}
} // fillTabsFields
public long startTcpServer(SocketAddress sa) throws EmReactorException {
try {
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.socket().bind(sa);
long s = createBinding();
Acceptors.put(s, server);
server.register(mySelector, SelectionKey.OP_ACCEPT, s);
return s;
} catch (IOException e) {
throw new EmReactorException("unable to open socket acceptor: " + e.toString());
}
}
public long attachChannel(SocketChannel sc, boolean watch_mode) {
long b = createBinding();
EventableSocketChannel ec = new EventableSocketChannel(sc, b, mySelector);
ec.setAttached();
if (watch_mode) ec.setWatchOnly();
Connections.put(b, ec);
NewConnections.add(b);
return b;
}
void isAcceptable(SelectionKey k) {
ServerSocketChannel ss = (ServerSocketChannel) k.channel();
SocketChannel sn;
long b;
for (int n = 0; n < 10; n++) {
try {
sn = ss.accept();
if (sn == null) break;
} catch (IOException e) {
e.printStackTrace();
k.cancel();
ServerSocketChannel server = Acceptors.remove(k.attachment());
if (server != null)
try {
server.close();
} catch (IOException ex) {
}
;
break;
}
try {
sn.configureBlocking(false);
} catch (IOException e) {
e.printStackTrace();
continue;
}
b = createBinding();
EventableSocketChannel ec = new EventableSocketChannel(sn, b, mySelector);
Connections.put(b, ec);
NewConnections.add(b);
eventCallback(((Long) k.attachment()).longValue(), EM_CONNECTION_ACCEPTED, null, b);
}
}
/**
* Logout
*
* @param expired expire
*/
public void logout(boolean expired) {
// End Session
MSession session = MSession.get(m_context); // finish
if (session != null) {
if (expired) {
if (session.getDescription() == null) session.setDescription("Expired");
else session.setDescription(session.getDescription() + " Expired");
}
session.logout(); // saves
}
if (m_context != null) {
int gwtServerID = m_context.getContextAsInt(MRole.GWTSERVERID);
if (gwtServerID > 0) MRole.resetGwt(gwtServerID);
}
// Clear Cache
m_tabs.clear();
m_fields.clear();
// m_windows.clear();
m_context.clear();
m_results.clear();
//
} // logout
void removeUnboundConnections() {
ListIterator<Long> iter = UnboundConnections.listIterator(0);
while (iter.hasNext()) {
long b = iter.next();
EventableChannel ec = Connections.remove(b);
if (ec != null) {
eventCallback(b, EM_CONNECTION_UNBOUND, null);
ec.close();
EventableSocketChannel sc = (EventableSocketChannel) ec;
if (sc != null && sc.isAttached()) DetachedConnections.add(sc);
}
}
UnboundConnections.clear();
}
void addNewConnections() {
ListIterator<EventableSocketChannel> iter = DetachedConnections.listIterator(0);
while (iter.hasNext()) {
EventableSocketChannel ec = iter.next();
ec.cleanup();
}
DetachedConnections.clear();
ListIterator<Long> iter2 = NewConnections.listIterator(0);
while (iter2.hasNext()) {
long b = iter2.next();
EventableChannel ec = Connections.get(b);
if (ec != null) {
try {
ec.register();
} catch (ClosedChannelException e) {
UnboundConnections.add(ec.getBinding());
}
}
}
NewConnections.clear();
}
public long connectTcpServer(String bindAddr, int bindPort, String address, int port) {
long b = createBinding();
try {
SocketChannel sc = SocketChannel.open();
sc.configureBlocking(false);
if (bindAddr != null) sc.socket().bind(new InetSocketAddress(bindAddr, bindPort));
EventableSocketChannel ec = new EventableSocketChannel(sc, b, mySelector);
if (sc.connect(new InetSocketAddress(address, port))) {
// Connection returned immediately. Can happen with localhost connections.
// WARNING, this code is untested due to lack of available test conditions.
// Ought to be be able to come here from a localhost connection, but that
// doesn't happen on Linux. (Maybe on FreeBSD?)
// The reason for not handling this until we can test it is that we
// really need to return from this function WITHOUT triggering any EM events.
// That's because until the user code has seen the signature we generated here,
// it won't be able to properly dispatch them. The C++ EM deals with this
// by setting pending mode as a flag in ALL eventable descriptors and making
// the descriptor select for writable. Then, it can send UNBOUND and
// CONNECTION_COMPLETED on the next pass through the loop, because writable will
// fire.
throw new RuntimeException("immediate-connect unimplemented");
} else {
ec.setConnectPending();
Connections.put(b, ec);
NewConnections.add(b);
}
} catch (IOException e) {
// Can theoretically come here if a connect failure can be determined immediately.
// I don't know how to make that happen for testing purposes.
throw new RuntimeException("immediate-connect unimplemented: " + e.toString());
}
return b;
}
public void stopProxy(long from) {
ProxyConnections.remove(from);
}
public NodeVO getNode(String key) {
return m_nodes.get(key);
}
public int getConnectionCount() {
return Connections.size() + Acceptors.size();
}
public boolean isNotifyWritable(long sig) {
return Connections.get(sig).isNotifyWritable();
}
public void setNotifyWritable(long sig, boolean mode) {
((EventableSocketChannel) Connections.get(sig)).setNotifyWritable(mode);
}
public void putNode(String key, NodeVO node) {
m_nodes.put(key, node);
}
public Object[] getPeerName(long sig) {
return Connections.get(sig).getPeerName();
}
public void startTls(long sig) throws NoSuchAlgorithmException, KeyManagementException {
Connections.get(sig).startTls();
}
public void closeConnection(long sig, boolean afterWriting) {
EventableChannel ec = Connections.get(sig);
if (ec != null) if (ec.scheduleClose(afterWriting)) UnboundConnections.add(sig);
}
public void sendDatagram(long sig, ByteBuffer bb, String recipAddress, int recipPort) {
(Connections.get(sig)).scheduleOutboundDatagram(bb, recipAddress, recipPort);
}
public void setCommInactivityTimeout(long sig, long mills) {
Connections.get(sig).setCommInactivityTimeout(mills);
}
public void sendData(long sig, ByteBuffer bb) throws IOException {
EventableChannel channel = Connections.get(sig);
if (channel != null) {
channel.scheduleOutboundData(bb);
}
}
public void stopTcpServer(long signature) throws IOException {
ServerSocketChannel server = Acceptors.remove(signature);
if (server != null) server.close();
else throw new RuntimeException("failed to close unknown acceptor");
}
