]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
1 | /* |
2 | * This file is open source software, licensed to you under the terms | |
3 | * of the Apache License, Version 2.0 (the "License"). See the NOTICE file | |
4 | * distributed with this work for additional information regarding copyright | |
5 | * ownership. You may not use this file except in compliance with the License. | |
6 | * | |
7 | * You may obtain a copy of the License at | |
8 | * | |
9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
10 | * | |
11 | * Unless required by applicable law or agreed to in writing, | |
12 | * software distributed under the License is distributed on an | |
13 | * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
14 | * KIND, either express or implied. See the License for the | |
15 | * specific language governing permissions and limitations | |
16 | * under the License. | |
17 | */ | |
18 | /* | |
19 | * Copyright 2015 Cloudius Systems | |
20 | */ | |
21 | ||
22 | // This file was modified from boost http example | |
23 | // | |
24 | // reply.hpp | |
25 | // ~~~~~~~~~ | |
26 | // | |
27 | // Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com) | |
28 | // | |
29 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
30 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
31 | // | |
32 | #pragma once | |
33 | ||
34 | #include <seastar/core/sstring.hh> | |
35 | #include <unordered_map> | |
36 | #include <seastar/http/mime_types.hh> | |
37 | #include <seastar/core/future-util.hh> | |
38 | #include <seastar/core/iostream.hh> | |
39 | #include <seastar/util/noncopyable_function.hh> | |
40 | ||
41 | namespace seastar { | |
42 | ||
43 | namespace httpd { | |
44 | ||
45 | class connection; | |
46 | class routes; | |
47 | ||
48 | /** | |
49 | * A reply to be sent to a client. | |
50 | */ | |
51 | struct reply { | |
52 | /** | |
53 | * The status of the reply. | |
54 | */ | |
55 | enum class status_type { | |
56 | ok = 200, //!< ok | |
57 | created = 201, //!< created | |
58 | accepted = 202, //!< accepted | |
59 | no_content = 204, //!< no_content | |
60 | multiple_choices = 300, //!< multiple_choices | |
61 | moved_permanently = 301, //!< moved_permanently | |
62 | moved_temporarily = 302, //!< moved_temporarily | |
63 | not_modified = 304, //!< not_modified | |
64 | bad_request = 400, //!< bad_request | |
65 | unauthorized = 401, //!< unauthorized | |
66 | forbidden = 403, //!< forbidden | |
67 | not_found = 404, //!< not_found | |
68 | internal_server_error = 500, //!< internal_server_error | |
69 | not_implemented = 501, //!< not_implemented | |
70 | bad_gateway = 502, //!< bad_gateway | |
71 | service_unavailable = 503 //!< service_unavailable | |
72 | } _status; | |
73 | ||
74 | /** | |
75 | * The headers to be included in the reply. | |
76 | */ | |
77 | std::unordered_map<sstring, sstring> _headers; | |
78 | ||
79 | sstring _version; | |
80 | /** | |
81 | * The content to be sent in the reply. | |
82 | */ | |
83 | sstring _content; | |
84 | ||
85 | sstring _response_line; | |
86 | reply() | |
87 | : _status(status_type::ok) { | |
88 | } | |
89 | ||
90 | reply& add_header(const sstring& h, const sstring& value) { | |
91 | _headers[h] = value; | |
92 | return *this; | |
93 | } | |
94 | ||
95 | reply& set_version(const sstring& version) { | |
96 | _version = version; | |
97 | return *this; | |
98 | } | |
99 | ||
100 | reply& set_status(status_type status, const sstring& content = "") { | |
101 | _status = status; | |
102 | if (content != "") { | |
103 | _content = content; | |
104 | } | |
105 | return *this; | |
106 | } | |
107 | ||
108 | /** | |
109 | * Set the content type mime type. | |
110 | * Used when the mime type is known. | |
111 | * For most cases, use the set_content_type | |
112 | */ | |
113 | reply& set_mime_type(const sstring& mime) { | |
114 | _headers["Content-Type"] = mime; | |
115 | return *this; | |
116 | } | |
117 | ||
118 | /** | |
119 | * Set the content type mime type according to the file extension | |
120 | * that would have been used if it was a file: e.g. html, txt, json etc' | |
121 | */ | |
122 | reply& set_content_type(const sstring& content_type = "html") { | |
123 | set_mime_type(httpd::mime_types::extension_to_type(content_type)); | |
124 | return *this; | |
125 | } | |
126 | ||
127 | reply& done(const sstring& content_type) { | |
128 | return set_content_type(content_type).done(); | |
129 | } | |
130 | /** | |
131 | * Done should be called before using the reply. | |
132 | * It would set the response line | |
133 | */ | |
134 | reply& done() { | |
135 | _response_line = response_line(); | |
136 | return *this; | |
137 | } | |
138 | sstring response_line(); | |
139 | ||
140 | /*! | |
141 | * \brief use an output stream to write the message body | |
142 | * | |
143 | * When a handler needs to use an output stream it should call this method | |
144 | * with a function. | |
145 | * | |
146 | * \param content_type - is used to choose the content type of the body. Use the file extension | |
147 | * you would have used for such a content, (i.e. "txt", "html", "json", etc') | |
148 | * \param body_writer - a function that accept an output stream and use that stream to write the body. | |
149 | * The function should take ownership of the stream while using it and must close the stream when it | |
150 | * is done. | |
151 | * | |
152 | * Message would use chunked transfer encoding in the reply. | |
153 | * | |
154 | */ | |
155 | ||
156 | void write_body(const sstring& content_type, noncopyable_function<future<>(output_stream<char>&&)>&& body_writer); | |
157 | ||
158 | /*! | |
159 | * \brief Write a string as the reply | |
160 | * | |
161 | * \param content_type - is used to choose the content type of the body. Use the file extension | |
162 | * you would have used for such a content, (i.e. "txt", "html", "json", etc') | |
163 | * \param content - the message content. | |
164 | * This would set the the content and content type of the message along | |
165 | * with any additional information that is needed to send the message. | |
166 | */ | |
167 | void write_body(const sstring& content_type, const sstring& content); | |
168 | ||
169 | private: | |
170 | future<> write_reply_to_connection(connection& con); | |
171 | future<> write_reply_headers(connection& connection); | |
172 | ||
173 | noncopyable_function<future<>(output_stream<char>&&)> _body_writer; | |
174 | friend class routes; | |
175 | friend class connection; | |
176 | }; | |
177 | ||
178 | } // namespace httpd | |
179 | ||
180 | } |