RestClient.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  RestClient.qm Copyright (C) 2013 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// minimum qore version
 
// require type definitions everywhere
 
// enable all warnings
 
// don't use "$" for vars, members, and methods, assume local variable scope
 
 
 
 
 
 
}
 
/*  Version History - see below in docs
*/
 
namespace RestClient {
class RestClient : public Qore::HTTPClient {
 
public:
        const DataSerializationSupport = {
%ifndef NoJson
            "json": MimeTypeJson,
%endif
%ifndef NoYaml
            "yaml": MimeTypeYaml,
%endif
%ifndef NoXml
            "xml": MimeTypeXml,
            "rawxml": MimeTypeXmlApp,
%endif
            "url": MimeTypeFormUrlEncoded,
            "text": MimeTypeText,
            "bin": MimeTypeOctetStream,
        };
 
        const DeserializeYaml = {
            "code": "yaml",
            "in": \parse_yaml(),
        };
        const DeserializeXml = {
            "code": "xml",
            "arg": True,
            "in": hash<auto> sub (string xml, reference<string> type) {
                try {
                    on_success type = "xml";
                    return parse_xmlrpc_value(xml);
                } catch (hash<ExceptionInfo> ex) {
                    try {
                        on_success type = "rawxml";
                        return parse_xml(xml);
                    } catch () {
                        rethrow;
                    }
                }
            },
        };
 
        const AcceptList = ...;
 
 
        const Accept = AcceptList.join(",");
 
        const AcceptMap = map {$1: True}, AcceptList;
 
        const Version = "1.7";
 
        const VersionString = sprintf("Qore-RestClient/%s", RestClient::Version);
 
        const DefaultHeaders = {
            "Accept": Accept,
            "User-Agent": RestClient::VersionString,
        };
 
 
        const DataSerializationOptions = {
            "auto": True,
%ifndef NoJson
            "json": True,
%endif
%ifndef NoYaml
            "yaml": True,
%endif
%ifndef NoXml
            "rawxml": True,
            "xml": True,
%endif
            "url": True,
            "text": True,
            "bin": True,
        };
 
 
        const EncodingSupport = {
            "gzip": {
                "ce": "gzip",
                "func": \gzip(),
            },
            "bzip2": {
                "ce": "bzip2",
                "func": \bzip2(),
            },
            "deflate": {
                "ce": "deflate",
                "func": \compress(),
            },
            "identity": {
                "ce": NOTHING,
            },
        };
 
        const CompressionThreshold = 1024;
 
protected:
        // headers to send with every request
        hash<auto> headers;
        // data serialization code
        string ds;
        // serialization content type
        string sct;
        // send content encoding hash
        *hash<auto> seh;
        // REST schema validator
        RestSchemaValidator::AbstractRestSchemaValidator validator;
        // no_charset option
        *bool noCharset;
 
public:
 
 
    constructor(*hash<auto> opts, *softbool do_not_connect) : HTTPClient(opts + ((opts.url || !opts.validator)
            ? NOTHING
 ;
 
 
 
    clearConnectionPath();
 
 
 
    setSerialization(string data = 'auto');
 
 
 
    setSendEncoding(string enc = 'auto');
 
 
 
    setContentEncoding(string enc = 'auto');
 
 
 
    addDefaultHeaders(hash<auto> h);
 
 
 
    hash<auto> getDefaultHeaders();
 
 
 
    *string getSendEncoding();
 
 
 
    string getSerialization();
 
 
 
    hash<auto> get(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> put(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> patch(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> post(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    hash<auto> del(string path, auto body, *reference<hash<auto>> info, *hash<auto> hdr);
 
 
 
    RestSchemaValidator::AbstractRestSchemaValidator getValidator();
 
 
    private nothing prepareMsg(string method, string path, reference<auto> body, reference<hash<auto>> hdr,
            string ct = "Content-Type") {
        // use {} + ... here to ensure that hdr stays "hash<auto>"
        hdr = {} + headers + hdr;
 
        // must get the path from the HTTPClient object if not given in the request
        if (!path.val() && (*string p = getConnectionPath()))
            path = p;
 
        hash<RestRequestClientInfo> req = validator.processRequest(method, path, body, hdr, sct);
 
        if (exists body);
 
    }
 
protected:
     nothing preparePath(reference<string> path);
public:
 
 
 
    hash<auto> doRequest(string m, string path, auto body, *reference<hash<auto>> info, softbool decode_errors = True,
            *hash<auto> hdr) {
        prepareMsg(m, path, \body, \hdr);
 
        on_exit if (exists body);
 
 
        // prepare path
        preparePath(\path);
 
        on_error rethrow $1.err, sprintf("%s (REST URL %y)", $1.desc, getSafeURL());
 
        return sendAndDecodeResponse(body, m, path, hdr, \info, decode_errors);
    }
 
 
    hash<auto> doValidatedRequest(string m, string path, auto body, *reference<hash<auto>> info,
            softbool decode_errors = True, *hash<auto> hdr) {
        // use {} + ... here to ensure that hdr stays "hash<auto>"
        hdr = {} + headers + hdr;
 
        on_exit if (exists body);
 
 
        return sendAndDecodeResponse(body, m, path, hdr, \info, decode_errors);
    }
 
    private hash<auto> sendAndDecodeResponse(*data body, string m, string path, hash<auto> hdr,
            *reference<hash<auto>> info, *softbool decode_errors) {
        hash<auto> h;
        try {
            h = send(body, m, path, hdr, False, \info);
            info."response-code" = h.status_code;
        } catch (hash<ExceptionInfo> ex) {
            info."response-code" = info."response-headers".status_code;
            if (ex.arg) {
                if (decode_errors && ex.arg.body) {
                    decodeError(ex.arg, \info);
                    ex.arg.deserialized_body = info."response-body";
                }
            }
 
            rethrow ex.err, ex.desc, ex.arg;
        }
 
        on_error {
            if (exists h.body && !exists info."response-body") {
                info."response-body" = h.body;
            }
        }
 
        return processRestResponse(h, m, path, \info);
    }
 
 
protected:
     hash<auto> processRestResponse(hash<auto> resp, string method, string path, *reference<hash<auto>> info);
public:
 
 
protected:
      static decodeError(hash<auto> h, *reference<hash<auto>> info);
public:
 
 
private:
      static tryDecodeErrorResponse(reference<hash<auto>> h, *reference<hash<auto>> info);
public:
 
 
}; // class RestClient
 
 
class RestConnection : public ConnectionProvider::HttpBasedConnection {
 
public:
        hash<auto> real_opts;
 
        const ConnectionScheme = <ConnectionSchemeInfo>{
            "cls": Class::forName("RestConnection"),
            "options": HttpConnection::ConnectionScheme.options + {
                "content_encoding": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "this sets the send encoding (if the `send_encoding` option is not set) and the "
                        "response encoding to request",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "gzip",
                            "desc": "use GNU zip encoding ([RFC 1952](https://tools.ietf.org/html/rfc1952))",
                        }, <AllowedValueInfo>{
                            "value": "bzip2",
                            "desc": "use bzip2 encoding",
                        }, <AllowedValueInfo>{
                            "value": "deflate",
                            "desc": "use the deflate algorithm ([RFC 1951](https://tools.ietf.org/html/rfc1951))",
                        }, <AllowedValueInfo>{
                            "value": "identity",
                            "desc": "use no content encoding",
                        },
                    ),
                },
                "data": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "data serialization options",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "auto",
                            "desc": "prefers in this order: `json`, `yaml`, `rawxml`, `xml`, `url`, and `text`",
                        }, <AllowedValueInfo>{
                            "value": "bin",
                            "desc": "for binary message bodies without data serialization",
                        }, <AllowedValueInfo>{
                            "value": "json",
                            "desc": "use JSON serialization",
                        }, <AllowedValueInfo>{
                            "value": "rawxml",
                            "desc": "use raw XML serialization",
                        }, <AllowedValueInfo>{
                            "value": "text",
                            "desc": "use only plain text; no serialization is used",
                        }, <AllowedValueInfo>{
                            "value": "url",
                            "desc": "for URL-encoded message bodies",
                        }, <AllowedValueInfo>{
                            "value": "xml",
                            "desc": "use only XML-RPC serialization",
                        }, <AllowedValueInfo>{
                            "value": "yaml",
                            "desc": "use only YAML serialization",
                        },
                    ),
                    "default_value": "auto",
                },
                "headers": <ConnectionOptionInfo>{
                    "type": "hash",
                    "desc": "an optional hash of headers to send with every request, these can also be "
                        "overridden in request method calls",
                },
                "ping_method": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The HTTP method to use for an advanced ping; this and `ping_path` must be set to make an "
                        "HTTP request as a part of the socket polling ping operation; must be a valid HTTP method name",
                },
                "ping_path": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "The URI path to use for an advanced ping; this and `ping_method` must be made to make an "
                        "HTTP request as a part of the socket polling ping operation",
                },
                "ping_headers": <ConnectionOptionInfo>{
                    "type": "hash",
                    "desc": "Any HTTP headers to send when performing an advanced ping operation; ignored if either "
                        "one of `ping_method` and `ping_path` are not set",
                },
                "ping_body": <ConnectionOptionInfo>{
                    "type": "auto",
                    "desc": "Any message body to send when performing an advanced ping operation; ignored if either "
                        "one of `ping_method` and `ping_path` are not set or if `ping_method` is `GET`",
                },
                "send_encoding": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "this sets the send encoding",
                    "allowed_values": (
                        <AllowedValueInfo>{
                            "value": "gzip",
                            "desc": "use GNU zip encoding ([RFC 1952](https://tools.ietf.org/html/rfc1952))",
                        }, <AllowedValueInfo>{
                            "value": "bzip2",
                            "desc": "use bzip2 encoding",
                        }, <AllowedValueInfo>{
                            "value": "deflate",
                            "desc": "use the deflate algorithm ([RFC 1951](https://tools.ietf.org/html/rfc1951))",
                        }, <AllowedValueInfo>{
                            "value": "identity",
                            "desc": "use no content encoding",
                        },
                    ),
                },
                "swagger": <ConnectionOptionInfo>{
                    "type": "file-as-string",
                    "desc": "the location of a Swagger schema to use for message validation; processed with "
                        "`FileLocationHandler::getTextFileFromLocation()` "
                        "(ex: `file:///path/to/swagger-schema.json`); conflicts with `validator`",
                    "freeform": True,
                },
                "swagger_base_path": <ConnectionOptionInfo>{
                    "type": "string",
                    "desc": "in case a REST validator is used, the base path in the schema can be overridden "
                        "with this option (applies to any REST validator; not just Swagger validators)",
                },
                "validator": <ConnectionOptionInfo>{
                    "type": "any",
                    "desc": "an `AbstractRestSchemaValidator` object for REST message validation; conflicts with "
                        "`swagger`",
                },
            },
        };
 
        const Options = map {$1: True}, keys ConnectionScheme.options;
 
        const DefaultOptions = ...;
 
 
        const OptionList = keys ConnectionScheme.options;
 
 
    constructor(string name, string description, string url, hash<auto> attributes = {}, hash<auto> options = {})
 ;
 
 
 
protected:
     RestClient getImpl(bool connect = True, *hash<auto> rtopts);
public:
 
 
 
    object getPollImpl();
 
 
 
    hash<auto> getOptions();
 
 
    *hash<auto> getDefaultOptions();
 
 
    string getType();
 
 
 
    DataProvider::AbstractDataProvider getDataProvider();
 
 
 
    bool hasDataProvider();
 
 
 
    Qore::AbstractPollOperation startPollConnect();
 
 
 
      static hash<auto> processOptions(*hash<auto> opts);
 
 
protected:
     pingImpl();
public:
 
 
protected:
     setChildCapabilities();
public:
 
 
protected:
     hash<ConnectionSchemeInfo> getConnectionSchemeInfoImpl();
public:
 
};
 
 
class RestPingPollOperation : public Qore::AbstractPollOperation {
 
public:
protected:
        AbstractPollOperation poller;
 
        bool goal_reached = False;
 
        Mutex m();
 
public:
 
    constructor(AbstractPollOperation poller);
 
 
 
    string getGoal();
 
 
 
    string getState();
 
 
 
    bool goalReached();
 
 
    *hash<SocketPollInfo> continuePoll();
 
};
};