HTTP

HTTP Protocol

HTTP (Hypertext Transfer Protocol) is an application protocol for distributed, collaborative, hypermedia information systems.

Protocol name in Jolie port definition: http.

HTTP Parameters

type HttpConfiguration:void {
    /* General *//*
     * Defines whether the underlying connection should be kept open.
     * Remote webservers could have been configured to automatically close
     * client connections after each request and without consideration of
     * eventual "Connection: close" HTTP headers. If a Jolie client performs
     * more than one request, the "keepAlive" parameter needs to be
     * changed to "false", otherwise the client fails with:
     * "jolie.net.ChannelClosingException: [http] Remote host closed
     * connection."
     *
     * Default: true
     */
    .keepAlive?:bool/*
     * Defines the status code of the HTTP message.
     * The parameter gets set on inbound requests and is read out on outbound
     *  requests.
     * Attention: for inbound requests the assigned variable needs to be
     * defined before
     * issuing the first request, otherwise it does not get set (e.g.,.
     * statusCode = 0)
     *
     * e.g.,
     * .statusCode -> statusCode
     *
     * Default: 200
     * Supported Values: any HTTP status codes
     */
    .statusCode?:string/*
     * Defines whether debug messages shall be 
     * activated
     *
     * Default: false
     */
    .debug?:bool {
        /*
         * Shows the message content
         *
         * Default: false
         */
        .showContent?:bool
    }
​
    /*
     * Defines whether the requests handled by the service
     * are thread-safe or not.
     * 
     * Default: 
     *    send     -> true
     *    receive -> false
     */
    .concurrent?: bool/*
     * Enable content compression in HTTP.
     * On client side the "Accept-Encoding" header is set to "gzip, deflate"
     * or according to "requestCompression". On the server the compression is
     * enabled using gzip or deflate as the client requested it. gzip is
     * preferred over deflate since it is more common.
     * If the ne.g.,otiation was successful, the server returns the compressed
     * data with a "Content-Encoding" header and an updated "Content-Length"
     * field.
     *
     * Default: true
     */
    .compression?:bool/*
     * Set the allowed mimetypes (content types) for compression.
     * This flag operates server-side only and is unset per default, which
     * means that common plain-text formats get compressed (among them
     * text/html text/css text/plain text/xml text/x-js text/x-gwt-rpc 
     * application/json application/javascript application/x-www-form-urlencoded
     * application/xhtml+xml application/xml).
     * The delimitation character should be different to the mimetype names,
     * valid choices include blank, comma or semicolon.
     *
     * "*" means compression for everything including binary formats, which is
     * usually not the best choice. Many formats come pre-compressed, like
     * archives, images or videos.
     *
     * Other webservers (Apache Tomcat, Apache HTTP mod_deflate) contain
     * similar filter variables.
     *
     * Default: common plain-text formats
     */
    .compressionTypes?:string/*
     * Enables the HTTP request compression feature.
     * HTTP 1.1 per RFC 2616 defines optional compression also on POST
     * requests, which works unless HTTP errors are returned, for instance 415
     * Unsupported Media Type.
     * Jolie allows to set the parameter to "gzip" or "deflate" which
     * overrides also the "Accept-Encoding" header. This invites the server to
     * use the same algorithm for the response compression.
     * Invalid values are ignored, the compression mimetypes are enforced.
     * If all conditions are met, the request content gets compressed, an
     * additional "Content-Encoding" header added and the "Content-Length"
     * header recalculated.
     *
     * Default: none/off
     */
    .requestCompression?:string/* Outbound *//*
     * Defines the HTTP response (outbound) message format.
     * Supported values: xml, html, x-www-form-urlencoded, json,
     * text/x-gwt-rpc, multipart/form-data, binary (data transfer in raw
     * representation - no conversion), raw (data transfer in string
     * representation with character set enforcement).
     * It might be necessary to override the format with the correct content
     * type, especially for "binary" and "raw" as shown below.
     *
     * Default: xml
     */
    .format?:string/*
     * Defines the content type of the HTTP message.
     * These are the default content types for each kind of format, override
     * if necessary:
     * xml                   : text/xml
     * html                  : text/html
     * x-www-form-urlencoded : application/x-www-form-urlencoded
     * json                  : application/json
     * text/x-gwt-rpc        : text/x-gwt-rpc
     * multipart/form-data   : multipart/form-data
     * binary                : application/octet-stream
     * raw                   : text/plain
     *
     * Default: none
     */
    .contentType?:string/*
     * Defines the HTTP response (outbound) message character encoding 
     * Supported values: "US-ASCII", "ISO-8859-1", 
     * "UTF-8", "UTF-16"... (all possible Java charsets)
     *
     * Default: "UTF-8"
     */
    .charset?:string/*
     * Set additional headers on HTTP requests
     *
     * Default: none
     */
    .addHeader?:void {
        /*
         * "header" contains the actual headers with their values
         * ("value") as children.
         *
         * e.g.,. for HTTP header "Authorization: TOP_SECRET": 
         * .addHeader.header[0] << "Authorization" { .value="TOP_SECRET" }
         * Default: none 
         */
         .header*:string { .value:string } }

         /*
         * Defines the request method *
         * Default: "POST"
         * Supported values: "GET", "POST" 
         */
         .method?:string {

            /*
            * "queryFormat" on a GET request may be set to "json" to have the 
            * parameters passed as JSON 
            * Default: none 
            */
            .queryFormat?:string }

            /*
            * Defines a set of operation-specific aliases, 
            * multi-part headers, and parameters. 
            * Default: none 
            */
            .osc?:void {

                /*
                * Jolie operation name(s) 
                * e.g.,. .osc.fetchBib.alias="rec/bib2/%!{dblpKey}.bib" for operation 
                * fetchBib()() which listens on "rec/bib2/%!{dblpKey}.bib" 
                * e.g.,. .osc.default.alias="" for method default()() which listens on "/" 
                * Default: none 
                */
                .operationName*:void {

                    /*
                    * Defines a HTTP alias which represents 
                    * an alternative name to the location of 
                    * "operationName" 
                    * Default: none 
                    * Supported values: URL address, string raw 
                    */
                    .alias*: string

                    /*
                    * Defines the elements composing a multi-part 
                    * request for a specific operation. 
                    * Default: none
                    */
                    .multipartHeaders?:void {

                        /*
                        * Defines the name of the part of 
                        * the multi-part request 
                        * Default: none 
                        */
                        .partName*:void { 

                        /*
                        * Defines the name of the file 
                        * corresponding to a specific part 
                        * Default: none 
                        */
                        .filename?:string 

                    } 
                } 
            } 
        }

     /* 
     * HTTP request paths are usually composed by the medium's URI path 
     * as prefix and the resource name (or eventual aliases) as suffix. 
     * This works perfectly on IP sockets (medium "socket"), but is not 
     * desirable on other media like the UNIX domain sockets ("localsocket"). 
     * Examples:
     *  - location: "socket://localhost:8000/x/", resource "sum" -> "/x/sum"
     *  - location: "localsocket://abs/s", resource "sum" -> "/ssum". "s"
     *    is just the file name of the UNIX domain socket and has no meaning
     *    in HTTP. With .dropURIPath = true the path component "s" is dropped
     *    and the result becomes "/sum".
     *
     */ Default: false
    .dropURIPath?:bool/*
     * Defines the cache-control header of the HTTP message.
     */
    .cacheControl?:void {
        /*
         * Maximum age for which the resource should be cached (in seconds)
         */
        .maxAge?:int
    }
​
    /*
     * Defines the Content-Transfer-Encoding value of the HTTP message.
     *
     * Default: none
     */
    .contentTransferEncoding?:string/*
     * Defines the Content-Disposition value of the HTTP message.
     *
     * Default: none
     */
    .contentDisposition?:string/* Inbound *//*
     * Specifies the default HTTP handler method(s) on a server
     * This is required for CRUD applications but also used in Leonardo which sets
     * it to default()() (.default = "default").
     *
     * Default: none
     */
    .default?:string {
        /*
         * Handler for specific HTTP request methods, e.g.,.
         * .default.get = "get";
         * .default.put = "put";
         * .default.delete = "delete"
         *
         * Default: none
         */
        .get?:string
        .post?:string
        .head?:string
        .put?:string
        .delete?:string
    }
​
    /*
     * If set to "strict", applies a more strict JSON array to Jolie value
     * mapping schema when the JSON format is used.
     *
     * Default: none
     */
    .json_encoding?:string/*
     * Defines the observed headers of a HTTP message.
     *
     * Default: none
     */
    .headers?:void {

        /*
         *  should be substituted with the actual header
         * names ("_" to decode "-", e.g.,. "content_type" for "content-type")
         * and the value constitutes the request variable's attribute where
         * the content will be assigned to.
         * Important: these attributes have to be part of the service's
         * input port interface, unless "undefined" is used.
         *
         * e.g.,. in the deployment:
         * .headers.server = "server"
         * .headers.content_type = "contentType";
         *
         * in the behaviour, "req" is the inbound request variable:
         * println@Console( "Server: " + req.server )();
         * if ( req.contentType == "application/json" ) { ...
         *
         * Default: none
         */
        .*: string
    }
​
    /*
    * Defines the redirecting location subsequent to
    * a Redirection 3xx status code
    *
    * Default: none
    */
    .redirect?:string/*
    * Defines a set of cookies used in the http communication
    *
    * Default: none
    */
    .cookies?:void {
        /*
        * Defines a cookie named
        * "cookieName"
        * Default: none
        */
        .cookieName*:void {

            /*
            * Defines the configuration of a cookie
            * 
            * Default: none
            */
            .cookieConfig?:string{

                /*
                * Defines the domain of the cookie
                *
                * Default: ""
                */
                .domain?:string

                /*
                * Defines the expiration time of the cookie
                *
                * Default: ""
                */
                .expires?:string

                /*
                * Defines the "path" value of the cookie
                *
                * Default: ""
                */
                .path?:string{}

                /*
                * Defines whether the cookie shall be encrypted 
                * and sent via HTTPS
                *
                * Default: 0
                */
                .secure?:int{}

                /*
                * Defines the type of the cookie
                * 
                * Default: string
                */
                .type?:string
            }
        }
​
    }
​
    /*
     * Overrides the HTTP User-Agent header value on incoming HTTP messages
     *
     * e.g.,.
     * .userAgent -> userAgent
     *
     * Default: none
     */
    .userAgent?:string/*
     * Overrides the HTTP host header on incoming HTTP messages
     *
     * e.g.,.
     * .host -> host
     *
     * Default: none
     */
    .host?:string
}

results matching ""

    No results matching ""