import org.opendaylight.openflowplugin.api.openflow.device.handlers.MessageHandler;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableFeatures;
import java.math.BigInteger;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import java.util.Collection;
+import java.util.concurrent.Future;
/**
* The central entity of OFP is the Device Context, which encapsulate the logical state of a switch
*/
ConnectionContext getAuxiliaryConnectiobContexts(BigInteger cookie);
+ Xid getNextXid();
+
+ <T extends DataObject> Future<RpcResult<T>> sendRequest(DataObject dataObject);
+
}
package org.opendaylight.openflowplugin.api.openflow.device;
+import com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import java.util.concurrent.Future;
/**
* Request context handles all requests on device. Number of requests is limited by request quota. When this quota is
* <p/>
* Created by Martin Bobak <mbobak@cisco.com> on 25.2.2015.
*/
-public interface RequestContext {
+public interface RequestContext extends AutoCloseable {
- <T extends DataObject> Future<RpcResult<T>> createRequestFuture(DataObject dataObject);
+ <T extends DataObject> SettableFuture<RpcResult<T>> createRequestFuture();
- void requestSucceeded();
- void requestFailed(String exception);
+ void close();
}
*/
package org.opendaylight.openflowplugin.api.openflow.rpc;
+import com.google.common.util.concurrent.SettableFuture;
+import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.RpcService;
<S extends RpcService> void registerRpcServiceImplementation(Class<S> serviceClass, S serviceInstance);
- /*
+ /**
* Method adds request to request queue which has limited quota. After number of requests exceeds quota limit
- * {@link org.opendaylight.openflowplugin.api.openflow.device.exception.RequestQuotaExceededException} is thrown.
+ * future will be done immediately and will contain information about exceeded request quota.
*
* @param data
*/
- <T extends DataObject> Future<RpcResult<T>> addNewRequest(DataObject data);
+ <T extends DataObject> SettableFuture<RpcResult<T>> storeOrFail(RequestContext data);
/**
* Method for setting request quota value. When the Request Context quota is exceeded, incoming RPCs fail
void setRequestContextQuota(int maxRequestsPerDevice);
void forgetRequestContext(RequestContext requestContext);
+
+ /**
+ * Method provides device context.
+ * @return
+ */
+ DeviceContext getDeviceContext();
+
+ /**
+ * Method returns new request context for current request.
+ * @return
+ */
+ <T extends DataObject> RequestContext createRequestContext();
+
}
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
+import org.opendaylight.openflowplugin.api.openflow.device.Xid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableFeatures;
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.common.RpcResult;
import java.math.BigInteger;
import java.util.Collection;
+import java.util.concurrent.Future;
/**
*
return null;
}
+ @Override
+ public Xid getNextXid() {
+ return null;
+ }
+
+ @Override
+ public <T extends DataObject> Future<RpcResult<T>> sendRequest(final DataObject dataObject) {
+ return null;
+ }
+
}
package org.opendaylight.openflowplugin.impl.rpc;
import com.google.common.util.concurrent.SettableFuture;
-import java.util.concurrent.Future;
import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
import org.opendaylight.yangtools.yang.binding.DataObject;
this.rpcContext = rpcContext;
}
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.openflowplugin.api.openflow.device.RequestContext#createRequestFuture(org.opendaylight.yangtools
- * .yang.binding.DataObject)
- */
@Override
- public Future<RpcResult<T>> createRequestFuture(final DataObject dataObject) {
+ public SettableFuture<RpcResult<T>> createRequestFuture() {
rpcResultFuture = SettableFuture.create();
return rpcResultFuture;
}
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.openflowplugin.api.openflow.device.RequestContext#requestSucceeded()
- */
@Override
- public void requestSucceeded() {
- // TODO Auto-generated method stub
-
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.openflowplugin.api.openflow.device.RequestContext#requestFailed(java.lang.String)
- */
- @Override
- public void requestFailed(final String exception) {
- // TODO Auto-generated method stub
-
+ public void close() {
+ rpcContext.forgetRequestContext(this);
}
}
*/
package org.opendaylight.openflowplugin.impl.rpc;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration;
import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.concurrent.Future;
public class RpcContextImpl implements RpcContext {
}
@Override
- public <T extends DataObject> Future<RpcResult<T>> addNewRequest(final DataObject data) {
- final Future<RpcResult<T>> rpcResultFuture;
- final RequestContext requestContext = new RequestContextImpl(this);
+ public <T extends DataObject> SettableFuture<RpcResult<T>> storeOrFail(RequestContext requestContext) {
+ final SettableFuture<RpcResult<T>> rpcResultFuture = requestContext.createRequestFuture();
if (synchronizedRequestsList.size() < maxRequestsPerDevice) {
synchronizedRequestsList.add(requestContext);
- rpcResultFuture = requestContext.createRequestFuture(data);
-
- ListenableFuture<RpcResult<Void>> resultFutureFromDevice = sendRequestToDevice(data);
- Futures.addCallback(resultFutureFromDevice, new FutureCallback<Object>() {
- @Override
- public void onSuccess(final Object o) {
- requestContext.requestSucceeded();
- }
-
- @Override
- public void onFailure(final Throwable throwable) {
- requestContext.requestFailed(throwable.getCause().getMessage());
- }
- });
} else {
- rpcResultFuture = Futures.immediateFuture(RpcResultBuilder.<T>failed().withError(RpcError.ErrorType.APPLICATION, "", "Request queue full.").build());
+ RpcResult rpcResult = RpcResultBuilder.failed().withError(RpcError.ErrorType.APPLICATION, "", "Device's request queue is full.").build();
+ rpcResultFuture.set(rpcResult);
}
-
-
return rpcResultFuture;
}
- private ListenableFuture<RpcResult<Void>> sendRequestToDevice(final DataObject data) {
- //TODO : send data to device
- return null;
- }
-
/**
* Unregisters all services.
requestContexts.remove(requestContext);
}
+ @Override
+ public DeviceContext getDeviceContext() {
+ return deviceContext;
+ }
+
+ @Override
+ public <T extends DataObject> RequestContext createRequestContext() {
+ return new RequestContextImpl<T>(this);
+ }
+
public boolean isRequestContextCapacityEmpty() {
return requestContexts.size() <= maxRequestsPerDevice;
}