1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/**
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @file AsyncHttpFetch.h
*/
#pragma once
#include <string>
#include <memory>
#include "tscpp/api/Async.h"
#include "tscpp/api/Request.h"
#include "tscpp/api/Response.h"
namespace atscppapi
{
// forward declarations
struct AsyncHttpFetchState;
namespace utils
{
class internal;
}
/**
* @brief This class provides an implementation of AsyncProvider that
* makes HTTP requests asynchronously. This provider automatically
* self-destructs after the completion of the request.
*
* See example async_http_fetch{,_streaming} for sample usage.
*/
class AsyncHttpFetch : public AsyncProvider
{
public:
/** Deprecated. Use variant with streaming flag argument */
AsyncHttpFetch(const std::string &url_str, HttpMethod http_method = HTTP_METHOD_GET);
/** Deprecated. Use variant with streaming flag argument */
AsyncHttpFetch(const std::string &url_str, const std::string &request_body);
enum StreamingFlag {
STREAMING_DISABLED = 0,
STREAMING_ENABLED = 0x1,
};
AsyncHttpFetch(const std::string &url_str, StreamingFlag streaming_flag, HttpMethod http_method = HTTP_METHOD_GET);
AsyncHttpFetch(const std::string &url_str, StreamingFlag streaming_flag, const std::string &request_body);
/**
* Used to manipulate the headers of the request to be made.
*
* @return A reference to mutable headers.
*/
Headers &getRequestHeaders();
enum Result {
RESULT_SUCCESS = 10000,
RESULT_TIMEOUT,
RESULT_FAILURE,
RESULT_HEADER_COMPLETE,
RESULT_PARTIAL_BODY,
RESULT_BODY_COMPLETE
};
/**
* Used to extract the response after request completion. Without
* streaming, this can result success, failure or timeout. With
* streaming, this can result failure, timeout, header complete,
* partial body or body complete.
*
* @return Result of the operation
*/
Result getResult() const;
/**
* @return Non-mutable reference to the request URL.
*/
const Url &getRequestUrl() const;
/**
* @return Non-mutable reference to the request body.
*/
const std::string &getRequestBody() const;
/**
* Used to extract the response after request completion (after
* RESULT_HEADER_COMPLETE in case of streaming).
*
* @return Non-mutable reference to the response.
*/
const Response &getResponse() const;
/**
* Used to extract the body of the response after request completion. On
* unsuccessful completion, values (nullptr, 0) are set.
*
* When streaming is enabled, this can be called on either body result.
*
* @param body Output argument; will point to the body
* @param body_size Output argument; will contain the size of the body
*
*/
void getResponseBody(const void *&body, size_t &body_size) const;
/**
* Starts a HTTP fetch of the Request contained.
*/
void run() override;
protected:
~AsyncHttpFetch() override;
private:
AsyncHttpFetchState *state_;
void init(const std::string &url_str, HttpMethod http_method, const std::string &request_body, StreamingFlag streaming_flag);
friend class utils::internal;
};
} // namespace atscppapi
|
