Settings HTTP output header parameters working with aggregation - http

Question

I am trying to change the contentType from the response of an aggregated operation, here is my example code.
interface MyAggregateInterface {
RequestResponse:
op1(typeOp1Request)(typeOp1Response)
}
outputPort MyAggregatePort {
Interfaces: MyAggregateInterface
}
embedded {
Jolie:
"MyAggratedCode.ol" in MyAggregatePort
}
inputPort MyInputPortHttp {
Protocol: http {
.debug= 1;
.debug.showContent =1;
.format -> format;
.contentType -> mime;
.charset ="UTF-8";
.default = "default";
.compression = false
}
Location: "socket://localhost:8081"
Interfaces: DefaultHttpInterface
Aggregates: MyAggregatePort
}
I would like to change the return format for op1.

Answer 1

well I will try to answer your question
we need to define your op1 response type
type typeOp1Response:any{
.format?:string
}
or if you prefer
type typeOp1Response:undefined
I personally prefer the first one so that you can decide the mime in the aggregated service
Now you need to add a courier sessions
courier MyInputPortHttp {
[interface MyAggregateInterface( request )( response )]{
forward( request )( response );
if (is_defined(response.format)){
mime = response.format;
undef(response.format);
}
}
This implementation has a limitation that can return flat data in the root node
Another way is to use the inputType to define your output format.
type typeOp1Request:void{
.otherParameter1:string
.format?:string
}
then your courier
courier MyInputPortHttp {
[interface MyAggregateInterface( request )( response )]{
forward( request )( response );
if (request.format=="json"){
mime = "application/json"
};
if (request.format=="xml"){
mime = "application/xml"
};
}
Not sure if this answers your question

Answer 2

As Balint pointed out, we are missing some information on the nature of the response.
However, it seems to me that the second example better covers the general case. We abstract from any information coming from the aggregated service (which ignores the fact it is aggregated) and we decide what to do with the response, based on local logic (within the aggregator).
Following Balint's example, we can wrap the aggregated operation with a courier and define the format of the output there. I include below a minimal working example.
Aggregated service
type PersonRequestType: void {
.name: string
}
type PersonResponseType: void {
.name: string
.surname: string
}
interface MyAggregatedInterface {
RequestResponse: op1( PersonRequestType )( PersonResponseType ) throws RecordNotFound
}
inputPort IN {
Location: "local"
Interfaces: MyAggregatedInterface
}
execution { concurrent }
main
{
op1( request )( response ){
if( request.name == "Mario" ){
response.name = "Mario";
response.surname = "Mario"
} else {
throw ( RecordNotFound )
}
}
}
Aggregator service
include "aggregated.ol"
outputPort MyAggregatePort { Interfaces: MyAggregatedInterface }
embedded { Jolie: "aggregated.ol" in MyAggregatePort }
inputPort HttpPort {
Location: "socket://localhost:8000"
Protocol: http {
.format -> format
}
Aggregates: MyAggregatePort
}
courier HttpPort {
[ interface MyAggregatedInterface( request )( response ) ]{
forward( request )( response );
format = "json" // e.g., alternative xml
}
}
By changing the value set to format, e.g., from "json" to "xml", we change the format of the HTTP response.
References:
Courier sessions in the Jolie documentation
Reference introduction of couriers and detailed example of its semantics, Pre-print version, https://doi.org/10.1109/SOCA.2012.6449432