Seastar
High performance C++ framework for concurrent servers
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
seastar::rpc::connection Class Referenceabstract
Inheritance diagram for seastar::rpc::connection:
seastar::rpc::client seastar::rpc::server::connection seastar::rpc::protocol< Serializer, MsgType >::client

Classes

struct  outgoing_entry
 

Public Member Functions

 connection (connected_socket &&fd, const logger &l, void *s, connection_id id=invalid_connection_id)
 
 connection (const logger &l, void *s, connection_id id=invalid_connection_id)
 
size_t outgoing_queue_length () const noexcept
 
void set_socket (connected_socket &&fd)
 
future send_negotiation_frame (feature_map features)
 
bool error () const noexcept
 
void abort ()
 
future stop () noexcept
 
future stream_receive (circular_buffer< foreign_ptr< std::unique_ptr< rcv_buf > > > &bufs)
 
future close_sink ()
 
bool sink_closed () const noexcept
 
future close_source ()
 
connection_id get_connection_id () const noexcept
 
statsget_stats_internal () noexcept
 
xshard_connection_ptr get_stream (connection_id id) const
 
void register_stream (connection_id id, xshard_connection_ptr c)
 
virtual socket_address peer_address () const =0
 
const loggerget_logger () const noexcept
 
template<typename Serializer >
Serializer & serializer ()
 
template<typename FrameType >
future< typename FrameType::return_type > read_frame (socket_address info, input_stream< char > &in)
 
template<typename FrameType >
future< typename FrameType::return_type > read_frame_compressed (socket_address info, std::unique_ptr< compressor > &compressor, input_stream< char > &in)
 
void suspend_for_testing (promise<> &p)
 

Protected Member Functions

void withdraw (outgoing_entry::container_t::iterator it, std::exception_ptr ex=nullptr)
 
void set_negotiated () noexcept
 
bool is_stream () const noexcept
 
snd_buf compress (snd_buf buf)
 
future send_buffer (snd_buf buf)
 
future send (snd_buf buf, std::optional< rpc_clock_type::time_point > timeout={}, cancellable *cancel=nullptr)
 
future send_entry (outgoing_entry &d) noexcept
 
future stop_send_loop (std::exception_ptr ex)
 
future< std::optional< rcv_buf > > read_stream_frame_compressed (input_stream< char > &in)
 
bool stream_check_twoway_closed () const noexcept
 
future stream_close ()
 
future stream_process_incoming (rcv_buf &&)
 
future handle_stream_frame ()
 

Protected Attributes

connected_socket _fd
 
input_stream< char > _read_buf
 
output_stream< char > _write_buf
 
bool _error = false
 
bool _connected = false
 
std::optional< shared_promise<> > _negotiated = shared_promise<>()
 
promise _stopped
 
stats _stats
 
const logger_logger
 
void * _serializer
 
future _outgoing_queue_ready = _negotiated->get_shared_future()
 
outgoing_entry::container_t _outgoing_queue
 
size_t _outgoing_queue_size = 0
 
std::unique_ptr< compressor_compressor
 
bool _propagate_timeout = false
 
bool _timeout_negotiated = false
 
bool _handler_duration_negotiated = false
 
bool _is_stream = false
 
connection_id _id = invalid_connection_id
 
std::unordered_map< connection_id, xshard_connection_ptr_streams
 
queue< rcv_buf_stream_queue = queue<rcv_buf>(max_queued_stream_buffers)
 
semaphore _stream_sem = semaphore(max_stream_buffers_memory)
 
bool _sink_closed = true
 
bool _source_closed = true
 
future< bool > _sink_closed_future = make_ready_future<bool>(false)
 

The documentation for this class was generated from the following file: