bool SmallNineAndroid::OnChangeBanker(const void* pBuffer, WORD wDataSize)
{
if (wDataSize!=sizeof(CMD_S_ChangeBanker))
return true;
CMD_S_ChangeBanker* pChangeBanker = (CMD_S_ChangeBanker *)pBuffer;
if (isSelf(m_wCurBanker))
{
SUser* pUser = GetUserInfo();
CString szMessage;
szMessage.Format("[%d][%d]下庄完成 做庄次数%d 成绩%I64d", pUser->dwUserID,
pUser->dwGameID, pUser->wCurUpBanker, pUser->nBankerCurWin);
LogEvent(szMessage, TraceLevel_Debug);
pUser->wCurUpBanker = 0;
pUser->nBankerCurWin = 0;
BankerManager::GetSingleton().Remove(pUser->dwUserID);
}
m_wCurBanker = pChangeBanker->wChairID;
m_nBankerScore = pChangeBanker->lBankerTreasure;
return true;
}
/**
* Calculates and sets the size of the widget for a synchronous message.
*/
void MessageWidget::calculateDimensionsSynchronous()
{
int x = 0;
int x1 = m_pOw[Uml::RoleType::A]->centerX();
int x2 = m_pOw[Uml::RoleType::B]->centerX();
int widgetWidth = 0;
if(isSelf()) {
widgetWidth = 50;
x = x1 - 2;
} else if(x1 < x2) {
x = x1;
widgetWidth = x2 - x1 + 8;
} else {
x = x2 - 8;
widgetWidth = x1 - x2 + 8;
}
QSizeF minSize = minimumSize();
int widgetHeight = 0;
if (height() < minSize.height()) {
widgetHeight = minSize.height();
} else {
widgetHeight = height();
}
setX(x);
setSize(widgetWidth, widgetHeight);
}
/**
* Draws the calling arrow with filled in arrowhead, the
* timeline box and the returning arrow with a dashed line and
* stick arrowhead.
*/
void MessageWidget::paintSynchronous(QPainter *painter, const QStyleOptionGraphicsItem *option)
{
int x1 = m_pOw[Uml::RoleType::A]->x();
int x2 = m_pOw[Uml::RoleType::B]->x();
int w = width() - 1;
int h = height();
int offsetX = 0;
int offsetY = 0;
bool messageOverlaps = m_pOw[Uml::RoleType::A]->messageOverlap(y(), this);
const int boxWidth = 17;
const int wr = w < boxWidth ? w : boxWidth;
const int arrowWidth = 4;
if(isSelf()) {
painter->fillRect(offsetX, offsetY, wr, h, QBrush(Qt::white)); //box
painter->drawRect(offsetX, offsetY, wr, h); //box
offsetX += wr;
w -= wr;
offsetY += 3;
const int lowerLineY = offsetY + h - 6;
// draw upper line segment (leaving the life line)
painter->drawLine(offsetX, offsetY, offsetX + w, offsetY);
// draw line segment parallel to (and at the right of) the life line
painter->drawLine(offsetX + w, offsetY, offsetX + w, lowerLineY);
// draw lower line segment (back to the life line)
paintArrow(painter, offsetX, lowerLineY, w, Qt::LeftArrow);
offsetX -= wr;
offsetY -= 3;
} else if(x1 < x2) {
if (messageOverlaps) {
offsetX += 8;
w -= 8;
}
QPen pen = painter->pen();
int startX = offsetX + w - wr + 1;
painter->fillRect(startX, offsetY, wr, h, QBrush(Qt::white)); //box
painter->drawRect(startX, offsetY, wr, h); //box
painter->drawLine(offsetX, offsetY + arrowWidth, startX, offsetY + arrowWidth); //arrow line
if (w > boxWidth + arrowWidth)
paintSolidArrowhead(painter, startX - 1, offsetY + arrowWidth, Qt::RightArrow);
paintArrow(painter, offsetX, offsetY + h - arrowWidth + 1, w - wr + 1, Qt::LeftArrow, true); // return arrow
if (messageOverlaps) {
offsetX -= 8; //reset for drawSelected()
}
} else {
if (messageOverlaps) {
w -=8;
}
QPen pen = painter->pen();
painter->fillRect(offsetX, offsetY, wr, h, QBrush(Qt::white)); //box
painter->drawRect(offsetX, offsetY, wr, h); //box
painter->drawLine(offsetX + wr + 1, offsetY + arrowWidth, offsetX + w, offsetY + arrowWidth); //arrow line
if (w > boxWidth + arrowWidth)
paintSolidArrowhead(painter, offsetX + wr, offsetY + arrowWidth, Qt::LeftArrow);
paintArrow(painter, offsetX + wr + 1, offsetY + h - arrowWidth + 1, w - wr - 1, Qt::RightArrow, true); // return arrow
}
UMLWidget::paint(painter, option);
}
int TlenMUCRecvPresence(const char *from, int status, int flags, const char *kick)
{
char str[512];
// if (JabberListExist(LIST_CHATROOM, from)) {
char *nick, *roomId, *userId;
MUCCEVENT mucce;
roomId = JabberLoginFromJID(from);
userId = JabberResourceFromJID(from);
nick = getDisplayName(userId);
mucce.cbSize = sizeof(MUCCEVENT);
mucce.pszModule = jabberProtoName;
mucce.pszID = roomId;
mucce.iType = MUCC_EVENT_STATUS;
mucce.pszUID = userId;//from;
mucce.pszNick = nick;
mucce.time = time(NULL);
mucce.bIsMe = isSelf(roomId, userId);
mucce.dwData = status;
mucce.dwFlags = 0;
if (flags & USER_FLAGS_GLOBALOWNER) mucce.dwFlags |= MUCC_EF_USER_GLOBALOWNER;
if (flags & USER_FLAGS_OWNER) mucce.dwFlags |= MUCC_EF_USER_OWNER;
if (flags & USER_FLAGS_ADMIN) mucce.dwFlags |= MUCC_EF_USER_ADMIN;
if (flags & USER_FLAGS_REGISTERED) mucce.dwFlags |= MUCC_EF_USER_REGISTERED;
if (status == ID_STATUS_OFFLINE && mucce.bIsMe && kick!=NULL) {
mucce.iType = MUCC_EVENT_ERROR;
sprintf(str, TranslateT("You have been kicked. Reason: %s "), kick);
mucce.pszText = str;
}
CallService(MS_MUCC_EVENT, 0, (LPARAM) &mucce);
mir_free(roomId);
mir_free(userId);
mir_free(nick);
// }
return 0;
}
/**
* Calculates and sets the size of the widget for an asynchronous message.
*/
void MessageWidget::calculateDimensionsAsynchronous()
{
int x = 0;
int x1 = m_pOw[Uml::RoleType::A]->centerX();
int x2 = m_pOw[Uml::RoleType::B]->centerX();
int widgetWidth = 0;
int widgetHeight = 8;
if(isSelf()) {
widgetWidth = 50;
x = x1;
if(height() < 20) {
widgetHeight = 20;
} else {
widgetHeight = height();
}
} else if(x1 < x2) {
x = x1;
widgetWidth = x2 - x1;
} else {
x = x2;
widgetWidth = x1 - x2;
}
x += 1;
widgetWidth -= 2;
setX(x);
setSize(widgetWidth, widgetHeight);
}
bool SmallNineAndroid::CanOffline()
{
if (isSelf(m_wCurBanker) || m_nChipInScore > 0)
return 0;
return true;
}
void TypeConstraint::verifyFail(const Func* func, int paramNum,
const TypedValue* tv) const {
Transl::VMRegAnchor _;
std::ostringstream fname;
fname << func->fullName()->data() << "()";
const StringData* tn = typeName();
if (isSelf()) {
selfToTypeName(func, &tn);
} else if (isParent()) {
parentToTypeName(func, &tn);
}
auto const givenType = describe_actual_type(tv);
if (isExtended()) {
// Extended type hints raise warnings instead of recoverable
// errors for now, to ease migration (we used to not check these
// at all at runtime).
assert(nullable() &&
"only nullable extended type hints are currently supported");
raise_warning(
"Argument %d to %s must be of type ?%s, %s given",
paramNum + 1, fname.str().c_str(), tn->data(), givenType);
} else {
raise_recoverable_error(
"Argument %d passed to %s must be an instance of %s, %s given",
paramNum + 1, fname.str().c_str(), tn->data(), givenType);
}
}
void ReplSetImpl::init(OperationContext* txn, ReplSetSeedList& replSetSeedList) {
mgr = new Manager(this);
_cfg = 0;
memset(_hbmsg, 0, sizeof(_hbmsg));
strcpy(_hbmsg , "initial startup");
changeState(MemberState::RS_STARTUP);
_seeds = &replSetSeedList.seeds;
LOG(1) << "replSet beginning startup..." << rsLog;
loadConfig(txn);
unsigned sss = replSetSeedList.seedSet.size();
for (Member *m = head(); m; m = m->next()) {
replSetSeedList.seedSet.erase(m->h());
}
for (set<HostAndPort>::iterator i = replSetSeedList.seedSet.begin();
i != replSetSeedList.seedSet.end();
i++) {
if (isSelf(*i)) {
if (sss == 1) {
LOG(1) << "replSet warning self is listed in the seed list and there are no "
"other seeds listed did you intend that?" << rsLog;
}
}
else {
log() << "replSet warning command line seed " << i->toString()
<< " is not present in the current repl set config" << rsLog;
}
}
}
QString HistoryItem::inDialogsText(DrawInDialog way) const {
auto getText = [this]() {
if (_media) {
return _media->chatListText();
} else if (!emptyText()) {
return TextUtilities::Clean(_text.originalText());
}
return QString();
};
const auto plainText = getText();
const auto sender = [&]() -> PeerData* {
if (isPost() || isEmpty() || (way == DrawInDialog::WithoutSender)) {
return nullptr;
} else if (!_history->peer->isUser() || out()) {
return author();
} else if (_history->peer->isSelf() && !Has<HistoryMessageForwarded>()) {
return senderOriginal();
}
return nullptr;
}();
if (sender) {
auto fromText = sender->isSelf() ? lang(lng_from_you) : sender->shortName();
auto fromWrapped = textcmdLink(1, lng_dialogs_text_from_wrapped(lt_from, TextUtilities::Clean(fromText)));
return lng_dialogs_text_with_from(lt_from_part, fromWrapped, lt_message, plainText);
}
return plainText;
}
void TypeConstraint::init() {
if (UNLIKELY(s_typeNamesToTypes.empty())) {
const struct Pair {
const StringData* name;
Type type;
} pairs[] = {
{ makeStaticString("HH\\bool"), { KindOfBoolean, MetaType::Precise }},
{ makeStaticString("HH\\int"), { KindOfInt64, MetaType::Precise }},
{ makeStaticString("HH\\float"), { KindOfDouble, MetaType::Precise }},
{ makeStaticString("HH\\string"), { KindOfString, MetaType::Precise }},
{ makeStaticString("array"), { KindOfArray, MetaType::Precise }},
{ makeStaticString("HH\\resource"), { KindOfResource,
MetaType::Precise }},
{ makeStaticString("HH\\num"), { KindOfDouble, MetaType::Number }},
{ makeStaticString("self"), { KindOfObject, MetaType::Self }},
{ makeStaticString("parent"), { KindOfObject, MetaType::Parent }},
{ makeStaticString("callable"), { KindOfObject, MetaType::Callable }},
};
for (unsigned i = 0; i < sizeof(pairs) / sizeof(Pair); ++i) {
s_typeNamesToTypes[pairs[i].name] = pairs[i].type;
}
}
if (isTypeVar()) {
// We kept the type variable type constraint to correctly check child
// classes implementing abstract methods or interfaces.
m_type.dt = KindOfInvalid;
m_type.metatype = MetaType::Precise;
return;
}
if (m_typeName == nullptr) {
m_type.dt = KindOfInvalid;
m_type.metatype = MetaType::Precise;
return;
}
Type dtype;
TRACE(5, "TypeConstraint: this %p type %s, nullable %d\n",
this, m_typeName->data(), isNullable());
auto const mptr = folly::get_ptr(s_typeNamesToTypes, m_typeName);
if (mptr) dtype = *mptr;
if (!mptr ||
!(isHHType() || dtype.dt == KindOfArray ||
dtype.metatype == MetaType::Parent ||
dtype.metatype == MetaType::Self ||
dtype.metatype == MetaType::Callable)) {
TRACE(5, "TypeConstraint: this %p no such type %s, treating as object\n",
this, m_typeName->data());
m_type = { KindOfObject, MetaType::Precise };
m_namedEntity = Unit::GetNamedEntity(m_typeName);
TRACE(5, "TypeConstraint: NamedEntity: %p\n", m_namedEntity);
return;
}
m_type = dtype;
assert(m_type.dt != KindOfStaticString);
assert(IMPLIES(isParent(), m_type.dt == KindOfObject));
assert(IMPLIES(isSelf(), m_type.dt == KindOfObject));
assert(IMPLIES(isCallable(), m_type.dt == KindOfObject));
}
bool SmallNineAndroid::OnApplyBanker(const void* pBuffer, WORD wDataSize)
{
if (wDataSize != sizeof(CMD_S_ApplyBanker))
return 0;
CMD_S_ApplyBanker* pApplyBanker = (CMD_S_ApplyBanker *)pBuffer;
SUser* pUser = m_pUserManager->Search(pApplyBanker->szAccount);
if (pUser != NULL)
{
if (pApplyBanker->bApplyBanker)
{
if (BankerManager::GetSingleton().Search(pUser->dwUserID) == NULL)
{
BankerManager::GetSingleton().Insert(
new SBanker(pApplyBanker->szAccount, pApplyBanker->lScore, pUser->dwUserID)
);
}
}
else
{
BankerManager::GetSingleton().Remove(pUser->dwUserID);
}
if (isSelf(pUser->dwUserID))
{
BankerManager::GetSingleton().RemoveRequest(pUser->dwUserID);
CString szMessage;
szMessage.Format("[%d][%d]已移除上庄请求，当前请求次数%d", GetUserID(), GetGameID(), BankerManager::GetSingleton().GetRequestCount());
LogEvent(szMessage, TraceLevel_Debug);
}
}
return true;
}
bool Process::isAlive()
{
if (!isSelf())
{
if (!boost::filesystem::exists(lockfilePath))
{
return false;
}
bool result;
{
boost::mutex::scoped_lock lock(isAliveMutex);
boost::interprocess::file_lock fileLock(lockfilePath.string().c_str());
result = !fileLock.try_lock();
if (!result)
{
fileLock.unlock();
}
}
return result;
}
else
{
return true;
}
}
bool TypeConstraint::checkTypeAliasNonObj(const TypedValue* tv) const {
assert(tv->m_type != KindOfObject); // this checks when tv is not an object
assert(!isSelf() && !isParent());
auto p = getTypeAliasOrClassWithAutoload(m_namedEntity, m_typeName);
auto td = p.first;
auto c = p.second;
// Common case is that we actually find the alias:
if (td) {
if (td->nullable && tv->m_type == KindOfNull) return true;
return td->any || equivDataTypes(td->kind, tv->m_type);
}
// Otherwise, this isn't a proper type alias, but it *might* be a
// first-class enum. Check if the type is an enum and check the
// constraint if it is. We only need to do this when the underlying
// type is not an object, since only int and string can be enums.
if (c && isEnum(c)) {
auto dt = c->enumBaseTy();
// For an enum, if the underlying type is mixed, we still require
// it is either an int or a string!
if (dt) {
return equivDataTypes(*dt, tv->m_type);
} else {
return IS_INT_TYPE(tv->m_type) || IS_STRING_TYPE(tv->m_type);
}
}
return false;
}
bool SmallNineAndroid::OnUpdateTime(float fElapsed)
{
m_fElapsed += fElapsed;
if ((m_fElapsed / 60) >= m_fOnlineTime)
{
if (isSelf(m_wCurBanker))
{
m_fOnlineTime = AndroidTimer::rdit(5, 15);
m_fElapsed = 0;
}
else
{
if (m_nChipInScore <= 0)
{
CString szMessage;
szMessage.Format("[%d][%d]到达在线时间, 立刻下线", GetUserID(), GetGameID());
LogEvent(szMessage, TraceLevel_Exception);
BankerManager::GetSingleton().Remove(m_dwUserID);
SetStatus(US_OFFLINE);
}
else
{
m_fOnlineTime = AndroidTimer::rdit(5, 15);
m_fElapsed = 0;
}
}
}
return true;
}
MaybeDataType TypeConstraint::underlyingDataTypeResolved() const {
assert(!isSelf() && !isParent());
if (!hasConstraint()) return folly::none;
auto t = underlyingDataType();
// If we aren't a class or type alias, nothing special to do.
if (!isObjectOrTypeAlias()) return t;
auto p = getTypeAliasOrClassWithAutoload(m_namedEntity, m_typeName);
auto td = p.first;
auto c = p.second;
// See if this is a type alias.
if (td) {
if (td->kind != KindOfObject) {
t = td->kind;
} else {
c = td->klass;
}
}
// If the underlying type is a class, see if it is an enum and get that.
if (c && isEnum(c)) {
t = c->enumBaseTy();
}
return t;
}
int TlenMUCRecvMessage(const char *from, long timestamp, XmlNode *bodyNode)
{
// if (JabberListExist(LIST_CHATROOM, from)) {
char *localMessage;
char *nick, *style, *roomId, *userId;
int iStyle;
MUCCEVENT mucce;
roomId = JabberLoginFromJID(from);
userId = JabberResourceFromJID(from);
nick = getDisplayName(userId);
localMessage = JabberTextDecode(bodyNode->text);
mucce.cbSize = sizeof(MUCCEVENT);
mucce.iType = MUCC_EVENT_MESSAGE;
mucce.pszID = roomId;
mucce.pszModule = jabberProtoName;
mucce.pszText = localMessage;
mucce.pszUID = userId;//from;
mucce.pszNick = nick;
mucce.time = timestamp;
mucce.bIsMe = isSelf(roomId, userId);
mucce.dwFlags = 0;
mucce.iFontSize = 0;
style = JabberXmlGetAttrValue(bodyNode, "f");
if (style!=NULL) {
iStyle = atoi(style);
if (iStyle & 1) mucce.dwFlags |= MUCC_EF_FONT_BOLD;
if (iStyle & 2) mucce.dwFlags |= MUCC_EF_FONT_ITALIC;
if (iStyle & 4) mucce.dwFlags |= MUCC_EF_FONT_UNDERLINE;
}
style = JabberXmlGetAttrValue(bodyNode, "c");
if (style!=NULL && strlen(style)>5) {
iStyle = (stringToHex(style)<<16) | (stringToHex(style+2)<<8) | stringToHex(style+4);
} else {
iStyle = 0xFFFFFFFF;
}
mucce.color = (COLORREF) iStyle;
style = JabberXmlGetAttrValue(bodyNode, "s");
if (style!=NULL) {
iStyle = atoi(style);
} else {
iStyle = 0;
}
mucce.iFontSize = iStyle;
style = JabberXmlGetAttrValue(bodyNode, "n");
if (style!=NULL) {
iStyle = atoi(style)-1;
} else {
iStyle = 0;
}
mucce.iFont = iStyle;
CallService(MS_MUCC_EVENT, 0, (LPARAM) &mucce);
mir_free(roomId);
mir_free(userId);
mir_free(nick);
mir_free(localMessage);
// }
return 0;
}
bool TypeConstraint::checkTypedefNonObj(const TypedValue* tv) const {
assert(tv->m_type != KindOfObject); // this checks when tv is not an object
assert(!isSelf() && !isParent());
auto const td = getTypedefWithAutoload(m_namedEntity, m_typeName);
if (!td) return false;
if (td->nullable && IS_NULL_TYPE(tv->m_type)) return true;
return td->kind == KindOfAny || equivDataTypes(td->kind, tv->m_type);
}
bool TypeConstraint::checkTypedefObj(const TypedValue* tv) const {
assert(tv->m_type == KindOfObject); // this checks when tv is an object
assert(!isSelf() && !isParent() && !isCallable());
auto const td = getTypedefWithAutoload(m_namedEntity, m_typeName);
if (!td) return false;
if (td->nullable && IS_NULL_TYPE(tv->m_type)) return true;
if (td->kind != KindOfObject) return td->kind == KindOfAny;
return td->klass && tv->m_data.pobj->instanceof(td->klass);
}
void TypeConstraint::verifyFail(const Func* func, int paramNum,
TypedValue* tv) const {
JIT::VMRegAnchor _;
const StringData* tn = typeName();
if (isSelf()) {
selfToTypeName(func, &tn);
} else if (isParent()) {
parentToTypeName(func, &tn);
}
auto const givenType = describe_actual_type(tv);
auto c = tvToCell(tv);
if (isArray() && !isSoft() && !func->mustBeRef(paramNum) &&
c->m_type == KindOfObject && c->m_data.pobj->isCollection()) {
// To ease migration, the 'array' type constraint will implicitly cast
// collections to arrays, provided the type constraint is not soft and
// the parameter is not by reference. We raise a notice to let the user
// know that there was a type mismatch and that an implicit conversion
// was performed.
raise_notice(
folly::format(
"Argument {} to {}() must be of type {}, {} given; argument {} was "
"implicitly cast to array",
paramNum + 1, func->fullName()->data(), fullName(), givenType,
paramNum + 1
).str()
);
tvCastToArrayInPlace(tv);
return;
}
if (isExtended() && isSoft()) {
// Soft extended type hints raise warnings instead of recoverable
// errors, to ease migration.
raise_debugging(
"Argument %d to %s() must be of type %s, %s given",
paramNum + 1, func->fullName()->data(), fullName().c_str(), givenType);
} else if (isExtended() && isNullable()) {
raise_typehint_error(
folly::format(
"Argument {} to {}() must be of type {}, {} given",
paramNum + 1, func->fullName()->data(), fullName(), givenType
).str()
);
} else {
raise_typehint_error(
folly::format(
"Argument {} passed to {}() must be an instance of {}, {} given",
paramNum + 1, func->fullName()->data(), tn->data(), givenType
).str()
);
}
}
void StaticClassName::outputCodeModel(CodeGenerator &cg) {
if (isSelf()) {
cg.printf("self");
} else if (isParent()) {
cg.printf("parent");
} else if (isStatic()) {
cg.printf("static");
} else {
cg.printf("%s", m_origClassName.c_str());
}
}
void HybridReplicationCoordinator::setImplConfigHack(const ReplSetConfig* config) {
int myIndex = -1;
for (size_t i = 0; i < config->members.size(); ++i) { // find my index in the config
if (isSelf(config->members[i].h)) {
myIndex = i;
break;
}
}
fassert(18646, myIndex >= 0);
_impl.forceCurrentRSConfigHack(config->asBson(), myIndex);
}
void StaticClassName::outputCodeModel(CodeGenerator &cg) {
if (isSelf()) {
cg.printValue("self");
} else if (isParent()) {
cg.printValue("parent");
} else if (isStatic()) {
cg.printValue("static");
} else {
cg.printValue(m_origClassName);
}
}
void Process::join()
{
if (!isSelf())
{
if (boost::filesystem::exists(lockfilePath))
{
boost::interprocess::file_lock fileLock(lockfilePath.string().c_str());
boost::interprocess::scoped_lock<boost::interprocess::file_lock> lock(fileLock);
}
}
}
void Manager::checkElectableSet() {
unsigned otherOp = rs->lastOtherOpTime().getSecs();
// make sure the electable set is up-to-date
if (rs->elect.aMajoritySeemsToBeUp() &&
rs->iAmPotentiallyHot() &&
(otherOp == 0 || rs->lastOpTimeWritten.getSecs() >= otherOp - 10)) {
theReplSet->addToElectable(rs->selfId());
}
else {
theReplSet->rmFromElectable(rs->selfId());
}
// check if we should ask the primary (possibly ourselves) to step down
const Member *highestPriority = theReplSet->getMostElectable();
const Member *primary = rs->box.getPrimary();
if (primary && highestPriority &&
highestPriority->config().priority > primary->config().priority &&
// if we're stepping down to allow another member to become primary, we
// better have another member (otherOp), and it should be up-to-date
otherOp != 0 && highestPriority->hbinfo().opTime.getSecs() >= otherOp - 10) {
log() << "stepping down " << primary->fullName() << " (priority " <<
primary->config().priority << "), " << highestPriority->fullName() <<
" is priority " << highestPriority->config().priority << " and " <<
(otherOp - highestPriority->hbinfo().opTime.getSecs()) << " seconds behind" << endl;
if (isSelf(primary->h())) {
// replSetStepDown tries to acquire the same lock
// msgCheckNewState takes, so we can't call replSetStepDown on
// ourselves.
rs->relinquish();
}
else {
BSONObj cmd = BSON( "replSetStepDown" << 1 );
ScopedConn conn(primary->fullName());
BSONObj result;
try {
if (!conn.runCommand("admin", cmd, result, 0)) {
log() << "stepping down " << primary->fullName()
<< " failed: " << result << endl;
}
}
catch (DBException &e) {
log() << "stepping down " << primary->fullName() << " threw exception: "
<< e.toString() << endl;
}
}
}
}
void ReplSetImpl::init(OperationContext* txn, ReplSetSeedList& replSetSeedList) {
mgr = new Manager(this);
_cfg = 0;
memset(_hbmsg, 0, sizeof(_hbmsg));
strcpy(_hbmsg , "initial startup");
lastH = 0;
changeState(MemberState::RS_STARTUP);
_seeds = &replSetSeedList.seeds;
LOG(1) << "replSet beginning startup..." << rsLog;
loadConfig(txn);
unsigned sss = replSetSeedList.seedSet.size();
for (Member *m = head(); m; m = m->next()) {
replSetSeedList.seedSet.erase(m->h());
}
for (set<HostAndPort>::iterator i = replSetSeedList.seedSet.begin();
i != replSetSeedList.seedSet.end();
i++) {
if (isSelf(*i)) {
if (sss == 1) {
LOG(1) << "replSet warning self is listed in the seed list and there are no "
"other seeds listed did you intend that?" << rsLog;
}
}
else {
log() << "replSet warning command line seed " << i->toString()
<< " is not present in the current repl set config" << rsLog;
}
}
// Figure out indexPrefetch setting
std::string& prefetch = getGlobalReplicationCoordinator()->getSettings().rsIndexPrefetch;
if (!prefetch.empty()) {
IndexPrefetchConfig prefetchConfig = PREFETCH_ALL;
if (prefetch == "none")
prefetchConfig = PREFETCH_NONE;
else if (prefetch == "_id_only")
prefetchConfig = PREFETCH_ID_ONLY;
else if (prefetch == "all")
prefetchConfig = PREFETCH_ALL;
else
warning() << "unrecognized indexPrefetch setting: " << prefetch << endl;
setIndexPrefetchConfig(prefetchConfig);
}
}
Process::~Process()
{
if (isSelf())
{
fileLock->unlock();
delete lockfile;
// This would clean up resources we used.
// However, on Windows files will not get removed until
// the process holding the file is closed.
// When using the Unity editor the process will not get closed
// in between tries causing the crash of the process
// in the next try.
// boost::filesystem::remove(lockfilePath);
}
}
/** @param cfgString <setname>/<seedhost1>,<seedhost2> */
void parseReplSetSeedList(const std::string& cfgString,
std::string& setname,
std::vector<HostAndPort>& seeds,
std::set<HostAndPort>& seedSet) {
const char *p = cfgString.c_str();
const char *slash = strchr(p, '/');
if( slash )
setname = string(p, slash-p);
else
setname = p;
uassert(13093,
"bad --replSet config string format is: <setname>[/<seedhost1>,<seedhost2>,...]",
!setname.empty());
if( slash == 0 )
return;
p = slash + 1;
while( 1 ) {
const char *comma = strchr(p, ',');
if( comma == 0 ) comma = strchr(p,0);
if( p == comma )
break;
{
HostAndPort m;
try {
m = HostAndPort( string(p, comma-p) );
}
catch(...) {
uassert(13114, "bad --replSet seed hostname", false);
}
uassert(13096, "bad --replSet command line config string - dups?",
seedSet.count(m) == 0);
seedSet.insert(m);
//uassert(13101, "can't use localhost in replset host list", !m.isLocalHost());
if (isSelf(m)) {
LOG(1) << "replSet ignoring seed " << m.toString() << " (=self)" << rsLog;
}
else
seeds.push_back(m);
if( *comma == 0 )
break;
p = comma + 1;
}
}
}
/**
* Overrides method from UMLWidget.
*/
QSizeF MessageWidget::minimumSize() const
{
if (m_sequenceMessageType == Uml::SequenceMessage::Synchronous) {
return QSizeF(width(), 20);
} else if (m_sequenceMessageType == Uml::SequenceMessage::Asynchronous) {
return isSelf() ? QSizeF(width(), 20) : QSizeF(width(), 8);
} else if (m_sequenceMessageType == Uml::SequenceMessage::Creation) {
return QSizeF(width(), 8);
} else if (m_sequenceMessageType == Uml::SequenceMessage::Lost) {
return QSizeF(width(), 10);
} else if (m_sequenceMessageType == Uml::SequenceMessage::Found) {
return QSizeF(width(), 10);
} else {
uWarning() << "Unknown message type";
}
return QSize(width(), height());
}
std::string TypeConstraint::displayName(const Func* func /*= nullptr*/) const {
const StringData* tn = typeName();
std::string name;
if (isSoft()) {
name += '@';
}
if (isNullable() && isExtended()) {
name += '?';
}
if (func && isSelf()) {
selfToTypeName(func, &tn);
name += tn->data();
} else if (func && isParent()) {
parentToTypeName(func, &tn);
name += tn->data();
} else {
const char* str = tn->data();
auto len = tn->size();
if (len > 3 && tolower(str[0]) == 'h' && tolower(str[1]) == 'h' &&
str[2] == '\\') {
bool strip = false;
const char* stripped = str + 3;
switch (len - 3) {
case 3:
strip = (!strcasecmp(stripped, "int") ||
!strcasecmp(stripped, "num"));
break;
case 4: strip = !strcasecmp(stripped, "bool"); break;
case 5: strip = !strcasecmp(stripped, "float"); break;
case 6: strip = !strcasecmp(stripped, "string"); break;
case 8:
strip = (!strcasecmp(stripped, "resource") ||
!strcasecmp(stripped, "noreturn") ||
!strcasecmp(stripped, "arraykey"));
break;
default:
break;
}
if (strip) {
str = stripped;
}
}
name += str;
}
return name;
}
void TypeConstraint::init() {
if (isTypeVar()) {
// We kept the type variable type constraint to correctly check child
// classes implementing abstract methods or interfaces.
m_type.dt = folly::none;
m_type.metatype = MetaType::Precise;
return;
}
if (m_typeName == nullptr) {
m_type.dt = folly::none;
m_type.metatype = MetaType::Precise;
return;
}
Type dtype;
TRACE(5, "TypeConstraint: this %p type %s, nullable %d\n",
this, m_typeName->data(), isNullable());
auto const mptr = typeNameToType(m_typeName);
if (mptr) dtype = *mptr;
if (!mptr ||
!(isHHType() || dtype.dt == KindOfArray ||
dtype.dt == KindOfBoolean ||
dtype.dt == KindOfString ||
dtype.dt == KindOfInt64 ||
dtype.dt == KindOfDouble ||
dtype.dt == KindOfResource ||
dtype.metatype == MetaType::ArrayKey ||
dtype.metatype == MetaType::Number ||
dtype.metatype == MetaType::Parent ||
dtype.metatype == MetaType::Self ||
dtype.metatype == MetaType::Callable)) {
TRACE(5, "TypeConstraint: this %p no such type %s, treating as object\n",
this, m_typeName->data());
m_type = { KindOfObject, MetaType::Precise };
m_namedEntity = NamedEntity::get(m_typeName);
TRACE(5, "TypeConstraint: NamedEntity: %p\n", m_namedEntity);
return;
}
m_type = dtype;
assert(m_type.dt != KindOfStaticString);
assert(IMPLIES(isParent(), m_type.dt == KindOfObject));
assert(IMPLIES(isSelf(), m_type.dt == KindOfObject));
assert(IMPLIES(isCallable(), m_type.dt == KindOfObject));
}
