Seastar
High performance C++ framework for concurrent servers
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
seastar Namespace Reference

Detailed Description

Seastar API namespace.

Namespaces

 alien
 Integration with non-seastar applications.
 
 log_cli
 Configure application logging at run-time with program options.
 
 memory
 
 metrics
 metrics creation and registration
 
 net
 
 scollectd
 
 tls
 

Classes

class  abort_requested_exception
 
class  abort_source
 
struct  accept_result
 The result of an server_socket::accept() call. More...
 
class  adder
 
class  app_template
 
struct  apply_helper
 
struct  apply_helper< Func, Tuple, std::index_sequence< I... > >
 
class  array_map
 
class  async_sharded_service
 
class  basic_rwlock
 
class  basic_semaphore
 Counted resource guard. More...
 
class  basic_sstring
 
class  bool_class
 Type-safe boolean. More...
 
class  broken_condition_variable
 
class  broken_pipe_exception
 
struct  broken_promise
 Exception type for broken promises. More...
 
class  broken_semaphore
 
class  checked_ptr
 seastar::checked_ptr class is a wrapper class that may be used with any pointer type (smart like std::unique_ptr or raw pointers like int*). More...
 
class  checked_ptr_is_null_exception
 The exception thrown by a default_null_deref_action. More...
 
class  chunked_fifo
 
class  circular_buffer
 
class  circular_buffer_fixed_capacity
 
class  concrete_execution_stage
 Concrete execution stage class. More...
 
class  condition_variable
 Conditional variable. More...
 
class  condition_variable_timed_out
 
class  connected_socket
 
class  consumption_result
 
struct  continue_consuming
 
struct  cpuset_bpo_wrapper
 
class  data_sink
 
class  data_sink_impl
 
class  data_source
 
class  data_source_impl
 
struct  default_null_deref_action
 Default not engaged seastar::checked_ptr dereferencing action (functor). More...
 
struct  default_timeout_exception_factory
 
class  deferred_action
 
class  deleter
 
struct  directory_entry
 A directory entry being listed. More...
 
struct  dummy_expiry
 
class  enable_lw_shared_from_this
 
class  enable_shared_from_this
 
class  enum_hash
 
struct  exception_future_marker
 
class  execution_stage
 Base execution stage class. More...
 
class  expiring_fifo
 
class  fair_queue
 Fair queuing class. More...
 
struct  fair_queue_request_descriptor
 describes a request that passes through the fair queue More...
 
class  file
 
class  file_desc
 
class  file_handle
 A shard-transportable handle to a file. More...
 
class  file_input_stream_history
 
struct  file_input_stream_options
 Data structure describing options for opening a file input stream. More...
 
struct  file_open_options
 
struct  file_output_stream_options
 
class  foreign_ptr
 
class  fragmented_memory_input_stream
 
class  fragmented_memory_output_stream
 
struct  frame
 
struct  free_deleter
 
struct  function_input_iterator
 
struct  function_traits
 
struct  function_traits< Ret(*)(Args...)>
 
struct  function_traits< Ret(Args...)>
 
struct  function_traits< Ret(T::*)(Args...) const >
 
struct  function_traits< Ret(T::*)(Args...)>
 
struct  function_traits< T & >
 
class  future
 A representation of a possibly not-yet-computed value. More...
 
struct  future_for_get_promise_marker
 
struct  future_state_base
 
struct  futurize
 Converts a type to a future type, if it isn't already. More...
 
class  gate
 
class  gate_closed_exception
 
struct  indirect_equal_to
 
struct  indirect_hash
 
struct  indirect_less
 
class  inheriting_concrete_execution_stage
 Concrete execution stage class, with support for automatic scheduling_group inheritance. More...
 
class  input_stream
 
class  io_queue
 
struct  ipv4_addr
 
struct  ipv6_addr
 
struct  is_future
 Check whether a type is a future. More...
 
struct  is_smart_ptr
 
struct  is_smart_ptr< foreign_ptr< T > >
 
struct  is_smart_ptr< lw_shared_ptr< T > >
 
struct  is_smart_ptr< shared_ptr< T > >
 
struct  is_smart_ptr< std::unique_ptr< T > >
 
class  lambda_task
 
struct  lazy_deref_wrapper
 This struct is a wrapper for lazy dereferencing a pointer. More...
 
class  lazy_eval
 This class is a wrapper for a lazy evaluation of a value. More...
 
struct  listen_options
 
class  logger
 Logger class for stdout or syslog. More...
 
class  logger_registry
 used to keep a static registry of loggers since the typical use case is to do: More...
 
struct  logging_settings
 
class  lowres_clock
 Low-resolution and efficient steady clock. More...
 
class  lowres_system_clock
 Low-resolution and efficient system clock. More...
 
class  lw_shared_ptr
 
struct  lw_shared_ptr_counter_base
 
struct  lw_shared_ptr_deleter
 
class  manual_clock
 
class  measuring_output_stream
 
class  memory_input_stream
 
class  memory_output_stream
 
struct  mmap_deleter
 
class  network_stack
 
class  no_sharded_instance_exception
 Exception thrown when a sharded object does not exist. More...
 
class  noncopyable_function
 
class  noncopyable_function< Ret(Args...)>
 
class  optimized_optional
 
class  output_stream
 
class  peering_sharded_service
 Provide a sharded service with access to its peers. More...
 
class  pipe
 A fixed-size pipe for communicating between two fibers. More...
 
class  pipe_reader
 Read side of a seastar::pipe. More...
 
class  pipe_writer
 Write side of a seastar::pipe. More...
 
class  pollable_fd
 
class  pollable_fd_state
 
class  posix_thread
 
struct  prefetcher
 
struct  prefetcher< 0, RW, LOC >
 
class  promise
 promise - allows a future value to be made available at a later time. More...
 
class  promise< void >
 Specialization of promise<void> More...
 
struct  promise_expiry
 
class  queue
 
class  ragel_parser_base
 
class  reactor
 
struct  reactor_config
 
class  readable_eventfd
 
struct  ready_future_marker
 
struct  reducer_traits
 
struct  reducer_traits< T, decltype(std::declval< T >().get(), void())>
 
struct  reducer_with_get_traits
 
struct  reducer_with_get_traits< T, false >
 
struct  reducer_with_get_traits< T, true >
 
class  reference_wrapper
 
struct  repeat_until_value_type_helper< future< compat::optional< T > > >
 Type helper for repeat_until_value() More...
 
class  saved_backtrace
 
class  scattered_message
 
class  scheduling_group
 Identifies function calls that are accounted as a group. More...
 
struct  semaphore_default_exception_factory
 
class  semaphore_timed_out
 
class  semaphore_units
 
class  sharded
 
class  shared_future
 Like future except the result can be waited for by many fibers. More...
 
class  shared_mutex
 Shared/exclusive mutual exclusion. More...
 
struct  shared_object
 
class  shared_promise
 Like promise except that its counterpart is shared_future instead of future. More...
 
class  shared_ptr
 
struct  shared_ptr_count_base
 
struct  shared_ptr_count_for
 
struct  shared_ptr_make_helper
 
struct  shared_ptr_make_helper< T, false >
 
struct  shared_ptr_make_helper< T, true >
 
struct  shared_ptr_no_esft
 
class  simple_memory_input_stream
 
class  simple_memory_output_stream
 
class  skip_bytes
 
class  slab_allocator
 
class  slab_class
 
class  slab_item_base
 
struct  slab_page_desc
 
class  sleep_aborted
 exception that is thrown when application is in process of been stopped More...
 
class  smp
 
class  smp_message_queue
 
class  smp_service_group
 
struct  smp_service_group_config
 
class  socket
 
class  socket_address
 
union  socket_address.u
 
class  sstring_builder
 
struct  stat_data
 Filesystem object stat information. More...
 
class  stop_consuming
 
struct  stop_iteration_tag
 
class  stream
 
class  subscription
 
class  task
 
class  temporary_buffer
 
class  thread
 thread - stateful thread of execution More...
 
class  thread_attributes
 Class that holds attributes controling the behavior of a thread. More...
 
class  thread_cputime_clock
 
class  timed_out_error
 
class  timer
 
class  timer_set
 
class  transform_iterator
 
struct  tuple_map_types
 
struct  tuple_map_types< MapClass, std::tuple< Elements... > >
 
struct  unaligned
 
class  unread_overflow_exception
 
struct  usecfmt_wrapper
 
class  vector_data_sink
 
class  weak_ptr
 
class  weakly_referencable
 
struct  with_clock
 Changes the clock used by shared_future<> and shared_promise<> when passed as the first template parameter. More...
 
class  writeable_eventfd
 

Typedefs

template<typename Service >
using distributed = sharded< Service >
 
using stop_iteration = bool_class< stop_iteration_tag >
 
template<typename AsyncAction >
using repeat_until_value_return_type = typename repeat_until_value_type_helper< std::result_of_t< AsyncAction()> >::future_type
 Return value of repeat_until_value()
 
template<typename T >
using futurize_t = typename futurize< T >::type
 
using shard_id = unsigned
 
using mmap_area = std::unique_ptr< char[], mmap_deleter >
 
using rwlock = basic_rwlock<>
 
using follow_symlink = bool_class< follow_symlink_tag >
 
using semaphore = basic_semaphore< semaphore_default_exception_factory >
 
using shared_ptr_counter_type = long
 
template<typename T >
using shared_ptr_equal_by_value = indirect_equal_to< shared_ptr< T > >
 
template<typename T >
using shared_ptr_value_hash = indirect_hash< shared_ptr< T > >
 
using simple_input_stream = simple_memory_input_stream
 
using simple_output_stream = simple_memory_output_stream
 
using sstring = basic_sstring< char, uint32_t, 15 >
 
using steady_clock_type = std::chrono::steady_clock
 
using rss_key_type = compat::basic_string_view< uint8_t >
 

Enumerations

enum  open_flags {
  rw = O_RDWR, ro = O_RDONLY, wo = O_WRONLY, create = O_CREAT,
  truncate = O_TRUNC, exclusive = O_EXCL, dsync = O_DSYNC
}
 
enum  directory_entry_type {
  unknown, block_device, char_device, directory,
  fifo, link, regular, socket
}
 
enum  fs_type {
  other, xfs, ext2, ext3,
  ext4, btrfs, hfs, tmpfs
}
 Enumeration describing the type of a particular filesystem.
 
enum  access_flags {
  exists = F_OK, read = R_OK, write = W_OK, execute = X_OK,
  lookup = execute
}
 
enum  file_permissions {
  user_read = S_IRUSR, user_write = S_IWUSR, user_execute = S_IXUSR, group_read = S_IRGRP,
  group_write = S_IWGRP, group_execute = S_IXGRP, others_read = S_IROTH, others_write = S_IWOTH,
  others_execute = S_IXOTH, user_permissions = user_read | user_write | user_execute, group_permissions = group_read | group_write | group_execute, others_permissions = others_read | others_write | others_execute,
  all_permissions = user_permissions | group_permissions | others_permissions, default_file_permissions = user_read | user_write | group_read | group_write | others_read | others_write, default_dir_permissions = all_permissions
}
 
enum  transport { TCP = IPPROTO_TCP, SCTP = IPPROTO_SCTP }
 
enum  log_level {
  error, warn, info, debug,
  trace
}
 log level used with More...
 
enum  logger_timestamp_style { none, boot, real }
 

Functions

void set_abort_on_ebadf (bool do_abort)
 
bool is_abort_on_ebadf_enabled ()
 
template<typename T >
constexpr T align_up (T v, T align)
 
template<typename T >
constexpr T * align_up (T *v, size_t align)
 
template<typename T >
constexpr T align_down (T v, T align)
 
template<typename T >
constexpr T * align_down (T *v, size_t align)
 
template<typename CharType >
std::unique_ptr< CharType[], free_deleterallocate_aligned_buffer (size_t size, size_t align)
 
template<typename Func , typename... T>
auto apply (Func &&func, std::tuple< T... > &&args)
 
template<typename Func , typename... T>
auto apply (Func &&func, std::tuple< T... > &args)
 
template<typename Func , typename... T>
auto apply (Func &&func, const std::tuple< T... > &args)
 
constexpr unsigned count_leading_zeros (unsigned x)
 
constexpr unsigned count_leading_zeros (unsigned long x)
 
constexpr unsigned count_leading_zeros (unsigned long long x)
 
constexpr unsigned count_trailing_zeros (unsigned x)
 
constexpr unsigned count_trailing_zeros (unsigned long x)
 
constexpr unsigned count_trailing_zeros (unsigned long long x)
 
template<typename T >
constexpr unsigned log2ceil (T n)
 
template<typename T >
constexpr unsigned log2floor (T n)
 
uint8_t cpu_to_le (uint8_t x)
 
uint8_t le_to_cpu (uint8_t x)
 
uint16_t cpu_to_le (uint16_t x)
 
uint16_t le_to_cpu (uint16_t x)
 
uint32_t cpu_to_le (uint32_t x)
 
uint32_t le_to_cpu (uint32_t x)
 
uint64_t cpu_to_le (uint64_t x)
 
uint64_t le_to_cpu (uint64_t x)
 
int8_t cpu_to_le (int8_t x)
 
int8_t le_to_cpu (int8_t x)
 
int16_t cpu_to_le (int16_t x)
 
int16_t le_to_cpu (int16_t x)
 
int32_t cpu_to_le (int32_t x)
 
int32_t le_to_cpu (int32_t x)
 
int64_t cpu_to_le (int64_t x)
 
int64_t le_to_cpu (int64_t x)
 
uint8_t cpu_to_be (uint8_t x)
 
uint8_t be_to_cpu (uint8_t x)
 
uint16_t cpu_to_be (uint16_t x)
 
uint16_t be_to_cpu (uint16_t x)
 
uint32_t cpu_to_be (uint32_t x)
 
uint32_t be_to_cpu (uint32_t x)
 
uint64_t cpu_to_be (uint64_t x)
 
uint64_t be_to_cpu (uint64_t x)
 
int8_t cpu_to_be (int8_t x)
 
int8_t be_to_cpu (int8_t x)
 
int16_t cpu_to_be (int16_t x)
 
int16_t be_to_cpu (int16_t x)
 
int32_t cpu_to_be (int32_t x)
 
int32_t be_to_cpu (int32_t x)
 
int64_t cpu_to_be (int64_t x)
 
int64_t be_to_cpu (int64_t x)
 
template<typename T >
cpu_to_le (const unaligned< T > &v)
 
template<typename T >
le_to_cpu (const unaligned< T > &v)
 
template<typename T >
read_le (const char *p)
 
template<typename T >
void write_le (char *p, T datum)
 
template<typename T >
read_be (const char *p)
 
template<typename T >
void write_be (char *p, T datum)
 
template<typename T >
consume_be (const char *&p)
 
template<typename T >
void produce_be (char *&p, T datum)
 
template<typename... T>
auto operator co_await (future< T... > f) noexcept
 
template<typename T , typename F >
auto do_with (T &&rvalue, F &&f)
 
template<typename Lock , typename Func >
auto with_lock (Lock &lock, Func &&func)
 
template<typename T1 , typename T2 , typename T3_or_F , typename... More>
auto do_with (T1 &&rv1, T2 &&rv2, T3_or_F &&rv3, More &&... more)
 
void init_phdr_cache ()
 
template<typename Function >
auto make_execution_stage (const sstring &name, scheduling_group sg, Function &&fn)
 
template<typename Function >
auto make_execution_stage (const sstring &name, Function &&fn)
 
template<typename Ret , typename Object , typename... Args>
concrete_execution_stage< Ret, Object *, Args... > make_execution_stage (const sstring &name, scheduling_group sg, Ret(Object::*fn)(Args...))
 
template<typename Ret , typename Object , typename... Args>
concrete_execution_stage< Ret, const Object *, Args... > make_execution_stage (const sstring &name, scheduling_group sg, Ret(Object::*fn)(Args...) const)
 
template<typename Ret , typename Object , typename... Args>
concrete_execution_stage< Ret, Object *, Args... > make_execution_stage (const sstring &name, Ret(Object::*fn)(Args...))
 
template<typename Ret , typename Object , typename... Args>
concrete_execution_stage< Ret, const Object *, Args... > make_execution_stage (const sstring &name, Ret(Object::*fn)(Args...) const)
 
open_flags operator| (open_flags a, open_flags b)
 
void operator|= (open_flags &a, open_flags b)
 
open_flags operator & (open_flags a, open_flags b)
 
void operator &= (open_flags &a, open_flags b)
 
access_flags operator| (access_flags a, access_flags b)
 
access_flags operator & (access_flags a, access_flags b)
 
constexpr file_permissions operator| (file_permissions a, file_permissions b)
 
constexpr file_permissions operator & (file_permissions a, file_permissions b)
 
bool filesystem_has_good_aio_support (sstring directory, bool verbose=false)
 
input_stream< char > make_file_input_stream (file file, uint64_t offset, uint64_t len, file_input_stream_options options={})
 Creates an input_stream to read a portion of a file. More...
 
input_stream< char > make_file_input_stream (file file, uint64_t offset, file_input_stream_options={})
 
input_stream< char > make_file_input_stream (file file, file_input_stream_options={})
 
output_stream< char > make_file_output_stream (file file, uint64_t buffer_size=8192)
 
output_stream< char > make_file_output_stream (file file, file_output_stream_options options)
 
data_sink make_file_data_sink (file, file_output_stream_options)
 
template<typename Func , typename... Args>
auto with_scheduling_group (scheduling_group sg, Func func, Args &&... args)
 run a callable (with some arbitrary arguments) in a scheduling group More...
 
template<typename Iterator , typename Func >
future parallel_for_each (Iterator begin, Iterator end, Func &&func) noexcept
 
template<typename Range , typename Func >
future parallel_for_each (Range &&range, Func &&func)
 
template<typename AsyncAction >
future repeat (AsyncAction action)
 
template<typename AsyncAction >
repeat_until_value_return_type< AsyncAction > repeat_until_value (AsyncAction action)
 
template<typename AsyncAction , typename StopCondition >
future do_until (StopCondition stop_cond, AsyncAction action)
 
template<typename AsyncAction >
future keep_doing (AsyncAction action)
 
template<typename Iterator , typename AsyncAction >
future do_for_each (Iterator begin, Iterator end, AsyncAction action)
 
template<typename Container , typename AsyncAction >
future do_for_each (Container &c, AsyncAction action)
 
template<typename Fut , std::enable_if_t< is_future< Fut >::value, int > = 0>
auto futurize_apply_if_func (Fut &&fut)
 
template<typename Func , std::enable_if_t<!is_future< Func >::value, int > = 0>
auto futurize_apply_if_func (Func &&func)
 
template<typename... Futs>
future< std::tuple< Futs... > > when_all_impl (Futs &&... futs)
 
template<typename... FutOrFuncs>
auto when_all (FutOrFuncs &&... fut_or_funcs)
 
template<typename FutureIterator >
future< std::vector< typename std::iterator_traits< FutureIterator >::value_type > > when_all (FutureIterator begin, FutureIterator end)
 
template<typename Iterator , typename Mapper , typename Reducer >
auto map_reduce (Iterator begin, Iterator end, Mapper &&mapper, Reducer &&r) -> typename reducer_traits< Reducer >::future_type
 
template<typename Iterator , typename Mapper , typename Initial , typename Reduce >
future< Initial > map_reduce (Iterator begin, Iterator end, Mapper &&mapper, Initial initial, Reduce reduce)
 
template<typename Range , typename Mapper , typename Initial , typename Reduce >
future< Initial > map_reduce (Range &&range, Mapper &&mapper, Initial initial, Reduce reduce)
 
future now ()
 
future later ()
 
template<typename ExceptionFactory = default_timeout_exception_factory, typename Clock , typename Duration , typename... T>
future< T... > with_timeout (std::chrono::time_point< Clock, Duration > timeout, future< T... > f)
 Wait for either a future, or a timeout, whichever comes first. More...
 
template<typename... Futures>
auto when_all_succeed_impl (Futures &&... futures)
 
template<typename... FutOrFuncs>
auto when_all_succeed (FutOrFuncs &&... fut_or_funcs)
 
template<typename FutureIterator , typename = typename std::iterator_traits<FutureIterator>::value_type>
auto when_all_succeed (FutureIterator begin, FutureIterator end)
 
template<typename... T, typename... A>
future< T... > make_ready_future (A &&... value)
 Creates a future in an available, value state. More...
 
template<typename... T>
future< T... > make_exception_future (std::exception_ptr value) noexcept
 Creates a future in an available, failed state. More...
 
void log_exception_trace () noexcept
 
template<typename... T, typename Exception >
future< T... > make_exception_future (Exception &&ex) noexcept
 Creates a future in an available, failed state. More...
 
future rename_priority_class (io_priority_class pc, sstring new_name)
 
void add_to_flush_poller (output_stream< char > *x)
 
template<typename CharType >
future copy (input_stream< CharType > &, output_stream< CharType > &)
 copy all the content from the input stream to the output stream
 
template future copy< char > (input_stream< char > &, output_stream< char > &)
 
template<typename CharType >
temporary_buffer< CharType > make_temporary_buffer (compat::polymorphic_allocator< CharType > *allocator, std::size_t size)
 
void throw_system_error_on (bool condition, const char *what_arg="")
 
template<typename T >
void throw_kernel_error (T r)
 
mmap_area mmap_anonymous (void *addr, size_t length, int prot, int flags)
 
template<typename T >
void throw_pthread_error (T r)
 
sigset_t make_sigset_mask (int signo)
 
sigset_t make_full_sigset_mask ()
 
sigset_t make_empty_sigset_mask ()
 
void pin_this_thread (unsigned cpu_id)
 
bool need_preempt () noexcept
 
template<typename T , int LOC = 3>
void prefetch (T *ptr)
 
template<typename Iterator , int LOC = 3>
void prefetch (Iterator begin, Iterator end)
 
template<size_t C, typename T , int LOC = 3>
void prefetch_n (T **pptr)
 
template<size_t L, int LOC = 3>
void prefetch (void *ptr)
 
template<size_t L, typename Iterator , int LOC = 3>
void prefetch_n (Iterator begin, Iterator end)
 
template<size_t L, size_t C, typename T , int LOC = 3>
void prefetch_n (T **pptr)
 
template<typename T , int LOC = 3>
void prefetchw (T *ptr)
 
template<typename Iterator , int LOC = 3>
void prefetchw_n (Iterator begin, Iterator end)
 
template<size_t C, typename T , int LOC = 3>
void prefetchw_n (T **pptr)
 
template<size_t L, int LOC = 3>
void prefetchw (void *ptr)
 
template<size_t L, typename Iterator , int LOC = 3>
void prefetchw_n (Iterator begin, Iterator end)
 
template<size_t L, size_t C, typename T , int LOC = 3>
void prefetchw_n (T **pptr)
 
template<typename... A>
std::ostream & fprint (std::ostream &os, const char *fmt, A &&... a)
 
template<typename... A>
void print (const char *fmt, A &&... a)
 
template<typename... A>
std::string sprint (const char *fmt, A &&... a)
 
template<typename... A>
std::string sprint (const sstring &fmt, A &&... a)
 
template<typename Iterator >
std::string format_separated (Iterator b, Iterator e, const char *sep=", ")
 
template<typename TimePoint >
usecfmt_wrapper< TimePoint > usecfmt (TimePoint tp)
 
template<typename Clock , typename Rep , typename Period >
std::ostream & operator<< (std::ostream &os, usecfmt_wrapper< std::chrono::time_point< Clock, std::chrono::duration< Rep, Period >>> tp)
 
template<typename... A>
void log (A &&... a)
 
template<typename... A>
sstring format (const char *fmt, A &&... a)
 
template<typename... A>
std::ostream & fmt_print (std::ostream &os, const char *format, A &&... a)
 
size_t iovec_len (const std::vector< iovec > &iov)
 
void register_network_stack (sstring name, boost::program_options::options_description opts, std::function< future< std::unique_ptr< network_stack >>(boost::program_options::variables_map opts)> create, bool make_default=false)
 
smp_service_group default_smp_service_group ()
 
future< smp_service_groupcreate_smp_service_group (smp_service_group_config ssgc)
 
future destroy_smp_service_group (smp_service_group ssg)
 
reactorengine ()
 
bool engine_is_ready ()
 
size_t iovec_len (const iovec *begin, size_t len)
 
void report_exception (compat::string_view message, std::exception_ptr) noexcept
 
cpu_set_t cpuid_to_cpuset (unsigned cpuid)
 
void validate (boost::any &v, const std::vector< std::string > &values, cpuset_bpo_wrapper *target_type, int)
 
constexpr unsigned max_scheduling_groups ()
 
future< scheduling_groupcreate_scheduling_group (sstring name, float shares)
 
future destroy_scheduling_group (scheduling_group sg)
 
future rename_scheduling_group (scheduling_group sg, sstring new_name)
 
scheduling_group current_scheduling_group ()
 Returns the current scheduling group.
 
scheduling_group default_scheduling_group ()
 
server_socket listen (socket_address sa)
 
server_socket listen (socket_address sa, listen_options opts)
 
future< connected_socketconnect (socket_address sa)
 
future< connected_socketconnect (socket_address sa, socket_address local, transport proto)
 
future check_direct_io_support (sstring path)
 
future make_directory (sstring name, file_permissions permissions=file_permissions::default_dir_permissions)
 
future touch_directory (sstring name, file_permissions permissions=file_permissions::default_dir_permissions)
 
future recursive_touch_directory (sstring name, file_permissions permissions=file_permissions::default_dir_permissions)
 
future sync_directory (sstring name)
 
future remove_file (sstring name)
 
future rename_file (sstring old_name, sstring new_name)
 
future< stat_datafile_stat (sstring name, follow_symlink fs=follow_symlink::yes)
 
future< uint64_t > file_size (sstring name)
 
future< bool > file_accessible (sstring name, access_flags flags)
 
future< bool > file_exists (sstring name)
 
future link_file (sstring oldpath, sstring newpath)
 
future chmod (sstring name, file_permissions permissions)
 
future< fs_typefile_system_at (sstring name)
 
future< uint64_t > fs_avail (sstring name)
 
future< uint64_t > fs_free (sstring name)
 
template<typename ExceptionFactory , typename Clock = typename timer<>::clock>
semaphore_units< ExceptionFactory, Clock > consume_units (basic_semaphore< ExceptionFactory, Clock > &sem, size_t units)
 Consume units from semaphore temporarily. More...
 
template<typename T , typename... A>
lw_shared_ptr< T > make_lw_shared (A &&... a)
 
template<typename T >
lw_shared_ptr< T > make_lw_shared (T &&a)
 
template<typename T >
lw_shared_ptr< T > make_lw_shared (T &a)
 
template<typename T , typename... A>
shared_ptr< T > make_shared (A &&... a)
 
template<typename T >
shared_ptr< T > make_shared (T &&a)
 
template<typename T , typename U >
shared_ptr< T > static_pointer_cast (const shared_ptr< U > &p)
 
template<typename T , typename U >
shared_ptr< T > dynamic_pointer_cast (const shared_ptr< U > &p)
 
template<typename T , typename U >
shared_ptr< T > const_pointer_cast (const shared_ptr< U > &p)
 
template<typename T >
static std::ostream & operator<< (std::ostream &out, const lw_shared_ptr< T > &p)
 
template<typename T , typename U >
bool operator== (const shared_ptr< T > &x, const shared_ptr< U > &y)
 
template<typename T >
bool operator== (const shared_ptr< T > &x, std::nullptr_t)
 
template<typename T >
bool operator== (std::nullptr_t, const shared_ptr< T > &y)
 
template<typename T , typename U >
bool operator!= (const shared_ptr< T > &x, const shared_ptr< U > &y)
 
template<typename T >
bool operator!= (const shared_ptr< T > &x, std::nullptr_t)
 
template<typename T >
bool operator!= (std::nullptr_t, const shared_ptr< T > &y)
 
template<typename T , typename U >
bool operator< (const shared_ptr< T > &x, const shared_ptr< U > &y)
 
template<typename T >
bool operator< (const shared_ptr< T > &x, std::nullptr_t)
 
template<typename T >
bool operator< (std::nullptr_t, const shared_ptr< T > &y)
 
template<typename T , typename U >
bool operator<= (const shared_ptr< T > &x, const shared_ptr< U > &y)
 
template<typename T >
bool operator<= (const shared_ptr< T > &x, std::nullptr_t)
 
template<typename T >
bool operator<= (std::nullptr_t, const shared_ptr< T > &y)
 
template<typename T , typename U >
bool operator> (const shared_ptr< T > &x, const shared_ptr< U > &y)
 
template<typename T >
bool operator> (const shared_ptr< T > &x, std::nullptr_t)
 
template<typename T >
bool operator> (std::nullptr_t, const shared_ptr< T > &y)
 
template<typename T , typename U >
bool operator>= (const shared_ptr< T > &x, const shared_ptr< U > &y)
 
template<typename T >
bool operator>= (const shared_ptr< T > &x, std::nullptr_t)
 
template<typename T >
bool operator>= (std::nullptr_t, const shared_ptr< T > &y)
 
template<typename T >
static std::ostream & operator<< (std::ostream &out, const shared_ptr< T > &p)
 
template<typename Stream , typename StreamVisitor , typename = std::enable_if_t<Stream::has_with_stream::value>>
static decltype(auto) with_serialized_stream (Stream &stream, StreamVisitor &&visitor)
 
template<typename Stream , typename StreamVisitor , typename = std::enable_if_t<!Stream::has_with_stream::value>, typename = void>
static decltype(auto) with_serialized_stream (Stream &stream, StreamVisitor &&visitor)
 
template<typename Clock = steady_clock_type, typename Rep , typename Period >
future sleep (std::chrono::duration< Rep, Period > dur)
 
template<typename Clock = steady_clock_type>
future sleep_abortable (typename Clock::duration dur)
 
template future sleep_abortable< steady_clock_type > (typename steady_clock_type::duration)
 
template future sleep_abortable< lowres_clock > (typename lowres_clock::duration)
 
template<typename Clock = steady_clock_type>
future sleep_abortable (typename Clock::duration dur, abort_source &as)
 
template future sleep_abortable< steady_clock_type > (typename steady_clock_type::duration, abort_source &)
 
template future sleep_abortable< lowres_clock > (typename lowres_clock::duration, abort_source &)
 
template<typename string_type = sstring, typename T >
string_type to_sstring (T value)
 
template<typename char_type , typename size_type , size_type Max, size_type N, bool NulTerminate>
basic_sstring< char_type, size_type, Max, NulTerminate > operator+ (const char(&s)[N], const basic_sstring< char_type, size_type, Max, NulTerminate > &t)
 
template<size_t N>
static size_t str_len (const char(&s)[N])
 
template<size_t N>
static const char * str_begin (const char(&s)[N])
 
template<size_t N>
static const char * str_end (const char(&s)[N])
 
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate>
static const char_type * str_begin (const basic_sstring< char_type, size_type, max_size, NulTerminate > &s)
 
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate>
static const char_type * str_end (const basic_sstring< char_type, size_type, max_size, NulTerminate > &s)
 
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate>
static size_type str_len (const basic_sstring< char_type, size_type, max_size, NulTerminate > &s)
 
template<typename First , typename Second , typename... Tail>
static size_t str_len (const First &first, const Second &second, const Tail &... tail)
 
template<typename char_type , typename size_type , size_type max_size>
void swap (basic_sstring< char_type, size_type, max_size > &x, basic_sstring< char_type, size_type, max_size > &y) noexcept
 
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate, typename char_traits >
std::basic_ostream< char_type, char_traits > & operator<< (std::basic_ostream< char_type, char_traits > &os, const basic_sstring< char_type, size_type, max_size, NulTerminate > &s)
 
template<typename char_type , typename size_type , size_type max_size, bool NulTerminate, typename char_traits >
std::basic_istream< char_type, char_traits > & operator>> (std::basic_istream< char_type, char_traits > &is, basic_sstring< char_type, size_type, max_size, NulTerminate > &s)
 
static char * copy_str_to (char *dst)
 
template<typename Head , typename... Tail>
static char * copy_str_to (char *dst, const Head &head, const Tail &... tail)
 
template<typename String = sstring, typename... Args>
static String make_sstring (Args &&... args)
 
void schedule (std::unique_ptr< task > &&t) noexcept
 
void schedule_urgent (std::unique_ptr< task > &&t) noexcept
 
template<typename Func >
std::unique_ptr< taskmake_task (Func &&func)
 
template<typename Func >
std::unique_ptr< taskmake_task (scheduling_group sg, Func &&func)
 
template<typename Func , typename... Args>
futurize_t< std::result_of_t< std::decay_t< Func >std::decay_t< Args >...)> > async (thread_attributes attr, Func &&func, Args &&... args)
 
template<typename Func , typename... Args>
futurize_t< std::result_of_t< std::decay_t< Func >std::decay_t< Args >...)> > async (Func &&func, Args &&... args)
 
template<typename T , typename Alloc >
void transfer_pass1 (Alloc &a, T *from, T *to, typename std::enable_if< std::is_nothrow_move_constructible< T >::value >::type *=nullptr)
 
template<typename T , typename Alloc >
void transfer_pass2 (Alloc &a, T *from, T *to, typename std::enable_if< std::is_nothrow_move_constructible< T >::value >::type *=nullptr)
 
template<typename T , typename Alloc >
void transfer_pass1 (Alloc &a, T *from, T *to, typename std::enable_if<!std::is_nothrow_move_constructible< T >::value >::type *=nullptr)
 
template<typename T , typename Alloc >
void transfer_pass2 (Alloc &a, T *from, T *to, typename std::enable_if<!std::is_nothrow_move_constructible< T >::value >::type *=nullptr)
 
template<typename T >
struct seastar::unaligned __attribute__ ((packed))
 
template<typename T , typename F >
auto unaligned_cast (F *p)
 
template<typename T , typename F >
auto unaligned_cast (const F *p)
 
bool is_ip_unspecified (const ipv4_addr &addr)
 
bool is_port_unspecified (const ipv4_addr &addr)
 
socket_address make_ipv4_address (const ipv4_addr &addr)
 
socket_address make_ipv4_address (uint32_t ip, uint16_t port)
 
uint64_t ntohq (uint64_t v)
 
uint64_t htonq (uint64_t v)
 
std::ostream & operator<< (std::ostream &, const socket_address &)
 
std::ostream & operator<< (std::ostream &, const ipv4_addr &)
 
std::ostream & operator<< (std::ostream &, const ipv6_addr &)
 
bool operator== (const ipv4_addr &lhs, const ipv4_addr &rhs)
 
template<typename T >
static uint32_t toeplitz_hash (rss_key_type key, const T &data)
 
std::unique_ptr< net::devicecreate_virtio_net_device (boost::program_options::variables_map opts=boost::program_options::variables_map())
 
boost::program_options::options_description get_virtio_net_options_description ()
 
bool operator== (const frame &a, const frame &b)
 
frame decorate (uintptr_t addr)
 
template<typename Func >
void backtrace (Func &&func) noexcept(noexcept(func(frame())))
 
saved_backtrace current_backtrace () noexcept
 
std::ostream & operator<< (std::ostream &out, const saved_backtrace &b)
 
template<class Exc , typename... Args>
void throw_with_backtrace (Args &&... args)
 
size_t parse_memory_size (std::string s)
 
static std::vector< char > string2vector (std::string str)
 
template<typename Func >
deferred_action< Func > defer (Func &&func)
 
template<typename Function , typename State >
function_input_iterator< Function, State > make_function_input_iterator (Function func, State state)
 
template<typename Function , typename State >
function_input_iterator< Function, State > make_function_input_iterator (Function &&func)
 
template<typename Func >
lazy_eval< Func > value_of (Func &&func)
 
template<typename T >
lazy_deref_wrapper< T > lazy_deref (const T &p)
 
std::ostream & operator<< (std::ostream &out, log_level level)
 
std::istream & operator>> (std::istream &in, log_level &level)
 
logger_registryglobal_logger_registry ()
 
void apply_logging_settings (const logging_settings &)
 
void print_safe (const char *str, size_t len) noexcept
 
void print_safe (const char *str) noexcept
 
template<typename Integral >
void convert_zero_padded_hex_safe (char *buf, size_t bufsz, Integral n) noexcept
 
template<typename Integral >
void print_zero_padded_hex_safe (Integral n) noexcept
 
template<typename Integral >
size_t convert_decimal_safe (char *buf, size_t bufsz, Integral n) noexcept
 
template<typename Integral >
void print_decimal_safe (Integral n) noexcept
 
sstring read_first_line (compat::filesystem::path sys_file)
 
template<typename T >
reference_wrapper< T > ref (T &object) noexcept
 Wraps reference in a reference_wrapper.
 
template<typename T >
reference_wrapper< const T > cref (const T &object) noexcept
 Wraps constant reference in a reference_wrapper.
 
template<typename Iterator , typename Func >
transform_iterator< Iterator, Func > make_transform_iterator (Iterator i, Func f)
 
template<template< typename > class FilterClass, typename... Elements>
auto tuple_filter_by_type (const std::tuple< Elements... > &t)
 
template<template< typename > class FilterClass, typename... Elements>
auto tuple_filter_by_type (std::tuple< Elements... > &&t)
 
template<typename Function , typename... Elements>
auto tuple_map (const std::tuple< Elements... > &t, Function &&f)
 
template<typename Function , typename... Elements>
auto tuple_map (std::tuple< Elements... > &&t, Function &&f)
 
template<typename Function , typename... Elements>
void tuple_for_each (const std::tuple< Elements... > &t, Function &&f)
 
template<typename Function , typename... Elements>
void tuple_for_each (std::tuple< Elements... > &t, Function &&f)
 
template<typename Function , typename... Elements>
void tuple_for_each (std::tuple< Elements... > &&t, Function &&f)
 
template<typename... Args>
auto make_visitor (Args &&... args)
 
template<typename Variant , typename... Args>
auto visit (Variant &&variant, Args &&... args)
 
template<typename Variant >
Variant variant_cast (Variant &&var)
 

Variables

__thread const internal::preemption_monitor * g_need_preempt
 
__thread reactorlocal_engine
 
__thread size_t task_quota
 
logger seastar_logger
 
static constexpr uint16_t SLAB_MAGIC_NUMBER = 0x51AB
 
static constexpr size_t KB = 1 << 10
 
static constexpr size_t MB = 1 << 20
 
static constexpr size_t GB = 1 << 30
 
seastar::vector_data_sink __attribute__
 
static constexpr uint8_t default_rsskey_40bytes []
 
static constexpr uint8_t default_rsskey_52bytes []
 

Class Documentation

◆ seastar::apply_helper

struct seastar::apply_helper

◆ seastar::continue_consuming

struct seastar::continue_consuming

◆ seastar::cpuset_bpo_wrapper

struct seastar::cpuset_bpo_wrapper
Class Members
cpuset value

◆ seastar::fair_queue_request_descriptor

struct seastar::fair_queue_request_descriptor
Class Members
unsigned size the effective size of this request
unsigned weight the weight of this request for capacity purposes (IOPS).

◆ seastar::file_input_stream_options

struct seastar::file_input_stream_options
Class Members
size_t buffer_size I/O buffer size.
lw_shared_ptr< file_input_stream_history > dynamic_adjustments Input stream history, if null dynamic adjustments are disabled.
::io_priority_class io_priority_class
unsigned read_ahead Maximum number of extra read-ahead operations.

◆ seastar::file_output_stream_options

struct seastar::file_output_stream_options
Class Members
unsigned buffer_size
::io_priority_class io_priority_class
unsigned preallocation_size Preallocate extents. For large files, set to a large number (a few megabytes) to reduce fragmentation.
unsigned write_behind Number of buffers to write in parallel.

◆ seastar::frame

struct seastar::frame
Class Members
uintptr_t addr
const shared_object * so

◆ seastar::function_traits

struct seastar::function_traits

◆ seastar::listen_options

struct seastar::listen_options
Class Members
load_balancing_algorithm lba
int listen_backlog
transport proto
bool reuse_address

◆ seastar::logging_settings

struct seastar::logging_settings
Class Members
log_level default_level
unordered_map< sstring, log_level > logger_levels
bool stdout_enabled
logger_timestamp_style stdout_timestamp_style
bool syslog_enabled

◆ seastar::lw_shared_ptr_deleter

struct seastar::lw_shared_ptr_deleter

◆ seastar::noncopyable_function

class seastar::noncopyable_function

◆ seastar::reactor_config

struct seastar::reactor_config
Class Members
bool auto_handle_sigint_sigterm Handle SIGINT/SIGTERM by calling reactor::stop()

When true, Seastar will set up signal handlers for SIGINT/SIGTERM that call reactor::stop(). The reactor will then execute callbacks installed by reactor::at_exit().

When false, Seastar will not set up signal handlers for SIGINT/SIGTERM automatically. The default behavior (terminate the program) will be kept. You can adjust the behavior of SIGINT/SIGTERM by installing signal handlers via reactor::handle_signal(). automatically terminate on SIGINT/SIGTERM

duration< double > task_quota

default time between polls

◆ seastar::shared_object

struct seastar::shared_object
Class Members
uintptr_t begin
uintptr_t end
sstring name

◆ seastar::shared_ptr_make_helper

struct seastar::shared_ptr_make_helper

◆ seastar::smp_service_group_config

struct seastar::smp_service_group_config
Class Members
unsigned max_nonlocal_requests

The maximum number of non-local requests that execute on a shard concurrently

Will be adjusted upwards to allow at least one request per non-local shard.

◆ seastar::socket_address.u

union seastar::socket_address.u
Class Members
::sockaddr_in in
::sockaddr_in6 in6
::sockaddr sa
::sockaddr_storage sas

◆ seastar::tuple_map_types< MapClass, std::tuple< Elements... > >

struct seastar::tuple_map_types< MapClass, std::tuple< Elements... > >
Class Members
type

◆ seastar::usecfmt_wrapper

struct seastar::usecfmt_wrapper
Class Members
TimePoint val

Enumeration Type Documentation

◆ log_level

enum seastar::log_level
strong

log level used with

See also
{logger} used with the logger.do_log method. Levels are in increasing order. That is if you want to see debug(3) logs you will also see error(0), warn(1), info(2).

Function Documentation

◆ apply_logging_settings()

void seastar::apply_logging_settings ( const logging_settings )

Shortcut for configuring the logging system all at once.

◆ create_scheduling_group()

future<scheduling_group> seastar::create_scheduling_group ( sstring  name,
float  shares 
)

Creates a scheduling group with a specified number of shares.

The operation is global and affects all shards. The returned scheduling group can then be used in any shard.

Parameters
nameA name that identifiers the group; will be used as a label in the group's metrics
sharesnumber of shares of the CPU time allotted to the group; Use numbers in the 1-1000 range (but can go above).
Returns
a scheduling group that can be used on any shard

◆ create_smp_service_group()

future<smp_service_group> seastar::create_smp_service_group ( smp_service_group_config  ssgc)

Creates an smp_service_group with the specified configuration.

The smp_service_group is global, and after this call completes, the returned value can be used on any shard.

◆ default_smp_service_group()

smp_service_group seastar::default_smp_service_group ( )
inline

Returns the default smp_service_group. This smp_service_group does not impose any limits on concurrency in the target shard. This makes is deadlock-safe, but can consume unbounded resources, and should therefore only be used when initiator concurrency is very low (e.g. administrative tasks).

◆ destroy_scheduling_group()

future seastar::destroy_scheduling_group ( scheduling_group  sg)

Destroys a scheduling group.

Destroys a scheduling_group previously created with create_scheduling_group(). The destroyed group must not be currently in use and must not be used later.

The operation is global and affects all shards.

Parameters
sgThe scheduling group to be destroyed
Returns
a future that is ready when the scheduling group has been torn down

◆ destroy_smp_service_group()

future seastar::destroy_smp_service_group ( smp_service_group  ssg)

Destroy an smp_service_group.

Frees all resources used by an smp_service_group. It must not be used again once this function is called.

◆ format()

template<typename... A>
sstring seastar::format ( const char *  fmt,
A &&...  a 
)

Evaluate the formatted string in a native fmt library format

Parameters
fmtformat string with the native fmt library syntax
apositional parameters
Returns
sstring object with the result of applying the given positional parameters on a given format string.

◆ is_abort_on_ebadf_enabled()

bool seastar::is_abort_on_ebadf_enabled ( )

Queries the current setting for seastar's behavior on invalid file descriptor access. See set_abort_on_ebadf().

◆ lazy_deref()

template<typename T >
lazy_deref_wrapper<T> seastar::lazy_deref ( const T &  p)

Create a seastar::lazy_deref_wrapper object.

The actual dereferencing will happen when the object is inserted into a stream. The pointer is not copied, only a reference is saved to it. Smart pointers are supported as well.

Parameters
pa raw pointer or a smart pointer
Returns
a lazy_deref_wrapper object

◆ make_file_data_sink()

data_sink seastar::make_file_data_sink ( file  ,
file_output_stream_options   
)

Create a data_sink for writing starting at the position zero of a newly created file.

◆ make_file_input_stream()

input_stream<char> seastar::make_file_input_stream ( file  file,
uint64_t  offset,
uint64_t  len,
file_input_stream_options  options = {} 
)

Creates an input_stream to read a portion of a file.

Parameters
fileFile to read; multiple streams for the same file may coexist
offsetStarting offset to read from (no alignment restrictions)
lenMaximum number of bytes to read; the stream will stop at end-of-file even if offset + len is beyond end-of-file.
optionsA set of options controlling the stream.
Note
Multiple input streams may exist concurrently for the same file.

◆ make_file_output_stream()

output_stream<char> seastar::make_file_output_stream ( file  file,
file_output_stream_options  options 
)

Create an output_stream for writing starting at the position zero of a newly created file. NOTE: flush() should be the last thing to be called on a file output stream.

◆ make_temporary_buffer()

template<typename CharType >
temporary_buffer<CharType> seastar::make_temporary_buffer ( compat::polymorphic_allocator< CharType > *  allocator,
std::size_t  size 
)

Creates a temporary_buffer allocated by a custom allocator

Parameters
allocatorallocator to use when allocating the temporary_buffer
sizesize of the temporary buffer

◆ rename_priority_class()

future seastar::rename_priority_class ( io_priority_class  pc,
sstring  new_name 
)

Renames an io priority class

Renames an io_priority_class previously created with register_one_priority_class().

The operation is global and affects all shards. The operation affects the exported statistics labels.

Parameters
pcThe io priority class to be renamed
new_nameThe new name for the io priority class
Returns
a future that is ready when the io priority class have been renamed

◆ rename_scheduling_group()

future seastar::rename_scheduling_group ( scheduling_group  sg,
sstring  new_name 
)

Rename scheduling group.

Renames a scheduling_group previously created with create_scheduling_group().

The operation is global and affects all shards. The operation affects the exported statistics labels.

Parameters
sgThe scheduling group to be renamed
new_nameThe new name for the scheduling group.
Returns
a future that is ready when the scheduling group has been renamed

◆ set_abort_on_ebadf()

void seastar::set_abort_on_ebadf ( bool  do_abort)

Determines whether seastar should throw or abort when operation made by seastar fails because the target file descriptor is not valid. This is detected when underlying system calls return EBADF or ENOTSOCK. The default behavior is to throw std::system_error.

◆ sleep()

template<typename Clock = steady_clock_type, typename Rep , typename Period >
future seastar::sleep ( std::chrono::duration< Rep, Period >  dur)

Returns a future which completes after a specified time has elapsed.

Parameters
durminimum amount of time before the returned future becomes ready.
Returns
A future which becomes ready when the sleep duration elapses.

◆ sleep_abortable() [1/2]

template<typename Clock = steady_clock_type>
future seastar::sleep_abortable ( typename Clock::duration  dur)

Returns a future which completes after a specified time has elapsed or throws sleep_aborted exception if application is aborted

Parameters
durminimum amount of time before the returned future becomes ready.
Returns
A future which becomes ready when the sleep duration elapses.

◆ sleep_abortable() [2/2]

template<typename Clock = steady_clock_type>
future seastar::sleep_abortable ( typename Clock::duration  dur,
abort_source as 
)

Returns a future which completes after a specified time has elapsed or throws sleep_aborted exception if the sleep is aborted.

Parameters
durminimum amount of time before the returned future becomes ready.
asthe abort_source that eventually notifies that the sleep should be aborted.
Returns
A future which becomes ready when the sleep duration elapses.

◆ throw_with_backtrace()

template<class Exc , typename... Args>
void seastar::throw_with_backtrace ( Args &&...  args)

Throws an exception of unspecified type that is derived from the Exc type with a backtrace attached to its message

Template Parameters
Excexception type to be caught at the receiving side
Argstypes of arguments forwarded to the constructor of Exc
Parameters
argsarguments forwarded to the constructor of Exc
Returns
never returns (throws an exception)

◆ value_of()

template<typename Func >
lazy_eval<Func> seastar::value_of ( Func &&  func)
inline

Create a seastar::lazy_eval object that will use a given functor for evaluating a value when the evaluation is triggered.

The actual evaluation is triggered by applying a () operator on a returned object.

Parameters
Funca type of a func
funcfunc a functor to evaluate the value
Returns
a lazy_eval object that may be used for evaluating a value

Variable Documentation

◆ default_rsskey_40bytes

constexpr uint8_t seastar::default_rsskey_40bytes[]
static
Initial value:
= {
0xd1, 0x81, 0xc6, 0x2c, 0xf7, 0xf4, 0xdb, 0x5b,
0x19, 0x83, 0xa2, 0xfc, 0x94, 0x3e, 0x1a, 0xdb,
0xd9, 0x38, 0x9e, 0x6b, 0xd1, 0x03, 0x9c, 0x2c,
0xa7, 0x44, 0x99, 0xad, 0x59, 0x3d, 0x56, 0xd9,
0xf3, 0x25, 0x3c, 0x06, 0x2a, 0xdc, 0x1f, 0xfc
}

◆ default_rsskey_52bytes

constexpr uint8_t seastar::default_rsskey_52bytes[]
static
Initial value:
= {
0x44, 0x39, 0x79, 0x6b, 0xb5, 0x4c, 0x50, 0x23,
0xb6, 0x75, 0xea, 0x5b, 0x12, 0x4f, 0x9f, 0x30,
0xb8, 0xa2, 0xc0, 0x3d, 0xdf, 0xdc, 0x4d, 0x02,
0xa0, 0x8c, 0x9b, 0x33, 0x4a, 0xf6, 0x4a, 0x4c,
0x05, 0xc6, 0xfa, 0x34, 0x39, 0x58, 0xd8, 0x55,
0x7d, 0x99, 0x58, 0x3a, 0xe1, 0x38, 0xc9, 0x2e,
0x81, 0x15, 0x03, 0x66
}