Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/psg__client__transport_8cpp_source.html below:

NCBI C++ ToolKit: src/objtools/pubseq_gateway/client/psg_client_transport.cpp Source File

(

, PSG, throttle_by_consecutive_connection_failures, 0);

(

& cookie : *m_Cookies) {

(cookie.GetName() == name) {

combine = [](

p,

v) {

v.empty()? v : p.Get() +

+

(v); };

admin_cookie = combine(admin_auth_token_name, admin_auth_token.Get());

hup_cookie = combine(auth_token_name, auth_token.Get().empty() ? get_auth_token() : auth_token.Get());

admin_cookie.empty() ? hup_cookie : hup_cookie.empty() ? admin_cookie : admin_cookie +

+ hup_cookie;

= TPSG_RequestTimeout::GetDefault();

(

< io_timer_period) {

<< io_timer_period <<

);

= io_timer_period;

(

/ io_timer_period);

= TPSG_CompetitiveAfter::GetDefault();

timeout *= io_timer_period;

((

> 0.0) && (

< io_timer_period)) {

<< io_timer_period <<

);

= io_timer_period;

(

>= timeout) {

<< timeout <<

);

}

(

> 0.0) {

(timeout / io_timer_period);

(!

.empty()) os <<

<<

;

(port) os <<

<< port;

(m_Params.proxy) os <<

<< m_Params.proxy;

(Message <<

<<

<< address << path <<

<< sid <<

<< phid << os.str());

os <<

<< chunk.size() <<

;

(Message <<

<<

<< retries <<

<<

);

(

& event : m_Events) {

= get<0>(event);

= get<1>(event);

thread_id = get<2>(event);

os << fixed <<

<<

<<

<<

<<

<<

<< thread_id <<

;

cout << os.str() << flush;

constexpr

prefix =

;

constexpr

prefix =

;

constexpr

prefix =

;

constexpr

prefix =

;

constexpr

prefix =

;

constexpr

prefix =

;

<SPSG_Stats::EGroup group>

(

& counter :

.back()) {

<SPSG_Stats::EGroup group>

&

=

[group];

(

: TGroup::values) {

=

[

(

)].load();

(

)

(

<< prefix << report << TGroup::prefix << TGroup::ValueName(

) <<

<<

);

Apply<SInit>(eRequest, m_Data);

<

TWhat,

...

>

(start_with) {

eRequest: TWhat::template Func<eRequest> (std::forward<TArgs>(args)...);

eReplyItem: TWhat::template Func<eReplyItem> (std::forward<TArgs>(args)...);

eSkippedBlob: TWhat::template Func<eSkippedBlob> (std::forward<TArgs>(args)...);

eReplyItemStatus: TWhat::template Func<eReplyItemStatus> (std::forward<TArgs>(args)...);

: TWhat::template Func<eMessage> (std::forward<TArgs>(args)...);

eRetries: TWhat::template Func<eRetries> (std::forward<TArgs>(args)...);

<

...

>

Apply<SReport>(eRequest, m_Data, std::forward<TArgs>(args)...);

m_Data(eTimeUntilResend + 1)

v =

.first.load();

=

.second.load();

(

)

(

<< prefix << report <<

<<

(

) <<

<<

(v /

) / milli::den);

<

TDataId>

Tuple(

&

) {

tie(

.

(),

.GetLastModified()); }

Tuple(

&

) {

tuple<int, const string&>(

.GetId2Chunk(),

.GetId2Info()); }

operator()(

TDataId& lhs,

TDataId& rhs)

{

Tuple(lhs) < Tuple(rhs); }

(

locked = m_Ids.GetLock()) {

total = locked->

();

(

& data_id : *locked) {

= unique_ids.emplace(data_id, 1);

(

<< prefix << report << data_prefix <<

<< total <<

<< unique_ids.

());

received = m_Received.load();

read = m_Read.load();

(received)

(

<< prefix << report << data_prefix <<

<< received <<

<< read);

(

& p : unique_ids) {

= group_by_count.emplace(p.second, 1);

(

& p : group_by_count) {

(

<< prefix << report << data_prefix <<

<< p.first <<

<< p.second);

(TPSG_StatsPeriod::GetDefault());

prefix =

;

(

& server : *servers_locked) {

= server.stats.load();

(

)

(

<< prefix << report <<

<< server.address <<

<<

);

(m && ((min_severity ==

) || ((m.severity !=

) && (m.severity >= min_severity)))) {

m_InProgress.store(

);

message =

;

missing =

;

(

items_locked =

.GetLock()) {

(

& item : *items_locked) {

(item->state.InProgress()) {

item.GetLock()->state.AddError(message);

item->state.SetComplete();

(missing || reply_item_locked->expected.Cmp<greater>(reply_item_locked->received)) {

reply_item_locked->state.AddError(message);

reply_item_locked->state.SetComplete();

(

items_locked =

.GetLock()) {

(

& item : *items_locked) {

(item->state.InProgress()) {

item.GetLock()->state.AddError(message);

item->state.SetComplete();

reply_item_locked->state.AddError(message, status);

reply_item_locked->state.SetComplete();

was_in_progress =

->state.InProgress();

(

new_items_locked =

.GetLock()) {

(!new_items_locked->empty()) {

rv = new_items_locked->front();

new_items_locked->pop_front();

(!was_in_progress) {

.GetLock()->clear();

guard = m_ExistingGuard.lock();

m_ExistingGuard = guard;

full_path(std::move(p)),

=

;

(++index ==

.size()) {

(

->raw && !index) {

message =

;

(

(message)) {

->reply_item.GetLock()->state.AddError(message);

(*

!=

) {

& size_str = args.

(

);

= size_str.empty() ? 0ul : stoul(size_str);

chunk.append(

, data_size);

.empty() ? optional<int>{} : atoi(

.c_str());

& reply_item_ts =

->reply_item;

(

item_locked = reply_item_ts.GetLock()) {

(

update_result =

(item_type, *item_locked, args); update_result ==

) {

}

(update_result ==

) {

reply_item_ts.NotifyOne();

(

reply_item_locked = reply_item_ts.GetLock()) {

& reply_item = *reply_item_locked;

++reply_item.received;

(reply_item.expected.Cmp<

>(reply_item.received)) {

reply_item.state.AddError(

);

item_id = args.GetValue(

);

to_create = !item_by_id;

(

items_locked =

->items.GetLock()) {

items_locked->emplace_back();

item_by_id = &items_locked->back();

(

item_locked = item_by_id->GetLock()) {

update_result =

(item_type, *item_locked, args);

item_locked->args = std::move(args);

->new_items.GetLock()->emplace_back(item_by_id);

reply_item_ts.NotifyOne();

item_by_id->NotifyOne();

->queue->NotifyOne();

n_chunks = args.

(

);

(!n_chunks.empty()) {

item.

.

(

);

(

status = get_status(); can_retry_503(status,

)) {

atomic_bool reported(

);

(!reported.exchange(

)) {

(

<< chunk_type.second.get());

(TPSG_FailOnUnknownChunks::GetDefault()) {

item.

.

(

+ chunk_type.second +

);

}

(

status = get_status(); can_retry_503(status, chunk.c_str())) {

blob_chunk = args.

(

);

index = blob_chunk.empty() ? 0 : stoul(blob_chunk);

(item.

.size() <= index) item.

.resize(index + 1);

item.

[index] = std::move(chunk);

item.

.

(

);

->reply_item.GetLock()->state.AddError(

);

(

tci = TUvNgHttp2_TestIdentity::GetDefault(); tci.empty()) {

}

(tci.starts_with(

)) {

ncbi_peer_id(

());

ncbi_peer_id;

<

... TNgHttp2Cbs>

TPSG_Https::GetDefault(),

std::forward<TNgHttp2Cbs>(callbacks)...,

{

,

},

{

, TPSG_Https::GetDefault() ?

:

},

{

, m_Authority },

{

},

{

},

{

}

(

[processor_id, req] = it->second.Get(); req) {

= req->OnReplyData(processor_id, (

*)

,

);

it->second.ResetTime();

req->reply->SetComplete();

->debug_printout << retries <<

<< endl;

.

=

s;

.

=

s;

context_guard = req->context.Set();

rv = req->Fail(processor_id,

, refused_stream);

req->reply->debug_printout.id <<

<<

);

(

[processor_id, req] = it->second.Get(); req) {

context_guard = req->context.Set();

& debug_printout = req->reply->debug_printout;

debug_printout << error_code << endl;

(

(processor_id, req,

, error_code == NGHTTP2_REFUSED_STREAM)) {

(req->reply->raw) {

req->OnReplyDone(processor_id)->SetComplete();

debug_printout.id <<

);

((frame->hd.type == NGHTTP2_HEADERS) && (frame->headers.cat == NGHTTP2_HCAT_RESPONSE) &&

stream_id = frame->hd.stream_id;

status_str =

*

(

);

(

[processor_id, req] = it->second.Get(); req) {

req->OnReplyDone(processor_id)->SetFailed(

, status);

context_guard = req->context.Set();

& path = req->full_path;

& session_id =

.GetSessionID();

& sub_hit_id =

.GetNextSubHitID();

& client_ip =

.GetClientIP();

(!client_ip.empty()) {

(stream_id < 0) {

<

TOnRetry,

TOnFail>

[processor_id, req] =

();

(req->Retry(

)) {

on_fail(processor_id, req);

on_fail = [&](

processor_id,

req) {

(processor_id, req,

); };

(it->second.CheckExpiration(

,

, on_retry, on_fail)) {

some_requests_failed =

;

(

[processor_id, req] = pair.second.Get(); req) {

some_requests_failed =

;

(some_requests_failed) {

(frame->hd.type) {

NGHTTP2_DATA:

sv;

NGHTTP2_HEADERS:

sv;

NGHTTP2_PRIORITY:

sv;

NGHTTP2_RST_STREAM:

sv;

NGHTTP2_SETTINGS:

sv;

NGHTTP2_PUSH_PROMISE:

sv;

NGHTTP2_PING:

sv;

NGHTTP2_GOAWAY:

sv;

NGHTTP2_WINDOW_UPDATE:

sv;

NGHTTP2_CONTINUATION:

sv;

NGHTTP2_ALTSVC:

sv;

NGHTTP2_ORIGIN:

sv;

it =

.find(frame->hd.stream_id);

= it !=

.end() ? it->second.GetId() :

sv;

(error_rate.empty())

;

numerator_str, denominator_str;

(!

(error_rate,

, numerator_str, denominator_str))

;

(

> 0)

=

(

);

m_Stats(std::move(p)),

m_Timer(this, s_OnTimer, Configured(), 0)

stats_locked =

.GetLock();

<<

.

<<

);

(

<<

<< address <<

threshold_reg.first.reset();

(

& server : m_Sessions) {

(

& session : server.sessions) {

servers_locked = m_Servers.GetLock();

& servers = *servers_locked;

(

& server : servers) {

server.throttling.StartClose();

servers_locked = m_Servers.GetLock();

& servers = *servers_locked;

(

& server : servers) {

server.throttling.FinishClose();

servers_locked = m_Servers.GetLock();

& servers = *servers_locked;

servers_size = m_Servers->size();

sessions_size = m_Sessions.size();

(servers_size >= sessions_size);

(

new_servers = servers_size - sessions_size; new_servers; --new_servers) {

& server = servers[servers_size - new_servers];

m_Sessions.emplace_back().sessions.emplace_back(server, m_Params, m_Queue, handle->loop);

(

<< server.address <<

);

available_servers = 0;

(

& server : m_Sessions) {

server.current_rate = server->rate.load();

(server.current_rate) {

++available_servers;

remaining_submits = m_Params.max_concurrent_submits.Get();

= m_Sessions.begin();

[timed_req, processor_id, req] = decltype(m_Queue.Pop()){};

d = m_Random.first;

request_rate = 0.0;

target_rate = 0.0;

get_request = [&, &timed_req = timed_req, &processor_id = processor_id, &req = req]() {

tie(timed_req, processor_id, req) = m_Queue.Pop();

target_rate = d(m_Random.second);

(req_id = req->reply->debug_printout.id;);

(

<< req_id <<

);

next_server = [&]() {

(++

== m_Sessions.end())

= m_Sessions.begin();

ignore_server = [&]() {

(--available_servers) {

d = uniform_real_distribution<>(0.0, d.max() -

->current_rate);

->current_rate = 0.0;

find_session = [&]() {

s =

->sessions.begin();

(; (s !=

->sessions.end()) && s->IsFull(); ++s);

make_pair(s !=

->sessions.end(), s);

(available_servers && remaining_submits) {

(!req && !get_request()) {

(; request_rate +=

->current_rate, request_rate < target_rate; next_server());

& server = *

;

(server->throttling.Active()) {

(

<< server->address <<

);

}

(server->available_streams <= 0) {

(

<< server->address <<

);

}

(

[found, session] = find_session(); !found) {

(

<< server->address <<

);

}

(!session->CanProcessRequest(req)) {

(

<< session->GetId() <<

);

req->submitted_by.Reset();

}

(!session->ProcessRequest(*std::move(timed_req), processor_id, std::move(req))) {

(

<< session->GetId() <<

<< req_id <<

<< target_rate);

(

<< session->GetId() <<

<< req_id <<

<< target_rate);

--remaining_submits;

(session->IsFull() && (distance(session, server.sessions.end()) == 1)) {

(server.sessions.size() >= max_sessions) {

(

<< server->address <<

);

server.sessions.emplace_back(*server, m_Params, m_Queue, handle->loop);

(

<< server->address <<

);

m_Queue.Emplace(*std::move(timed_req));

(!remaining_submits) {

(

<< m_Params.max_concurrent_submits);

(

<< m_Params.max_concurrent_submits - remaining_submits);

kRegularRate = nextafter(0.009, 1.0);

kStandbyRate = 0.001;

& service_name = m_Service.GetServiceName();

discovered = m_Service();

total_preferred_regular_rate = 0.0;

total_preferred_standby_rate = 0.0;

total_regular_rate = 0.0;

total_standby_rate = 0.0;

(

& server : discovered) {

(server.second >= kRegularRate) {

(is_server_preferred) {

total_preferred_regular_rate += server.second;

total_regular_rate += server.second;

}

(server.second >= kStandbyRate) {

(is_server_preferred) {

total_preferred_standby_rate += server.second;

total_standby_rate += server.second;

(m_NoServers(total_regular_rate || total_standby_rate, SUv_Timer::GetThat<SUv_Timer>(handle))) {

(

<< service_name <<

);

localhost_preference = TPSG_LocalhostPreference::GetDefault();

total_preferred_standby_percentage = localhost_preference ? 1.0 - 1.0 / localhost_preference : 0.0;

have_any_regular_servers = total_regular_rate > 0.0;

have_nonpreferred_regular_servers = total_regular_rate > total_preferred_regular_rate;

have_nonpreferred_standby_servers = total_standby_rate > total_preferred_standby_rate;

regular_rate_adjustment =

(localhost_preference <= 1) ||

(total_preferred_regular_rate != 0.0) ||

(total_preferred_standby_rate == 0.0) ||

(!have_nonpreferred_regular_servers && !have_nonpreferred_standby_servers);

rate_total = 0.0;

(

& server : discovered) {

old_rate = server.second;

(server.second >= kRegularRate) {

(is_server_preferred) {

(regular_rate_adjustment) {

server.second *= localhost_preference;

}

(have_nonpreferred_regular_servers) {

server.second = 0.0;

}

(have_nonpreferred_standby_servers) {

server.second = 0.0;

(regular_rate_adjustment) {

}

(have_nonpreferred_regular_servers) {

server.second *= (1 - total_preferred_standby_percentage) / total_regular_rate;

}

(have_nonpreferred_standby_servers) {

server.second = 0.0;

}

(server.second >= kStandbyRate) {

(is_server_preferred) {

(regular_rate_adjustment && have_any_regular_servers) {

server.second = 0.0;

}

(regular_rate_adjustment) {

server.second *= localhost_preference;

}

(have_nonpreferred_regular_servers) {

server.second *= total_preferred_standby_percentage / total_preferred_standby_rate;

}

(have_nonpreferred_standby_servers) {

server.second *= total_preferred_standby_percentage / total_preferred_standby_rate;

(regular_rate_adjustment && have_any_regular_servers && (localhost_preference || have_nonpreferred_regular_servers)) {

server.second = 0.0;

}

(regular_rate_adjustment) {

}

(have_nonpreferred_regular_servers) {

server.second = 0.0;

}

(have_nonpreferred_standby_servers) {

server.second *= (1 - total_preferred_standby_percentage) / (total_standby_rate - total_preferred_standby_rate);

rate_total += server.second;

(old_rate != server.second) {

(

<< server.first <<

<< old_rate <<

<< server.second);

servers_locked = m_Servers.GetLock();

& servers = *servers_locked;

(

& server : servers) {

it = find_if(discovered.begin(), discovered.end(), address_same);

(

<< server.address <<

<< service_name <<

);

server.throttling.Discovered();

rate = it->second / rate_total;

(server.rate != rate) {

(server.rate ?

:

) <<

service_name <<

<< rate);

(

& server : discovered) {

rate = server.second / rate_total;

servers.emplace_back(server.first, rate, m_Params.max_concurrent_requests_per_server, m_ThrottleParams, handle->loop);

service_name <<

<< rate);

m_QueuesRef.SignalAll();

(m_Servers->fail_requests) {

CheckRequestExpiration();

(

& server : m_Sessions) {

(

& session : server.sessions) {

session.CheckRequestExpiration();

queue_locked = m_Queue.GetLockedQueue();

list<SPSG_TimedRequest> retries;

on_retry = [&](

req) { retries.emplace_back(req); m_Queue.Signal(); };

on_fail = [&](

processor_id,

req) { req->Fail(processor_id,

); };

(

it = queue_locked->begin(); it != queue_locked->end(); ) {

(it->CheckExpiration(m_Params,

, on_retry, on_fail)) {

it = queue_locked->erase(it);

queue_locked->splice(queue_locked->end(), retries);

queue_locked = m_Queue.GetLockedQueue();

(

& timed_req : *queue_locked) {

(

[processor_id, req] = timed_req.Get(); req) {

context_guard = req->context.Set();

& debug_printout = req->reply->debug_printout;

debug_printout <<

<< endl;

req->OnReplyDone(processor_id)->SetFailed(

);

(

<< debug_printout.id <<

);

queue_locked->clear();

m_Queue.Init(

, &loop, s_OnQueue);

m_RetryDelay(

(TPSG_NoServersRetryDelay::GetDefault())),

m_Timeout(

((params.request_timeout + params.competitive_after * params.request_retries) * params.io_timer_period)),

m_FailRequests(const_cast<atomic_bool&>(servers->fail_requests))

timeout_expired = m_Passed >= m_Timeout;

m_FailRequests = timeout_expired;

}

(!timeout_expired) {

(TPSG_Stats::GetDefault()) {

make_shared<SPSG_Stats>(servers);

m_StartBarrier(

::GetDefault() + 2),

m_StopBarrier(

::GetDefault() + 1),

m_RequestCounter(0),

}

(

std::system_error& e) {

(

<<

<< e.what());

(

& io :

) {

(

.size() == 0) {

[idx].Emplace(std::move(req));

@ eEndOfReply

No more items expected in the (overall!) reply.

bool IsSingleServer() const

pair< SSocketAddress, double > TServer

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static const char * expected[]

#define _DEBUG_CODE(code)

string GetStringUID(TUID uid=0) const

Return string representation of UID.

CDiagContext & GetDiagContext(void)

Get diag context instance.

static void SetRequestContext(CRequestContext *ctx)

Shortcut to CDiagContextThreadData::GetThreadData().SetRequestContext()

static string GetStdStatusMessage(ECode code)

static CRequestContext & GetRequestContext(void)

Shortcut to CDiagContextThreadData::GetThreadData().GetRequestContext()

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

EDiagSev

Severity level for the posted diagnostics.

@ eDiag_Trace

Trace message.

@ eDiag_Info

Informational message.

@ eDiag_Error

Error message.

@ eDiag_Warning

Warning message.

@ eDiag_Fatal

Fatal error – guarantees exit(or abort)

@ eDiag_Critical

Critical error message.

@ e503_ServiceUnavailable

@ e451_Unavailable_For_Legal_Reasons

void Warning(CExceptionArgs_Base &args)

void Fatal(CExceptionArgs_Base &args)

const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)

If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...

@ eParam_Default

Default flags.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

static CNCBI_IPAddr GetLocalHostAddress(ESwitch reget=eDefault)

Local host address in network byte order (cached for faster retrieval)

static string PrintableString(const CTempString str, TPrintableMode mode=fNewLine_Quote|fNonAscii_Passthru)

Get a printable version of the specified string.

static int StringToInt(const CTempString str, TStringToNumFlags flags=0, int base=10)

Convert string to int.

static string URLDecode(const CTempString str, EUrlDecode flag=eUrlDec_All)

URL-decode string.

static bool SplitInTwo(const CTempString str, const CTempString delim, string &str1, string &str2, TSplitFlags flags=0)

Split a string into two pieces using the specified delimiters.

static string URLEncode(const CTempString str, EUrlEncode flag=eUrlEnc_SkipMarkChars)

URL-encode string.

@ fAllowTrailingSpaces

Ignore trailing whitespace characters.

@ fConvErr_NoThrow

Do not throw an exception on error.

@ fAllowLeadingSpaces

Ignore leading whitespace characters in converted string.

string GetQueryString(EAmpEncoding amp_enc, NStr::EUrlEncode encode) const

Construct and return complete query string.

@ eAmp_Char

Use & to separate arguments.

where both of them are integers Note

NCBI_PARAM_TYPE(PSG, throttle_by_connection_error_rate) TPSG_ThrottleThreshold

NCBI_PARAM_TYPE(PSG, throttle_relaxation_period) TPSG_ThrottlePeriod

const TYPE & Get(const CNamedParameterList *param)

const struct ncbi::grid::netcache::search::fields::SIZE size

const struct ncbi::grid::netcache::search::fields::CREATED created

const GenericPointer< typename T::ValueType > T2 value

int strcmp(const char *str1, const char *str2)

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

static bool less(const CSeq_feat *A, const CSeq_feat *B)

EPSG_Status

Retrieval result.

@ eSuccess

Successfully retrieved.

@ eInProgress

Retrieval is not finalized yet, more info may come.

@ eForbidden

User is not authorized for the retrieval.

@ eCanceled

Request canceled.

@ eError

An error was encountered while trying to send request or to read and to process the reply.

uint64_t s_GetStatsPeriod()

NCBI_PARAM_ENUM_DEF(EPSG_DebugPrintout, PSG, debug_printout, EPSG_DebugPrintout::eNone)

auto s_GetCode(const string &code)

NCBI_PARAM_DEF(double, PSG, request_timeout, 10.0)

auto s_GetFrameName(const nghttp2_frame *frame)

#define HTTP_STATUS_HEADER

EPSG_StatsCountersRetries

@ ePSG_StatsCountersRetries_Retry

@ ePSG_StatsCountersRetries_Timeout

uint64_t s_GetDiscoveryRepeat(const CServiceDiscovery &service)

EDiagSev s_GetSeverity(const string &severity)

PSG_PARAM_VALUE_DEF_MIN(unsigned, PSG, rd_buf_size, 64 *1024, 1024)

shared_ptr< SPSG_Stats > s_GetStats(SPSG_Servers::TTS &servers)

SPSG_IoCoordinator.

NCBI_PARAM_DEF_EX(string, PSG, service, "PSG2", eParam_Default, NCBI_PSG_SERVICE)

NCBI_PARAM_ENUM_ARRAY(EPSG_DebugPrintout, PSG, debug_printout)

#define PSG_IO_SESSION_TRACE(message)

#define PSG_THROTTLING_TRACE(message)

#define PSG_IO_TRACE(message)

#define PSG_DISCOVERY_TRACE(message)

uint64_t SecondsToMs(double seconds)

Defines CRequestStatus class for NCBI C++ diagnostic API.

static SLJIT_INLINE sljit_ins ms(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

void Print(SSocketAddress address, const string &path, const string &sid, const string &phid, const string &ip, SUv_Tcp::TPort port)

int32_t Submit(const nghttp2_nv *nva, size_t nvlen, nghttp2_data_provider *data_prd=nullptr)

void Emplace(TArgs &&... args)

void NotifyOne() volatile

bool WaitUntil(TArgs &&... args) volatile

SNoServers(const SPSG_Params &params, SPSG_Servers::TTS &servers)

bool operator()(bool discovered, SUv_Timer *timer)

void OnShutdown(uv_async_t *)

void OnTimer(uv_timer_t *handle)

SPSG_Servers::TTS & m_Servers

string GetCookie(const string &name) const

bool AddRequest(shared_ptr< SPSG_Request > req, const atomic_bool &stopped, const CDeadline &deadline)

SPSG_Servers::TTS m_Servers

SUv_Barrier m_StartBarrier

SPSG_IoCoordinator(CServiceDiscovery service)

atomic< size_t > m_RequestCounter

SUv_Barrier m_StopBarrier

TPSG_AsyncQueues m_Queues

SPSG_Thread< SPSG_DiscoveryImpl > m_Discovery

vector< unique_ptr< SPSG_Thread< SPSG_IoImpl > > > m_Io

void OnTimer(uv_timer_t *handle)

void OnQueue(uv_async_t *handle)

void CheckRequestExpiration()

void OnShutdown(uv_async_t *handle)

SPSG_IoImpl.

void OnExecute(uv_loop_t &loop)

void AddNewServers(uv_async_t *handle)

int OnStreamClose(nghttp2_session *session, int32_t stream_id, uint32_t error_code)

bool Fail(SPSG_Processor::TId processor_id, shared_ptr< SPSG_Request > req, const SUvNgHttp2_Error &error, bool refused_stream=false)

bool RetryFail(SPSG_Processor::TId processor_id, shared_ptr< SPSG_Request > req, const SUvNgHttp2_Error &error, bool refused_stream=false)

SPSG_AsyncQueue & m_Queue

SPSG_Requests< SPSG_IoSession > m_Requests

SPSG_Submitter::TId GetInternalId() const

SPSG_IoSession(SPSG_Server &s, const SPSG_Params &params, SPSG_AsyncQueue &queue, uv_loop_t *loop, TNgHttp2Cbs &&... callbacks)

SPSG_IoSession.

void CheckRequestExpiration()

bool ProcessRequest(SPSG_TimedRequest timed_req, SPSG_Processor::TId processor_id, shared_ptr< SPSG_Request > req)

int OnHeader(nghttp2_session *session, const nghttp2_frame *frame, const uint8_t *name, size_t namelen, const uint8_t *value, size_t valuelen, uint8_t flags)

void OnReset(SUvNgHttp2_Error error) override

array< SNgHttp2_Header< NGHTTP2_NV_FLAG_NO_COPY_NAME >, eSize > m_Headers

int OnData(nghttp2_session *session, uint8_t flags, int32_t stream_id, const uint8_t *data, size_t len)

int OnFrameRecv(nghttp2_session *session, const nghttp2_frame *frame)

static const string & Get()

static TValue GetDefault()

TPSG_RequestsPerIo requests_per_io

string GetCookie(function< string()> get_auth_token)

static unsigned s_GetCompetitiveAfter(double io_timer_period, double timeout)

const unsigned competitive_after

static unsigned s_GetRequestTimeout(double io_timer_period)

TPSG_IoTimerPeriod io_timer_period

const unsigned request_timeout

SPSG_Nullable< size_t > expected

vector< SPSG_Chunk > chunks

static int From(EPSG_Status status)

void SetComplete() volatile

void SetStatus(SStatus status, bool reset) volatile

void AddMessage(string message, EDiagSev severity, optional< int > code)

void AddError(string message, SStatus status=EPSG_Status::eError, EDiagSev severity=eDiag_Error, optional< int > code=nullopt)

deque< SPSG_Message > m_Messages

SPSG_Message GetMessage(EDiagSev min_severity)

shared_ptr< TPSG_Queue > queue

void SetFailed(string message, SState::SStatus status=EPSG_Status::eError)

SThreadSafe< list< SItem::TTS * > > new_items

SThreadSafe< list< SItem::TTS > > items

optional< SItem::TTS * > GetNextItem(CDeadline deadline)

unsigned GetRetries(SPSG_Retries::EType type, bool refused_stream)

unordered_map< string, SPSG_Reply::SItem::TTS * > m_ItemsByID

SPSG_Processor processed_by

bool Retry(const SUvNgHttp2_Error &error, bool refused_stream=false)

EStateResult StateData(const char *&data, size_t &len)

shared_ptr< SPSG_Reply > reply

SPSG_Request(string p, shared_ptr< SPSG_Reply > r, CRef< CRequestContext > c, const SPSG_Params &params)

bool Fail(SPSG_Processor::TId processor_id, const SUvNgHttp2_Error &error, bool refused_stream=false)

EStateResult StatePrefix(const char *&data, size_t &len)

auto & OnReplyDone(SPSG_Processor::TId processor_id)

EUpdateResult UpdateItem(SPSG_Args::EItemType item_type, SPSG_Reply::SItem &item, const SPSG_Args &args)

EStateResult StateArgs(const char *&data, size_t &len)

auto emplace(TArgs &&... args)

SPSG_Throttling throttling

const SSocketAddress address

vector< pair< atomic_uint64_t, atomic_uint > > m_Data

void Report(const char *prefix, unsigned report)

static const char * GetName(EAvgTime avg_time)

static const char * ValueName(type value)

static const char * ValueName(type value)

static const char * ValueName(type value)

static const char * ValueName(type value)

static const char * ValueName(type value)

static const char * ValueName(type value)

static void Func(TData &data)

static void Func(const TData &data, const char *prefix, unsigned report)

void Apply(EGroup start_with, TArgs &&... args)

void Report(TArgs &&... args)

vector< vector< atomic_uint > > TData

void Report(const char *prefix, unsigned report, const char *name)

SData< CPSG_BlobId > m_Blobs

void Report(const char *prefix, unsigned report)

SThreadSafe< unordered_set< string > > m_TSEs

SData< CPSG_ChunkId > m_Chunks

SPSG_Servers::TTS & m_Servers

SPSG_Stats(SPSG_Servers::TTS &servers)

SThreshold(string error_rate)

SPSG_ThrottleParams.

constexpr static size_t kMaxDenominator

TPSG_ThrottleUntilDiscovery until_discovery

const volatile uint64_t period

TPSG_ThrottleMaxFailures max_failures

pair< bitset< SPSG_ThrottleParams::SThreshold::kMaxDenominator >, size_t > threshold_reg

bool Adjust(const SSocketAddress &address, bool result)

SPSG_ThrottleParams params

SPSG_Throttling(const SSocketAddress &address, SPSG_ThrottleParams p, uv_loop_t *l)

SPSG_Throttling.

atomic< EThrottling > m_Active

SThreadSafe< SStats > m_Stats

static void s_OnSignal(uv_async_t *handle)

const SSocketAddress & m_Address

bool CheckExpiration(const SPSG_Params &params, const SUvNgHttp2_Error &error, TOnRetry on_retry, TOnFail on_fail)

static SUvNgHttp2_Error FromNgHttp2(T e, const char *w)

static const char * NgHttp2Str(T e)

SNgHttp2_Session m_Session

void Reset(SUvNgHttp2_Error error, SUv_Tcp::ECloseType close_type=SUv_Tcp::eCloseReset, bool shutdown=false)

pair< string, string > TCred

static const string & Get()

void Init(void *d, uv_loop_t *l, uv_async_cb cb)

TPort GetLocalPort() const

uint64_t GetDefaultRepeat() const

void SetRepeat(uint64_t r)

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

static CS_CONTEXT * context

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4