The API Gateway has a default mediation flow, which you can extend by adding custom mediation sequences. In API Manager there are 3 default sequences engaged as
fault. You create a custom mediation sequence either manually or using a tool such as the WSO2 API Manager Tooling Plug-in, and then engage it per API or globally to all APIs of a specific tenant. With custom mediation sequences you can modify the default mediation flow for different usabilities according to your requirement. Log the mediation flow, execute operations on Message context properties, to customize, format the requests and responses are some of them.
Please note that following mediators are not usable within custom sequences since they are not supported by API Gateway custom mediations.
- Call mediator in non-blocking mode
- Send mediator
Default mediation flow
The address endpoint of the WSO2 API Manager cannot be constructed dynamically. To achieve the requirement of a dynamic endpoint, you can use the default endpoint instead. The default endpoint sends the message to the address specified in the To header. The To header can be constructed dynamically. For example,
In this example, you have constructed the
service_ep property dynamically and assigned the value of this property to the To header. The default endpoint sends the message to the address specified in the To header, in this case,
Adding a non-blocking send operation
In this example, the Send mediator, which is in the proxy service, transfers a file to a Virtual File System (VFS) transport endpoint, using the VFS transport. By default, VFS is a non-blocking transport, which means a new thread is spawned for each outgoing message. The Property mediator, which is added before the Send mediator, removes the ClientAPINonBlocking property from the message to perform the mediation in a single thread. This is required when you want to avoid out-of-memory failures that occur when the file that you are transferring is large.
Creating per-API extensions
Create and upload using WSO2 Developer Studio
The recommended way to engage a mediation extension sequence per API is to create a custom sequence using WSO2 Developer Studio, upload it via the APIM Perspective and then engage it using the API Publisher. The following tutorial demonstrates how to do this: Change the Default Mediation Flow of API Requests.
Create and upload manually in the API Publisher
You can also create a mediation sequence manually and upload it from the API Publisher itself. For instance, you can copy the above default mediation flow content into an XML file. In the Implement tab of the API, select the Enable Message Mediation check box and click the Upload In Flow or Upload Out Flow field (for the example above, it needs to be uploaded to the
In flow). Once the file is uploaded, save and publish the API. When you invoke the API, the request is sent to the endpoint referred to in the To header.
Create manually and save in the file system
Alternatively, you can name the mediation XML file in the pattern
<API_NAME>:v<VERSION>--<DIRECTION> and save it directly in the following location:
- In the single-tenant mode, save the XML file in the
- In the multi-tenant mode, save the XML file in the tenant's synapse sequence folder. For example, if tenant id is 1, then save it in
In the naming pattern, the
<DIRECTION> can be
Out. When it is
In, the extension is triggered on the in-flow (request path) and when it is
Out, the extension is triggered on the out-flow (response path). To change the default fault sequence, you can either modify the default sequence or write a custom fault sequence and engage it to APIs through the API Publisher.
An example synapse configuration of a per-API extension sequence created for the API
admin--TwitterSearch version 1.0.0 is given below.
You can copy this content into an XML file (e.g.,
twittersearch_ext.xml) and save it in the
The above sequence prints a log message on the console whenever the
TwitterSearch API is invoked.
Creating global extensions
You can also engage mediation extension sequences to all APIs of a specific tenant at once. To do that, simply create the XML with the naming pattern
WSO2AM--Ext--<DIRECTION> and save it in the
An example synapse configuration of a global extension sequence is given below:
This custom sequence assigns the value of your basic authentication to Authorization header.
You can copy this content into an XML file (e.g.,
global_ext.xml) and save it in the
When you invoke your REST API via a REST Client, configure that client to have a custom header (Authentication) for your basic authentication credential and configure the Authorization header to contain the bearer token for the API. When you send the Authentication and Authorization headers, the Gateway drops the Authorization header, converts the Authentication to Authorization headers and sends to the backend.
Class Mediator is one specific example of mediation extension. When creating a class mediator, we are allowed to write a Java class which extends the org.apache.synapse.mediators.AbstractMediator class.
This class implements the mediate() function which access the message context and provide the facility to customize the mediation flow of the API. Through that we can read properties of the message context into variables and perform operations.
Then we can export this class as a jar file and add as a library to <API-M_HOME>/repository/components/lib directory.
By refering this class with the fully qualified class name in a class mediator in the API as below, we can execute it in the insequence or outsequence of the API globally or per API as described above.
If any properties are specified in the java class of the class mediator, the corresponding setter methods are invoked once on the class during initialization.
You can use the Class mediator for user-specific, custom developments only when there is no built-in mediator that already provides the required functionality, because maintaining custom classes incurs a high overhead. Therefore, avoid using them unless the scenario is frequently re-used and very user-specific.
Your class mediator might not be picked up and updated, if you use an existing package when creating it.