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

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

NCBI C++ ToolKit: src/app/pubseq_gateway/server/psgs_dispatcher.cpp Source File

request_id = (size_t)(handle->data);

app->GetProcessorDispatcher()->OnRequestTimer(request_id);

request_id = (size_t)(handle->data);

app->GetProcessorDispatcher()->OnRequestTimerClose(request_id);

request_id = (size_t)(user_data);

app->GetProcessorDispatcher()->EraseProcessorGroup(request_id);

processor_group_name = processor->GetGroupName();

processor_group_name);

<< processor_group_name <<

);

limit = app->GetProcessorMaxConcurrency(processor_group_name);

ret[

->GetGroupName()] = index;

shared_ptr<CPSGS_Reply> reply)

(

->CanProcess(request, reply)) {

ret.push_back(

->GetName());

(request->NeedTrace()) {

reply->SendTrace(

->GetName() +

,

request->GetStartTimestamp(),

);

(request->NeedTrace()) {

reply->SendTrace(

->GetName() +

,

request->GetStartTimestamp(),

);

=

;

request->GetStartTimestamp());

reply->SetCompleted();

list<shared_ptr<IPSGS_Processor>>

shared_ptr<CPSGS_Reply> reply,

list<string> & processor_names)

(processor_names.empty()) {

);

list<shared_ptr<IPSGS_Processor>> ret;

request_id = request->GetRequestId();

(find(processor_names.begin(), processor_names.end(),

->GetName()) == processor_names.end()) {

proc_index = proc_count - priority;

(current_count >= limit) {

request->AddLimitedProcessor(

->GetName(), limit);

(request->NeedTrace()) {

reply->SendTrace(

+

->GetName() +

+ to_string(limit) +

+ to_string(current_count),

request->GetStartTimestamp(),

);

(

& name :

->WhatCanProcess(request, reply)) {

(request->NeedTrace()) {

reply->SendTrace(

+

->GetName(),

request->GetStartTimestamp(),

);

shared_ptr<IPSGS_Processor> p(

->CreateProcessor(request, reply,

p->SetUVThreadId(uv_thread_self());

procs->m_Processors.emplace_back(p,

,

(request->NeedTrace()) {

reply->SendTrace(

+ p->GetName() +

+

to_string(priority) +

,

request->GetStartTimestamp(),

);

(request->NeedTrace()) {

reply->SendTrace(

+

->GetName() +

,

request->GetStartTimestamp(),

);

limited_processor_count = request->GetLimitedProcessorCount();

request->SetRequestContext();

(limited_processor_count == 0) {

=

;

= to_string(limited_processor_count) +

+

to_string(processor_names.size()) +

+

request->GetLimitedProcessorsMessage() +

;

reply->PrepareReplyMessage(

, status_code,

reply->PrepareReplyCompletion(status_code,

request->GetStartTimestamp());

reply->SetCompleted();

* grp = procs.release();

unique_ptr<SProcessorGroup>> req_grp = make_pair(request_id,

unique_ptr<SProcessorGroup>(grp));

need_trace = processor->

()->NeedTrace();

request_id = processor->

()->GetRequestId();

vector<IPSGS_Processor *> to_be_canceled;

+ processor->

() +

+

,

processor->

()->GetStartTimestamp(),

(

&

: procs->second->m_Processors) {

(

.m_Processor.get() == processor) {

(

);

(

&

: procs->second->m_Processors) {

current_proc =

.m_Processor.get();

(current_proc != processor) {

to_be_canceled.push_back(current_proc);

procs->second->m_StartedProcessing = processor;

(

&

: to_be_canceled) {

+

->GetName() +

+ to_string(

->GetPriority()) +

,

processor->

()->GetStartTimestamp(),

);

(

<< uv_thread_self() <<

<< processor->

() <<

reply = processor->

();

request_id = request->GetRequestId();

need_trace = request->NeedTrace();

started_processor_finished =

;

vector<IPSGS_Processor::EPSGS_Status> proc_statuses;

finishing_count = 0;

finished_count = 0;

+

+ processor->

() +

+ to_string(processor->

()) +

+

,

(

&

: procs->second->m_Processors) {

proc_statuses.push_back(

.m_Processor->GetStatus());

(

.m_Processor.get() == processor) {

(

.m_DoneStatusRegistered ==

) {

.m_DoneStatusRegistered =

;

(

.m_ProcPerformanceRegistered ==

) {

.m_ProcPerformanceRegistered =

;

(processor_status !=

.m_LastReportedTraceStatus) {

.m_LastReportedTraceStatus = processor_status;

+ processor->

() +

+ to_string(processor->

()) +

+

(

.m_DispatchStatus) {

(

.m_DispatchStatus) {

+ processor->

() +

+ to_string(processor->

()) +

+

+

.m_FinishStatus = processor_status;

+ processor->

() +

+ to_string(processor->

()) +

+

+

+ to_string(processor->

()) +

+

(processor == procs->second->m_StartedProcessing) {

started_processor_finished =

;

(

.m_DispatchStatus) {

= procs->second->m_Processors.size();

pre_finished = (finished_count + finishing_count) ==

;

fully_finished = finished_count ==

;

need_unlock =

;

safe_to_delete =

;

(fully_finished) {

procs->second->m_AllProcessorsFinished =

;

safe_to_delete = procs->second->IsSafeToDelete();

procs->second->StopRequestTimer();

(procs->second->m_StartedProcessing ==

) {

started_processor_finished =

;

(!reply->IsFinished() && reply->IsOutputReady() && started_processor_finished) {

procs->second->m_LowLevelClose);

procs->second->m_LowLevelClose);

+ to_string(request_status) +

,

reply->PrepareReplyCompletion(request_status,

request->GetStartTimestamp());

procs->second->m_FinallyFlushed =

;

procs->second->m_RequestStopPrinted =

;

need_unlock =

;

reply->SetCompleted();

(safe_to_delete) {

app->GetUvLoopBinder(processor->

()).PostponeInvoke(

vector<IPSGS_Processor *> to_be_canceled;

(

&

: procs->second->m_Processors) {

to_be_canceled.push_back(

.m_Processor.get());

(

&

: to_be_canceled) {

request_type = request->GetRequestType();

(request_type) {

counters.Increment(

,

counters.Increment(

,

counters.Increment(

,

counters.Increment(

,

counters.Increment(

,

counters.Increment(

,

counters.Increment(

,

request->SetRequestContext();

shared_ptr<CPSGS_Reply> reply,

vector<IPSGS_Processor::EPSGS_Status> proc_statuses,

low_level_close)

(low_level_close) {

count_200 = 0;

count_404_or_cancel = 0;

count_timeout = 0;

count_unauthorized = 0;

(

status: proc_statuses) {

++count_404_or_cancel;

++count_unauthorized;

count_limited_procs = request->GetLimitedProcessorCount();

(count_404_or_cancel == proc_statuses.size() &&

count_limited_procs == 0) {

(count_unauthorized > 0) {

(count_timeout > 0) {

(count_limited_procs > 0) {

=

+

to_string(count_limited_procs) +

+

request->GetLimitedProcessorsMessage() +

;

shared_ptr<CPSGS_Request> request,

shared_ptr<CPSGS_Reply> reply,

low_level_close)

(low_level_close) {

(

& item : processed_names) {

not_found_names.

(item.second);

error_names.

(item.second);

overall_status = 200;

count_200 = 0;

(

& name : annot_request->

) {

(annot_request->

(name)) {

result_per_na[name] = 200;

it = error_names.

(name);

(not_found_names.

(name) != not_found_names.

() &&

it == error_names.

()) {

result_per_na[name] = 404;

(it != error_names.

()) {

result_per_na[name] = it->second;

overall_status =

(overall_status, it->second);

result_per_na[name] = 404;

(!low_level_close) {

reply->SendPerNamedAnnotationResults(

(result_per_na));

(overall_status == 200) {

(count_200 == 0) {

overall_status = 404;

shared_ptr<CPSGS_Request> request,

shared_ptr<CPSGS_Reply> reply)

reply->SendTrace(

, request->GetStartTimestamp(),

);

shared_ptr<CPSGS_Request> request,

shared_ptr<CPSGS_Reply> reply)

request->NeedProcessorEvents()) {

reply->PrepareProcessorProgressMessage(

vector<IPSGS_Processor *> to_be_canceled;

total_procs = 0;

cancel_count = 0;

(!procs->second->m_FinallyFlushed) {

first_proc = procs->second->m_Processors[0].m_Processor.get();

total_procs = procs->second->m_Processors.size();

(

&

: procs->second->m_Processors) {

(!proc_names.empty())

proc_names +=

;

proc_names +=

.m_Processor->GetName() +

to_be_canceled.push_back(

.m_Processor.get());

procs->second->m_LowLevelClose =

;

(total_procs > 0) {

first_proc->

()->SetRequestContext();

request_name = first_proc->

()->GetName();

(cancel_count > 0) {

(

+

to_string(cancel_count) +

+

to_string(total_procs) +

+ to_string(connection_id) +

+ request_name +

+ to_string(request_id) +

+ proc_names +

);

(

+

to_string(total_procs) +

+ to_string(connection_id) +

+ request_name +

+ to_string(request_id) +

+ proc_names +

);

(

&

: to_be_canceled) {

(first_proc !=

) {

app->GetUvLoopBinder(first_proc->

()).PostponeInvoke(

vector<IPSGS_Processor *> to_be_canceled;

(

bucket_index = 0; bucket_index <

; ++bucket_index) {

(

&

: procs.second->m_Processors) {

to_be_canceled.push_back(

.m_Processor.get());

(

&

: to_be_canceled) {

to_be_canceled.clear();

vector<IPSGS_Processor *> to_be_canceled;

vector<SProcessorData> & processors = procs->second->m_Processors;

* first_processor = processors.front().m_Processor.get();

reply = first_processor->GetReply();

request = first_processor->GetRequest();

from_last_activity_to_now_ms =

reply->GetTimespanFromLastActivityToNowMks() / 1000;

(request->NeedTrace()) {

reply->SendTrace(

+

+ to_string(from_last_activity_to_now_ms) +

,

request->GetStartTimestamp(),

);

procs->second->RestartTimer(timeout);

(request->NeedTrace()) {

reply->SendTrace(

+

,

request->GetStartTimestamp(),

);

reply->PrepareRequestTimeoutMessage(

+

(

&

: procs->second->m_Processors) {

to_be_canceled.push_back(

.m_Processor.get());

(

&

: to_be_canceled) {

procs->second->m_Libh2oFinished =

;

(procs->second->IsSafeToDelete()) {

processor = procs->second->m_Processors[0].m_Processor;

(processor->IsUVThreadAssigned()) {

app->GetUvLoopBinder(processor->GetUVThreadId()).PostponeInvoke(

(!procs->second->IsSafeToDelete()) {

(!procs->second->m_RequestStopPrinted) {

(procs->second->m_LowLevelClose) {

processor = procs->second->m_Processors.begin()->m_Processor;

reply = processor->GetReply();

request = processor->GetRequest();

procs->second->m_LowLevelClose);

vector<IPSGS_Processor::EPSGS_Status> proc_statuses;

(

&

: procs->second->m_Processors) {

proc_statuses.push_back(

.m_Processor->GetStatus());

procs->second->m_LowLevelClose);

procs->second->m_RequestStopPrinted =

;

(

& proc_data : procs->second->m_Processors) {

(!per_proc.empty())

per_proc +=

+ proc_data.m_Processor->GetName() +

+ to_string(proc_data.m_DispatchStatus) +

+ to_string(proc_data.m_FinishStatus) +

+ to_string(proc_data.m_DoneStatusRegistered) +

+ to_string(proc_data.m_ProcPerformanceRegistered) +

started_proc =

;

(procs->second->m_StartedProcessing)

started_proc += procs->second->m_StartedProcessing->GetName();

started_proc +=

;

(

+ to_string(request_id) +

+ to_string(procs->second->m_TimerActive) +

+ to_string(procs->second->m_TimerClosed) +

+ to_string(procs->second->m_FinallyFlushed) +

+ to_string(procs->second->m_AllProcessorsFinished) +

+ to_string(procs->second->m_Libh2oFinished) +

+ to_string(procs->second->m_LowLevelClose) +

+ to_string(procs->second->m_Processors.size()) +

+ started_proc +

);

first_processor = procs->second->m_Processors.begin()->m_Processor;

request_type = first_processor->GetRequest()->GetRequestType();

group = procs->second.release();

(group !=

) {

procs->second->m_TimerClosed =

;

(procs->second->IsSafeToDelete()) {

proc_priority = processor->

();

proc_index = proc_count - proc_priority;

current_count;

limit_reached_count;

&limit_reached_count);

found =

;

(

index=0; index <

; ++index) {

* first_proc = processors_group.second->m_Processors[0].m_Processor.get();

shared_ptr<CPSGS_Request> request = first_proc->

();

proc_group.

(

, request->Serialize());

proc_group.

(

, processors_group.second->m_TimerActive);

proc_group.

(

, processors_group.second->m_TimerClosed);

proc_group.

(

, processors_group.second->m_FinallyFlushed);

proc_group.

(

, processors_group.second->m_AllProcessorsFinished);

proc_group.

(

, processors_group.second->m_Libh2oFinished);

proc_group.

(

, processors_group.second->m_LowLevelClose);

proc_group.

(

, processors_group.second->IsSafeToDelete());

(processors_group.second->m_StartedProcessing ==

)

proc_group.

(

);

proc_group.

(

, processors_group.second->m_StartedProcessing->GetName());

now = psg_clock_t::now();

(

& processor : processors_group.second->m_Processors) {

timestamp = processor.m_Processor->GetProcessInvokeTimestamp(

);

mks = chrono::duration_cast<chrono::microseconds>(now - timestamp).count();

.SetInteger(

, mks);

.SetString(

,

);

timestamp = processor.m_Processor->GetSignalStartTimestamp(

);

mks = chrono::duration_cast<chrono::microseconds>(now - timestamp).count();

.SetInteger(

, mks);

.SetString(

,

);

timestamp = processor.m_Processor->GetSignalFinishTimestamp(

);

mks = chrono::duration_cast<chrono::microseconds>(now - timestamp).count();

.SetInteger(

, mks);

.SetString(

,

);

.SetString(

,

);

.SetString(

,

);

.SetString(

,

);

.SetString(

, processor.m_Processor->GetName());

.SetString(

, processor.m_Processor->GetGroupName());

.SetInteger(

, processor.m_Processor->GetPriority());

.SetString(

,

.SetString(

,

.SetString(

,

proc_group.

(

, processors);

status.

(proc_group);

void RegisterProcessorGroupName(const string &group_name, TProcessorPriority priority)

void UnregisterActiveProcGroup(CPSGS_Request::EPSGS_Type request_type, SProcessorGroup *proc_group)

void RegisterActiveProcGroup(CPSGS_Request::EPSGS_Type request_type, SProcessorGroup *proc_group)

static CJsonNode NewArrayNode()

Create a new JSON array node.

void SetString(const string &key, const string &value)

Set a JSON object element to the specified string value.

void SetNull(const string &key)

Set a JSON object element to the specified null value.

void SetBoolean(const string &key, bool value)

Set a JSON object element to the specified boolean value.

void SetByKey(const string &key, CJsonNode::TInstance value)

For a JSON object node, insert a new element or update an existing element.

static CJsonNode NewObjectNode()

Create a new JSON object node.

void Append(CJsonNode::TInstance value)

For an array node, add a new element at the end of the array.

void RegisterProcessorPerformance(IPSGS_Processor *processor, IPSGS_Processor::EPSGS_Status proc_finish_status)

void RegisterProcessorDone(CPSGS_Request::EPSGS_Type request_type, IPSGS_Processor *processor)

void RegisterForTimeSeries(CPSGS_Request::EPSGS_Type request_type, CRequestStatus::ECode status)

void IncrementRequestStopCounter(int status)

@ ePSGS_GetBlobBySeqIdRequest

@ ePSGS_AccessionVersionHistory

@ ePSGS_GetBlobBySatSatKeyRequest

@ ePSGS_GetNamedAnnotations

void Increment(IPSGS_Processor *processor, EPSGS_CounterType counter)

void SignalFinishProcessing(IPSGS_Processor *processor, EPSGS_SignalSource source)

The processor signals that it finished one way or another; including when a processor is canceled.

bool IsGroupAlive(size_t request_id)

map< string, size_t > GetConcurrentCounters(void)

void OnRequestTimer(size_t request_id)

void AddProcessor(unique_ptr< IPSGS_Processor > processor)

Register processor (one to serve as a processor factory)

vector< string > m_RegisteredProcessorGroups

void PopulateStatus(CJsonNode &status)

CRequestStatus::ECode x_ConcludeRequestStatus(shared_ptr< CPSGS_Request > request, shared_ptr< CPSGS_Reply > reply, vector< IPSGS_Processor::EPSGS_Status > proc_statuses, bool low_level_close)

uint64_t m_RequestTimeoutMillisec

map< string, size_t > GetProcessorGroupToIndexMap(void) const

Provides a map between a processor group name and a unique zero-based index of the group.

SProcessorConcurrency m_ProcessorConcurrency[16]

void NotifyRequestFinished(size_t request_id)

void OnRequestTimerClose(size_t request_id)

CRequestStatus::ECode x_MapProcessorFinishToStatus(IPSGS_Processor::EPSGS_Status status) const

void OnLibh2oFinished(size_t request_id)

CRequestStatus::ECode x_ConcludeIDGetNARequestStatus(shared_ptr< CPSGS_Request > request, shared_ptr< CPSGS_Reply > reply, bool low_level_close)

void x_PrintRequestStop(shared_ptr< CPSGS_Request > request, CRequestStatus::ECode status, size_t bytes_sent)

void StartRequestTimer(size_t request_id)

void x_SendProgressMessage(IPSGS_Processor::EPSGS_Status finish_status, IPSGS_Processor *processor, shared_ptr< CPSGS_Request > request, shared_ptr< CPSGS_Reply > reply)

static string SignalSourceToString(EPSGS_SignalSource source)

void x_SendTrace(const string &msg, shared_ptr< CPSGS_Request > request, shared_ptr< CPSGS_Reply > reply)

list< string > PreliminaryDispatchRequest(shared_ptr< CPSGS_Request > request, shared_ptr< CPSGS_Reply > reply)

Return list of processor names which reported that they can process the request.

void x_DecrementConcurrencyCounter(IPSGS_Processor *processor)

static string ProcessorStatusToString(EPSGS_ProcessorStatus st)

void EraseProcessorGroup(size_t request_id)

size_t x_GetBucketIndex(size_t request_id) const

unordered_map< size_t, unique_ptr< SProcessorGroup > > m_ProcessorGroups[100]

void RegisterProcessorsForMomentousCounters(void)

void SignalConnectionCanceled(size_t request_id)

An http connection can be canceled so this method will be invoked for such a case.

list< shared_ptr< IPSGS_Processor > > DispatchRequest(shared_ptr< CPSGS_Request > request, shared_ptr< CPSGS_Reply > reply, const list< string > &processor_names)

Return list of processors which can be used to process the request.

IPSGS_Processor::EPSGS_StartProcessing SignalStartProcessing(IPSGS_Processor *processor)

The processor signals that it is going to provide data to the client.

list< unique_ptr< IPSGS_Processor > > m_RegisteredProcessors

@ ePSGS_AnnotationRequest

@ ePSGS_BlobBySatSatKeyRequest

@ ePSGS_IPGResolveRequest

@ ePSGS_AccessionVersionHistoryRequest

@ ePSGS_BlobBySeqIdRequest

CPSGSCounters & GetCounters(void)

COperationTiming & GetTiming(void)

static CPubseqGatewayApp * GetInstance(void)

Interface class (and self-factory) for request processor objects that can retrieve data from a given ...

virtual string GetName(void) const =0

Tells the processor name (used in logging and tracing)

static string StatusToString(EPSGS_Status status)

Converts the processor status to a string for tracing and logging purposes.

virtual EPSGS_Status GetStatus(void)=0

Tells the processor status (if it has finished or in progress)

shared_ptr< CPSGS_Reply > GetReply(void) const

Provides the reply wrapper.

uv_thread_t GetUVThreadId(void) const

Provides the libuv thread id which runs the processor.

shared_ptr< CPSGS_Request > GetRequest(void) const

Provides the user request.

bool IsUVThreadAssigned(void) const

Tells if a libuv thread id has been assigned to the processor.

EPSGS_StartProcessing

Tells wether to continue or not after a processor called SignalStartProcessing() method.

TProcessorPriority GetPriority(void) const

Provides the processor priority.

EPSGS_Status

The GetStatus() method returns a processor current status.

static string StatusToProgressMessage(EPSGS_Status status)

Converts the processor status to a string for protocol message.

const_iterator end() const

const_iterator find(const key_type &key) const

const_iterator find(const key_type &key) const

const_iterator end() const

static bool is_valid(const char *num, int type, CONV_RESULT *cr)

void PrintRequestStop(void)

Print request stop message (for request-driven applications)

void SetBytesWr(Int8 bytes)

CDiagContext & GetDiagContext(void)

Get diag context instance.

static void SetRequestContext(CRequestContext *ctx)

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

static CRequestContext & GetRequestContext(void)

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

void SetRequestStatus(int status)

#define ERR_POST(message)

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

void Reset(void)

Reset all properties to the initial state.

@ eDiag_Error

Error message.

@ e499_BrokenConnection

Non-standard status code - used to indicate broken connection while serving normal request.

@ e503_ServiceUnavailable

@ e500_InternalServerError

void Critical(CExceptionArgs_Base &args)

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

const CharType(& source)[N]

static unsigned long int total_count

void request_timer_cb(uv_timer_t *handle)

bool g_AllowProcessorTiming

void erase_processor_group_cb(void *user_data)

void request_timer_close_cb(uv_handle_t *handle)

#define MAX_PROCESSOR_GROUPS

string ToJsonString(const CBioseqInfoRecord &bioseq_info, SPSGS_ResolveRequest::TPSGS_BioseqIncludeData include_data_flags, const string &custom_blob_id)

#define PSG_ERROR(message)

#define PSG_WARNING(message)

@ ePSGS_NotFoundAndNotInstantiated

psg_clock_t::time_point psg_time_point_t

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

size_t GetCurrentCount(void) const

void IncrementLimitReachedCount(void)

void IncrementCurrentCount(void)

void DecrementCurrentCount(void)

void GetCurrentAndLimitReachedCounts(size_t *current, size_t *limit_reached)

bool WasSent(const string &annot_name) const

map< string, int > GetErrorNames(void) const

set< string > GetNotFoundNames(void) const

vector< pair< TProcessorPriority, string > > GetProcessedNames(void) const

void ReportResultStatus(const string &annot_name, EPSGS_ResultStatus rs)

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