seastar.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 (C) 2015 Cloudius Systems, Ltd.
 */
 
#pragma once
 
 
#include <seastar/core/sstring.hh>
#include <seastar/core/future.hh>
#include <seastar/core/file-types.hh>
#include <seastar/core/posix.hh>
#include <seastar/util/bool_class.hh>
#include <seastar/util/std-compat.hh>
#include <seastar/util/modules.hh>
#include "./internal/api-level.hh"
#ifndef SEASTAR_MODULE
#include <cstdint>
#include <filesystem>
#include <optional>
#include <string_view>
#endif
 
namespace seastar {
 
SEASTAR_MODULE_EXPORT_BEGIN
 
// iostream.hh
template <class CharType> class input_stream;
template <class CharType> class output_stream;
 
class server_socket;
class socket;
class connected_socket;
class socket_address;
struct listen_options;
enum class transport;
 
// file.hh
class file;
struct file_open_options;
struct stat_data;
 
namespace net {
 
using udp_channel = class datagram_channel;
 
}
 
namespace experimental {
// process.hh
class process;
struct spawn_parameters;
}
 
// Networking API
 
 
 
server_socket listen(socket_address sa);
 
server_socket listen(socket_address sa, listen_options opts);
 
future<connected_socket> connect(socket_address sa);
 
future<connected_socket> connect(socket_address sa, socket_address local, transport proto);
 
 
socket make_socket();
 
[[deprecated("Use `make_unbound_datagram_channel` instead")]]
net::udp_channel make_udp_channel();
 
 
[[deprecated("Use `make_bound_datagram_channel` instead")]]
net::udp_channel make_udp_channel(const socket_address& local);
 
net::datagram_channel make_unbound_datagram_channel(sa_family_t family);
 
net::datagram_channel make_bound_datagram_channel(const socket_address& local);
 
 
 
 
future<file> open_file_dma(std::string_view name, open_flags flags) noexcept;
 
future<file> open_file_dma(std::string_view name, open_flags flags, file_open_options options) noexcept;
 
future<> check_direct_io_support(std::string_view path) noexcept;
 
future<file> open_directory(std::string_view name) noexcept;
 
future<> make_directory(std::string_view name, file_permissions permissions = file_permissions::default_dir_permissions) noexcept;
 
future<> touch_directory(std::string_view name, file_permissions permissions = file_permissions::default_dir_permissions) noexcept;
 
future<> recursive_touch_directory(std::string_view name, file_permissions permissions = file_permissions::default_dir_permissions) noexcept;
 
future<> sync_directory(std::string_view name) noexcept;
 
 
future<> remove_file(std::string_view name) noexcept;
 
future<> rename_file(std::string_view old_name, std::string_view new_name) noexcept;
 
struct follow_symlink_tag { };
using follow_symlink = bool_class<follow_symlink_tag>;
 
future<stat_data> file_stat(std::string_view name, follow_symlink fs = follow_symlink::yes) noexcept;
 
future<uint64_t> file_size(std::string_view name) noexcept;
 
future<bool> file_accessible(std::string_view name, access_flags flags) noexcept;
 
future<bool> file_exists(std::string_view name) noexcept;
 
future<std::optional<directory_entry_type>> file_type(std::string_view name, follow_symlink follow = follow_symlink::yes) noexcept;
 
 
future<> link_file(std::string_view oldpath, std::string_view newpath) noexcept;
 
future<> chmod(std::string_view name, file_permissions permissions) noexcept;
 
future<fs_type> file_system_at(std::string_view name) noexcept;
 
future<uint64_t> fs_avail(std::string_view name) noexcept;
 
future<uint64_t> fs_free(std::string_view name) noexcept;
 
namespace experimental {
 
 
future<std::tuple<file_desc, file_desc>> make_pipe();
 
future<process> spawn_process(const std::filesystem::path& pathname,
                              spawn_parameters params);
future<process> spawn_process(const std::filesystem::path& pathname);
}
 
SEASTAR_MODULE_EXPORT_END
 
}