Let's create our own interceptor that will count the number of PDUs that went through it.
In this example, we are going to use Storable interface.
First we are going to create a simple store for our PDU counter.
/**
* Store for persisting PDU count.
*/
public class ExampleInterceptorStore {
private int pduCount;
public ExampleInterceptorStore() {
pduCount = 0;
}
/**
* Increases the PDU count and returns it.
*/
public int increaseAndGetCount() {
return ++pduCount;
}
}
Now we are going to create a simple Interceptor.
/**
* Example interceptor that logs number of intercepted PDUs.
*/
public class ExampleInterceptor extends Interceptor {
private ExampleInterceptorStore store;
public ExampleInterceptor(
int id,
InterceptorModule module,
PetepHelper helper,
ExampleInterceptorStore store) {
super(id, module, helper);
this.store = store;
}
@Override
public boolean intercept(PDU pdu) {
Logger.getGlobal().info(
() -> "Example interceptor intercepted PDU number " + store.increaseAndGetCount() + "!"
);
return true;
}
@Override
public boolean prepare() {
Logger.getGlobal().info("Example interceptor prepared!");
return true;
}
@Override
public void stop() {
Logger.getGlobal().info("Example interceptor stopped!");
}
}
Ok, our interceptor logic is defined. Now we need to create module that will allow user to add our interceptor to the list of interceptors in PETEP.
/**
* Example interceptor module that creates interceptor for logging number of intercepted PDUs.
*/
public class ExampleInterceptorModule extends InterceptorModule implements Storable<ExampleInterceptorStore> {
/**
* Store for persisting the PDU counter
*/
private ExampleInterceptorStore store;
public ExampleInterceptorModule(
InterceptorModuleFactory factory,
String code,
String name,
String description,
boolean enabled) {
super(factory, code, name, description, enabled);
}
@Override
public Interceptor createInterceptor(int id, PetepHelper helper) {
if (store == null) {
store = new ExampleInterceptorStore();
}
return new ExampleInterceptor(id, this, helper, store);
}
@Override
public void loadStore(ExampleInterceptorStore store) {
this.store = store;
}
@Override
public ExampleInterceptorStore saveStore() {
return store;
}
}
Notice that our module implements Storable interface that allows it to store the data (our counter) in the project.
Now we can create a factory that will create the modules.
/**
* Example interceptor module factory for creating example interceptor modules.
*/
public class ExampleInterceptorModuleFactory extends InterceptorModuleFactory {
public ExampleInterceptorModuleFactory(Extension extension) {
super(extension);
}
@Override
public String getCode() {
return "example-interceptor";
}
@Override
public String getName() {
return "Example interceptor";
}
@Override
public InterceptorModule createModule(String code, String name, String description, boolean enabled) {
return new ExampleInterceptorModule(this, code, name, description, enabled);
}
}
And finally, we can register the factory to the PETEP in our PetepExtension.init() method by adding the following line to it.
helper.registerInterceptorModuleFactory(new ExampleInterceptorModuleFactory(this));