reply.hh

/*
 * This file is open source software, licensed to you under the terms
 * of the Apache License, Version 2.0 (the "License").  See the NOTICE file
 * distributed with this work for additional information regarding copyright
 * ownership.  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.
 */
/*
 * Copyright 2015 Cloudius Systems
 */
 
// This file was modified from boost http example
//
// reply.hpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma once
 
#ifndef SEASTAR_MODULE
#include <unordered_map>
#endif
#include <seastar/core/sstring.hh>
#include <seastar/http/mime_types.hh>
#include <seastar/core/iostream.hh>
#include <seastar/util/noncopyable_function.hh>
#include <seastar/util/modules.hh>
#include <seastar/util/string_utils.hh>
 
namespace seastar {
 
SEASTAR_MODULE_EXPORT_BEGIN
 
namespace httpd {
 
class connection;
class routes;
 
}
 
namespace http {
 
struct reply {
    enum class status_type {
        continue_ = 100, 
        switching_protocols = 101, 
        ok = 200, 
        created = 201, 
        accepted = 202, 
        nonauthoritative_information = 203, 
        no_content = 204, 
        reset_content = 205, 
        partial_content = 206, 
        multiple_choices = 300, 
        moved_permanently = 301, 
        moved_temporarily = 302, 
        see_other = 303, 
        not_modified = 304, 
        use_proxy = 305, 
        temporary_redirect = 307, 
        bad_request = 400, 
        unauthorized = 401, 
        payment_required = 402, 
        forbidden = 403, 
        not_found = 404, 
        method_not_allowed = 405, 
        not_acceptable = 406, 
        request_timeout = 408, 
        conflict = 409, 
        gone = 410, 
        length_required = 411, 
        payload_too_large = 413, 
        uri_too_long = 414, 
        unsupported_media_type = 415, 
        expectation_failed = 417, 
        unprocessable_entity = 422, 
        upgrade_required = 426, 
        too_many_requests = 429, 
        internal_server_error = 500, 
        not_implemented = 501, 
        bad_gateway = 502, 
        service_unavailable = 503,  
        gateway_timeout = 504, 
        http_version_not_supported = 505, 
        insufficient_storage = 507 
    } _status;
 
    std::unordered_map<sstring, sstring, seastar::internal::case_insensitive_hash, seastar::internal::case_insensitive_cmp> _headers;
 
    sstring _version;
    sstring _content;
    size_t content_length = 0; // valid when received via client connection
 
    sstring _response_line;
    std::unordered_map<sstring, sstring> trailing_headers;
    std::unordered_map<sstring, sstring> chunk_extensions;
 
    reply()
            : _status(status_type::ok) {
    }
 
    reply& add_header(const sstring& h, const sstring& value) {
        _headers[h] = value;
        return *this;
    }
 
    sstring get_header(const sstring& name) const {
        auto res = _headers.find(name);
        if (res == _headers.end()) {
            return "";
        }
        return res->second;
    }
 
    reply& set_version(const sstring& version) {
        _version = version;
        return *this;
    }
 
    reply& set_status(status_type status, sstring content = "") {
        _status = status;
        if (content != "") {
            _content = std::move(content);
        }
        return *this;
    }
 
    reply& set_mime_type(const sstring& mime) {
        _headers["Content-Type"] = mime;
        return *this;
    }
 
    reply& set_content_type(const sstring& content_type = "html") {
        set_mime_type(http::mime_types::extension_to_type(content_type));
        return *this;
    }
 
    reply& done(const sstring& content_type) {
        return set_content_type(content_type).done();
    }
    reply& done() {
        _response_line = response_line();
        return *this;
    }
    sstring response_line();
 
    void write_body(const sstring& content_type, noncopyable_function<future<>(output_stream<char>&&)>&& body_writer);
 
    void write_body(const sstring& content_type, sstring content);
 
private:
    future<> write_reply_to_connection(httpd::connection& con);
    future<> write_reply_headers(httpd::connection& connection);
 
    noncopyable_function<future<>(output_stream<char>&&)> _body_writer;
    friend class httpd::routes;
    friend class httpd::connection;
};
 
std::ostream& operator<<(std::ostream& os, reply::status_type st);
 
} // namespace http
 
namespace httpd {
using reply [[deprecated("Use http::reply instead")]] = http::reply;
}
 
SEASTAR_MODULE_EXPORT_END
}
 
#if FMT_VERSION >= 90000
template <> struct fmt::formatter<seastar::http::reply::status_type> : fmt::ostream_formatter {};
#endif