static axiom_node_t * AXIS2_CALL Axis2Service_on_fault( axis2_svc_skeleton_t*, const axutil_env_t* pEnv, axiom_node_t* /*pNode*/) { staff::ScopedLock tLock(m_tFaultDetailsMutex); std::map<unsigned long, std::string>::iterator itFault = m_mFaultDetails.find(staff::Thread::GetCurrentId()); axiom_node_t* pErrorNode = NULL; axiom_element_t* pErrorElement = axiom_element_create(pEnv, NULL, "Exception", NULL, &pErrorNode); if (itFault != m_mFaultDetails.end()) { axiom_element_set_text(pErrorElement, pEnv, itFault->second.c_str(), pErrorNode); m_mFaultDetails.erase(itFault); } else { axiom_element_set_text(pErrorElement, pEnv, "No fault details", pErrorNode); } return pErrorNode; }
/********************************************************** Pauses of restarts RX activity. Restart is immediate, pause may be delayed until NDIS returns all the indicated NBL Parameters: context bPause 1/0 - pause or restart ONPAUSECOMPLETEPROC Callback to be called when PAUSE finished Return value: SUCCESS if finished synchronously PENDING if not, then callback will be called ***********************************************************/ NDIS_STATUS ParaNdis6_ReceivePauseRestart( PARANDIS_ADAPTER *pContext, BOOLEAN bPause, ONPAUSECOMPLETEPROC Callback ) { NDIS_STATUS status = NDIS_STATUS_SUCCESS; if (bPause) { CNdisPassiveWriteAutoLock tLock(pContext->m_PauseLock); ParaNdis_DebugHistory(pContext, hopInternalReceivePause, NULL, 1, 0, 0); if (pContext->m_rxPacketsOutsideRing != 0) { pContext->ReceiveState = srsPausing; pContext->ReceivePauseCompletionProc = Callback; status = NDIS_STATUS_PENDING; } else { ParaNdis_DebugHistory(pContext, hopInternalReceivePause, NULL, 0, 0, 0); pContext->ReceiveState = srsDisabled; } } else { ParaNdis_DebugHistory(pContext, hopInternalReceiveResume, NULL, 0, 0, 0); pContext->ReceiveState = srsEnabled; } return status; }
//任务分发 void dispatch() { while (mRunning.load()) { std::unique_lock<std::mutex> tLock(mMutex); mCondition.wait(tLock, [this]() { return !mTasks.Empty(); }); Task task{std::move(mTasks.Front())}; mTasks.Pop(); //删掉队列的头元素 task(); } }
/********************************************************** Pauses of restarts TX activity. Restart is immediate, pause may be delayed until we return all the NBLs to NDIS Parameters: context bPause 1/0 - pause or restart ONPAUSECOMPLETEPROC Callback to be called when PAUSE finished Return value: SUCCESS if finished synchronously PENDING if not, then callback will be called later ***********************************************************/ NDIS_STATUS ParaNdis6_SendPauseRestart( PARANDIS_ADAPTER *pContext, BOOLEAN bPause, ONPAUSECOMPLETEPROC Callback ) { NDIS_STATUS status = NDIS_STATUS_SUCCESS; DEBUG_ENTRY(4); if (bPause) { ParaNdis_DebugHistory(pContext, hopInternalSendPause, NULL, 1, 0, 0); if (pContext->SendState == srsEnabled) { { CNdisPassiveWriteAutoLock tLock(pContext->m_PauseLock); pContext->SendState = srsPausing; pContext->SendPauseCompletionProc = Callback; } for (UINT i = 0; i < pContext->nPathBundles; i++) { if (!pContext->pPathBundles[i].txPath.Pause()) { status = NDIS_STATUS_PENDING; } } if (status == NDIS_STATUS_SUCCESS) { pContext->SendState = srsDisabled; } } if (status == NDIS_STATUS_SUCCESS) { ParaNdis_DebugHistory(pContext, hopInternalSendPause, NULL, 0, 0, 0); } } else { pContext->SendState = srsEnabled; ParaNdis_DebugHistory(pContext, hopInternalSendResume, NULL, 0, 0, 0); } return status; }
/* * This method invokes the target service method */ static axiom_node_t* AXIS2_CALL Axis2Service_invoke(axis2_svc_skeleton_t* /*pServiceSkeleton*/, const axutil_env_t* pEnv, axiom_node_t* pAxiomNode, axis2_msg_ctx_t* pMsgCtx) { if (pAxiomNode == NULL) { staff::LogError() << "AxiOM node is NULL\n"; return NULL; } if (axiom_node_get_node_type(pAxiomNode, pEnv) != AXIOM_ELEMENT) { staff::LogError() << "Can't get AxiOM node type"; return NULL; } axiom_element_t* pAxiomElement = (axiom_element_t*)axiom_node_get_data_element(pAxiomNode, pEnv); if (pAxiomElement == NULL) { staff::LogError() << "Can't get AxiOM node element\n"; return NULL; } const axis2_char_t* szServiceName = reinterpret_cast<const axis2_char_t*> (axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "ServiceName")); #ifndef WITHOUT_SECURITY const axis2_char_t* szSessionId = reinterpret_cast<const axis2_char_t*> (axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "SessionId")); const axis2_char_t* szInstanceId = reinterpret_cast<const axis2_char_t*> (axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "InstanceId")); #endif if (szServiceName == NULL) { staff::LogError() << "Cannot process message: Failed to get service name."; return NULL; } #ifndef WITHOUT_SECURITY if (szSessionId == NULL) { staff::LogError() << "Cannot process message: Failed to get session id."; return NULL; } if (szInstanceId == NULL) { staff::LogError() << "Cannot process message: Failed to get instance id."; return NULL; } #endif #ifdef _DEBUG staff::LogDebug1() << "Service name: [" << szServiceName << "]"; #ifndef WITHOUT_SECURITY staff::LogDebug1() << "Session id: [" << szSessionId << "]"; staff::LogDebug1() << "Instance id: [" << szInstanceId << "]"; #endif { axiom_node_t* panBody = axiom_node_get_parent(pAxiomNode, pEnv); axiom_node_t* panEnv = axiom_node_get_parent(panBody, pEnv); staff::LogDebug2() << "request SOAP Envelope: \n" << staff::ColorTextBlue << staff::DataObject(panEnv).ToString() << "\n" << staff::ColorDefault; } #endif staff::Operation tOperation; staff::MessageContext tMessageContext(pEnv, pMsgCtx); std::string sServiceName(szServiceName); #ifndef WITHOUT_SECURITY std::string sSessionId(szSessionId); std::string sInstanceId(szInstanceId); #else static std::string sSessionId; static std::string sInstanceId; #endif try { tOperation.SetRequest(pAxiomNode); tOperation.SetMessageContext(tMessageContext); if (axis2_msg_ctx_get_doing_rest(pMsgCtx, pEnv)) { const axis2_char_t* szOperation = reinterpret_cast<const axis2_char_t*> (axis2_msg_ctx_get_property_value(pMsgCtx, pEnv, "Operation")); if (szOperation != NULL) { tOperation.SetName(szOperation); } } if (sServiceName == "StaffService") { staff::ServiceDispatcher::Inst().InvokeSelf(tOperation); } else { staff::ServiceWrapper* pServiceWrapper = staff::SharedContext::Inst().GetService(sServiceName); STAFF_ASSERT(pServiceWrapper, "Service [" + sServiceName + "] is not found: "); pServiceWrapper->Invoke(tOperation, sSessionId, sInstanceId); } } catch (const staff::SoapUserFaultException& rEx) { try { staff::DataObject tdoFault; tdoFault.FromString(rEx.GetFault()); tOperation.SetUserFault(tdoFault); } catch (...) { tOperation.SetFault("server", "Invalid format of user soap fault", "Failed to invoke service " + sServiceName + "." + tOperation.GetName() #ifndef WITHOUT_SECURITY + "#" + sInstanceId + "(" + sSessionId + ")" #endif ); } } catch (const staff::SoapFaultException& rEx) { tOperation.SetFault(rEx.GetCode(), rEx.GetString(), rEx.GetDetail()); } catch (const std::exception& rEx) { tOperation.SetFault("server", rEx.what(), "Failed to invoke service " + sServiceName + "." + tOperation.GetName() #ifndef WITHOUT_SECURITY + "#" + sInstanceId + "(" + sSessionId + ")" #endif ); } catch (...) { tOperation.SetFault("server", "Unknown exception", "Failed to invoke service " + sServiceName + "." + tOperation.GetName() #ifndef WITHOUT_SECURITY + "#" + sInstanceId + "(" + sSessionId + ")" #endif ); } if (tOperation.IsFault()) { staff::ScopedLock tLock(m_tFaultDetailsMutex); m_mFaultDetails[staff::Thread::GetCurrentId()] = tOperation.GetFaultDetail(); staff::LogWarning() << "Fault: \n" << tOperation.GetFaultDescr() << "\n"; AXIS2_ERROR_SET_MESSAGE(pEnv->error, static_cast<axis2_char_t*>(axutil_strdup(pEnv, tOperation.GetFaultString().c_str()))); AXIS2_ERROR_SET_ERROR_NUMBER(pEnv->error, static_cast<axutil_error_codes_t>(AXUTIL_ERROR_MAX + 1)); AXIS2_ERROR_SET_STATUS_CODE(pEnv->error, AXIS2_FAILURE); if (!m_bHttp200OnFault) return NULL; } if(!IsNeedReply(pMsgCtx, pEnv)) { return NULL; } tOperation.PrepareResult(); staff::DataObject& rResponse = tOperation.GetResponse(); rResponse.SetOwner(false); #ifdef _DEBUG staff::LogDebug2() << "Sending Response: \n" << staff::ColorTextBlue << rResponse.ToString() << "\n" << staff::ColorDefault; #endif return rResponse; }
void processTransactions(const std::string& name, std::ifstream& in) { Transaction t; while(in >> t) { if(t.operation() == Operation::Deposit) { // Deposit routine. if(t.account() == AccountType::Checking) { std::lock_guard l(checkingLock); checking += t.amount(); std::cout << name << " deposited $" << t.amount() << ". New " << t.account() << " balance: $" << checking << std::endl; } else if(t.account() == AccountType::Savings) { std::lock_guard l(savingsLock); savings += t.amount(); std::cout << name << " deposited $" << t.amount() << ". New " << t.account() << " balance: $" << savings << std::endl; } } else if(t.operation() == Operation::Withdrawal) { // Withdraw routine. // Lock whichever account is being accessed. if(t.account() == AccountType::Checking) { std::lock_guard l(checkingLock); if(t.amount() > checking) { // Lock both accounts if transfering. std::lock_guard transferL(transferLock); std::lock_guard savingsL(savingsLock); if(savings > 0) { savings += checking; checking = 0; savings -= t.amount(); std::cout << name << " withdrew $" << t.amount() << "." << std::endl; printBalances(); } else { std::cout << name << " cannot withdraw $" << t.amount() << ". Insufficient funds." << std::endl; } } else { checking -= t.amount(); std::cout << name << " withdrew $" << t.amount() << ". New " << t.account() << " balance: $" << checking << std::endl; } } else if(t.account() == AccountType::Savings) { std::lock_guard l(savingsLock); if(savings > 0) { savings -= t.amount(); std::cout << name << " withdrew $" << t.amount() << ". New" << t.account() << " balance: $" << savings << std::endl; } else { std::cout << name << " cannot withdraw $" << t.amount() << ". Insufficient funds." << std::endl; } } } else if(t.operation() == Operation::Transfer) { // Transfer routine. // Lock both accounts when transfering. std::lock_guard tLock(transferLock); std::lock_guard cLock(checkingLock); std::lock_guard sLock(savingsLock); if(t.account() == AccountType::Checking) { if(savings > 0) { checking += t.amount(); savings -= t.amount(); std::cout << name << " transferred $" << t.amount() << " from savings to checking." << std::endl; printBalances(); } else { std::cout << name << " cannot transfer $" << t.amount() << ". Insufficient funds." << std::endl; } } else if(t.account() == AccountType::Savings) { if(checking > 0) { checking -= t.amount(); savings += t.amount(); std::cout << name << " transferred $" << t.amount() << " from checking to savings." << std::endl; printBalances(); } else { std::cout << name << " cannot transfer $" << t.amount() << ". Insufficient funds." << std::endl; } } } } return; }