private final $base_package.JVpp jvpp;
private final java.util.Map<Integer, $base_package.$callback_package.JVppCallback> callbacks;
- public CallbackJVppFacade(final $base_package.JVpp jvpp,
- java.util.Map<Integer, $base_package.$callback_package.JVppCallback> callbacks) {
+ /**
+ * <p>Create CallbackJVppFacade object for provided JVpp instance.
+ * Constructor internally creates CallbackJVppFacadeCallback class for processing callbacks
+ * and then connects to provided JVpp instance
+ *
+ * @param jvpp provided $base_package.JVpp instance
+ *
+ * @throws java.io.IOException in case instance cannot connect to JVPP
+ */
+ public CallbackJVppFacade(final $base_package.JVpp jvpp) throws java.io.IOException {
this.jvpp = java.util.Objects.requireNonNull(jvpp,"jvpp is null");
- this.callbacks = callbacks;
+ this.callbacks = new java.util.HashMap<>();
+ this.jvpp.connect(new CallbackJVppFacadeCallback(this.callbacks));
}
@Override
*/
public class FutureJVppFacade extends FutureJVppInvokerFacade implements FutureJVpp {
- public FutureJVppFacade(final $base_package.JVpp jvpp,
- final java.util.Map<Integer, java.util.concurrent.CompletableFuture<? extends $base_package.$dto_package.JVppReply<?>>> requestMap) {
- super(jvpp, requestMap);
+ /**
+ * <p>Create FutureJVppFacade object for provided JVpp instance.
+ * Constructor internally creates FutureJVppFacadeCallback class for processing callbacks
+ * and then connects to provided JVpp instance
+ *
+ * @param jvpp provided $base_package.JVpp instance
+ *
+ * @throws java.io.IOException in case instance cannot connect to JVPP
+ */
+ public FutureJVppFacade(final $base_package.JVpp jvpp) throws java.io.IOException {
+ super(jvpp, new java.util.HashMap<>());
+ jvpp.connect(new FutureJVppFacadeCallback(getRequests()));
}
$methods
}
*/
public interface JVpp extends java.lang.AutoCloseable {
+ /**
+ * Generic connect with $base_package.callback.JVppCallback callback handler
+ * providing connecting to VPP
+ *
+ * @param callback JVppCallback instance providing callback handling
+ *
+ * @throws java.io.IOException if connection cannot be initiated
+ */
+ void connect($base_package.callback.JVppCallback callback) throws java.io.IOException;
+
/**
* Generic dispatch method for sending requests to VPP
*/
this.connection = java.util.Objects.requireNonNull(connection,"Connection is null");
}
+ @Override
+ public void connect($base_package.callback.JVppCallback callback) throws java.io.IOException {
+ connection.connect(callback);
+ }
+
@Override
public void close() {
connection.close();
package org.openvpp.jvpp;
+import java.io.IOException;
+
/**
* Representation of a management connection to VPP.
* Connection is initiated when instance is created, closed with close().
*/
public interface VppConnection extends AutoCloseable {
+ /**
+ * Open VppConnection for communication with VPP
+ *
+ * @param callback instance handling responses
+ *
+ * @throws IOException if connection is not established
+ */
+ void connect(final org.openvpp.jvpp.callback.JVppCallback callback) throws IOException;
+
/**
* Check if this instance connection is active.
*
private final String clientName;
private volatile boolean disconnected = false;
- private VppJNIConnection(final String clientName) {
+ /**
+ * Create VPPJNIConnection instance for client connecting to VPP.
+ *
+ * @param clientName client name instance to be used for communication. Single connection per clientName is allowed.
+ */
+ public VppJNIConnection(final String clientName) {
this.clientName = Objects.requireNonNull(clientName,"Null clientName");
}
private static final Map<String, VppJNIConnection> connections = new HashMap<>();
/**
- * Create a new Vpp connection identified by clientName parameter.
+ * Initiate VPP connection for current instance
*
* Multiple instances are allowed since this class is not a singleton
* (VPP allows multiple management connections).
*
* However only a single connection per clientName is allowed.
*
- * @param clientName identifier of vpp connection
* @param callback global callback to receive response calls from vpp
*
- * @return new Vpp connection
- * @throws IOException in case the connection could not be established, or there already is a connection with the same name
+ * @throws IOException in case the connection could not be established
*/
- public static VppJNIConnection create(final String clientName, final JVppCallback callback) throws IOException {
+ public void connect(final JVppCallback callback) throws IOException {
synchronized (VppJNIConnection.class) {
if(connections.containsKey(clientName)) {
throw new IOException("Client " + clientName + " already connected");
}
- final VppJNIConnection vppJNIConnection = new VppJNIConnection(clientName);
final int ret = clientConnect(clientName, callback);
if (ret != 0) {
throw new IOException("Connection returned error " + ret);
}
- connections.put(clientName, vppJNIConnection);
- return vppJNIConnection;
+ connections.put(clientName, this);
}
}
this.requests = Objects.requireNonNull(requestMap, "Null requestMap");
}
+ protected final Map<Integer, CompletableFuture<? extends JVppReply<?>>> getRequests() {
+ return this.requests;
+ }
+
// TODO use Optional in Future, java8
@Override
private static void testCallbackApi() throws Exception {
System.out.println("Testing Java callback API");
- JVpp jvpp = new JVppImpl(VppJNIConnection.create("CallbackApiTest", new TestCallback()));
+ JVpp jvpp = new JVppImpl( new VppJNIConnection("CallbackApiTest"));
+ jvpp.connect( new TestCallback());
System.out.println("Successfully connected to VPP");
System.out.println("Sending ShowVersion request...");
package org.openvpp.jvpp.test;
-import java.util.HashMap;
-import java.util.Map;
import org.openvpp.jvpp.JVpp;
import org.openvpp.jvpp.JVppImpl;
import org.openvpp.jvpp.VppJNIConnection;
-import org.openvpp.jvpp.callback.JVppCallback;
import org.openvpp.jvpp.callback.ShowVersionCallback;
import org.openvpp.jvpp.callfacade.CallbackJVppFacade;
-import org.openvpp.jvpp.callfacade.CallbackJVppFacadeCallback;
/**
* CallbackJVppFacade together with CallbackJVppFacadeCallback allow for setting different callback for each request.
private static void testCallbackFacade() throws Exception {
System.out.println("Testing CallbackJVppFacade");
- final Map<Integer, JVppCallback> callbackMap = new HashMap<>();
- JVpp impl = new JVppImpl(VppJNIConnection.create("CallbackApiTest", new CallbackJVppFacadeCallback(callbackMap)));
- CallbackJVppFacade jvpp = new CallbackJVppFacade(impl, callbackMap);
+ JVpp jvpp = new JVppImpl(new VppJNIConnection("CallbackApiTest"));
+
+ CallbackJVppFacade jvppCallbackFacade = new CallbackJVppFacade(jvpp);
System.out.println("Successfully connected to VPP");
- jvpp.showVersion(showVersionCallback1);
- jvpp.showVersion(showVersionCallback2);
+ jvppCallbackFacade.showVersion(showVersionCallback1);
+ jvppCallbackFacade.showVersion(showVersionCallback2);
Thread.sleep(2000);
System.out.println("Disconnecting...");
- impl.close();
+ jvpp.close();
Thread.sleep(1000);
}
private static void testControlPing() throws Exception {
System.out.println("Testing ControlPing using Java callback API");
- JVpp jvpp = new JVppImpl(VppJNIConnection.create("ControlPingTest", new ControlPingCallback() {
+ JVpp jvpp = new JVppImpl( new VppJNIConnection("ControlPingTest"));
+ jvpp.connect( new ControlPingCallback() {
@Override
public void onControlPingReply(final ControlPingReply reply) {
System.out.printf("Received ControlPingReply: context=%d, retval=%d, clientIndex=%d vpePid=%d\n",
reply.context, reply.retval, reply.clientIndex, reply.vpePid);
}
- }));
+ });
System.out.println("Successfully connected to VPP");
Thread.sleep(1000);
package org.openvpp.jvpp.test;
-import java.util.HashMap;
-import java.util.Map;
import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import org.openvpp.jvpp.VppJNIConnection;
import org.openvpp.jvpp.dto.GetNodeIndex;
import org.openvpp.jvpp.dto.GetNodeIndexReply;
-import org.openvpp.jvpp.dto.JVppReply;
import org.openvpp.jvpp.dto.ShowVersion;
import org.openvpp.jvpp.dto.ShowVersionReply;
import org.openvpp.jvpp.dto.SwInterfaceDetails;
import org.openvpp.jvpp.dto.SwInterfaceDetailsReplyDump;
import org.openvpp.jvpp.dto.SwInterfaceDump;
import org.openvpp.jvpp.future.FutureJVppFacade;
-import org.openvpp.jvpp.future.FutureJVppFacadeCallback;
public class FutureApiTest {
private static void testFutureApi() throws Exception {
System.out.println("Testing Java future API");
- final Map<Integer, CompletableFuture<? extends JVppReply<?>>> map = new HashMap<>();
final org.openvpp.jvpp.JVppImpl impl =
- new org.openvpp.jvpp.JVppImpl(VppJNIConnection.create("FutureApiTest", new FutureJVppFacadeCallback(map)));
- final FutureJVppFacade jvppFacade = new FutureJVppFacade(impl, map);
+ new org.openvpp.jvpp.JVppImpl(new VppJNIConnection("FutureApiTest"));
+ final FutureJVppFacade jvppFacade = new FutureJVppFacade(impl);
System.out.println("Successfully connected to VPP");
testShowVersion(jvppFacade);