ceph/src/seastar/include/seastar/http/reply.hh

   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 }