def __ShutdownTimer(self):
while self.state == SERVICE_RUNNING:
try:
if self.shutdownTime and self.shutdownTime - blue.os.GetWallclockTime(
) < 5 * const.MIN:
timeLeft = max(
0L, self.shutdownTime - blue.os.GetWallclockTime())
self.Say(
localization.GetByLabel(
'UI/Shared/ClusterShutdownInSeconds',
timeLeft=timeLeft))
except:
log.LogException()
sys.exc_clear()
blue.pyos.synchro.SleepWallclock(5000)
def _Receiver(self):
ch = self._channel
while True:
try:
args, kw = ch.receive()
blue.pyos.synchro.SleepWallclock(self._delay)
while ch.balance != 0:
args, kw = ch.receive()
self._fn(*args, **kw)
except self._StopExc:
sys.exc_clear()
return
except Exception:
log.LogException()
sys.exc_clear()
def LoadScroll(self):
if self is None or self.destroyed:
return
if not self.sr.Get('scroll'):
return
try:
scrolllist = []
sm.GetService('corpui').ShowLoad()
self.ShowMyAllianceDetails(scrolllist)
self.ShowMyAllianceSystems(scrolllist)
self.sr.scroll.Load(contentList=scrolllist)
except:
log.LogException()
sys.exc_clear()
finally:
sm.GetService('corpui').HideLoad()
def Miner(self):
try:
while self.minerThread is threading.current_thread():
time.sleep(self.threshold)
now = time.time()
self.minerTimestamp = now
if not self.timestamp:
continue
next_timestamp = self.timestamp + self.interval
late = now - next_timestamp
if late < self.threshold:
continue
self.Report(late)
except:
log.LogException('canaryService.Miner thread errored out')
def MoveCursor_thread(self):
self.isMoving = True
lib = uicore.uilib
while lib.leftbtn:
if self.currentCursor:
x, y, z = self.GetSelectionCenter()
dungeonOrigin = self.GetDungeonOrigin()
playerPos = self.GetPlayerOffset()
try:
rotation = self.GetSelectionRotation()
singleObjectRotation = self.currentCursor == 'Rotation' and len(
self.selection) == 1
multipleObjectRotation = self.currentCursor == 'Rotation' and len(
self.selection) > 1
if singleObjectRotation:
self.cursors[self.currentCursor].Rotate(
(rotation[0], rotation[1], rotation[2],
rotation[3]))
elif multipleObjectRotation:
self.cursors[self.currentCursor].Rotate(
(rotation[0], rotation[1], rotation[2],
-rotation[3]))
self.cursors[self.currentCursor].Translate(
trinity.TriVector(x - playerPos.x, y - playerPos.y,
z - playerPos.z))
self.cursors[self.currentCursor].Transform(
uicore.uilib.x, uicore.uilib.y)
if multipleObjectRotation:
rotation = self.cursors[
self.currentCursor].GetRotation()
self.SetGroupSelectionRotation(
(rotation[0], rotation[1], rotation[2],
-rotation[3]))
except:
self.LogError(
'Error when attempting to move the dungeon editor object manipulation tool.'
)
log.LogException()
sys.exc_clear()
self.isMoving = False
return
self.lastChangeTimestamp = blue.os.GetWallclockTime()
blue.synchro.Yield()
self.isMoving = False
self.StopMovingCursor()
def Write(self, message):
if self.transport:
MachoTransport.Write(self, message)
try:
uthread.Lock(self, 'httpReaders')
if len(
self.readers
) > 0 and message.command == const.cluster.MACHONETMSG_TYPE_NOTIFICATION:
with bluepy.Timer(
'machoNet::StreamingHTTPMachoTransport::Write::MPT-Megahack'
):
sent = False
try:
data = message.__getstate__()
if data[0] == 12:
if data[2].__getstate__()[1] == '__MultiEvent':
self.LogInfo(
'Splitting __MultiEvent into multiple chunks'
)
jsonMessage = json.loads(
httpUtil.ToComplexJSON(data))
innerMessages = jsonMessage[4][0][1][1][1]
innerMessage = (12, None, [[], None], None,
[[0, [0, [1, None]]]])
with bluepy.Timer(
'machoNet::StreamingHTTPMachoTransport::Write::MPT-Megahack::Multiplex'
):
for msg in innerMessages:
innerMessage[2][1] = msg[0]
innerMessage[4][0][1][1][1] = msg[1]
for reader in self.readers:
reader.write(innerMessage)
sent = True
except:
self.LogError('MultiEvent exception', message)
log.LogException()
with bluepy.Timer(
'machoNet::StreamingHTTPMachoTransport::Write::Multiplex'
):
if not sent:
for reader in self.readers.copy():
reader.write(message)
finally:
uthread.UnLock(self, 'httpReaders')
def ExceptionHandler(self, exctype, exc, tb, message=''):
try:
if isinstance(exc, UserError):
self.Message(exc.msg, exc.dict)
else:
toMsgWindow = prefs.GetValue('showExceptions', 0)
if isinstance(exc, RuntimeError) and len(
exc.args) and exc.args[0] == 'ErrMessageNotFound':
if toMsgWindow:
self.Message('ErrMessageNotFound', exc.args[1])
else:
toMsgWindow = toMsgWindow and not self.noErrorPopups
if isinstance(exc, AttributeError):
deadWindowCheck = self.IsDestroyedWindow(tb)
if deadWindowCheck:
name = ''
try:
nameIdx = deadWindowCheck.find('name=')
if nameIdx != -1:
nameIdx += 6
endNameIdx = deadWindowCheck[
nameIdx:].find('",')
if endNameIdx != -1:
name = deadWindowCheck[
nameIdx:nameIdx + endNameIdx]
except:
sys.exc_clear()
log.LogWarn('Message sent to dead window:', name)
exctype = exc = tb = None
return
if getattr(exc, 'msg', None) == 'DisconnectedFromServer':
toMsgWindow = 0
severity = log.LGERR
extraText = '; caught by eve.ExceptionHandler'
if message:
extraText += '\nContext info: ' + message
return log.LogException(extraText=extraText,
toMsgWindow=toMsgWindow,
exctype=exctype,
exc=exc,
tb=tb,
severity=severity)
except:
exctype = exc = tb = None
traceback.print_exc()
sys.exc_clear()
def __FlushCache(self, yieldFirst):
"""
If the cache has been changed since last flush, we dump it to disk.
"""
if yieldFirst:
blue.pyos.synchro.Yield()
while self.lastChange:
flushWhat, lastChange = self.lastChange.items()[0]
del self.lastChange[flushWhat]
what, key = flushWhat
filename = self.cachePath + what + '/%s.cache' % self.KeyToFileName(
key)
if os.access(filename,
os.F_OK) and not os.access(filename, os.W_OK):
try:
os.chmod(filename, 666)
except StandardError:
self.LogWarn(
'Failed to reset access priviledges on file from file system (',
filename, ')')
sys.exc_clear()
try:
store = getattr(self, what)
if key not in store:
try:
os.unlink(filename)
self.LogInfo('Deleted ', key, ' from file system (',
filename, ')')
except StandardError as e:
self.LogWarn(
'Failed to delete file from file system (',
filename, '):', e)
sys.exc_clear()
else:
ob = store[key]
if not isinstance(ob, uthread.Semaphore):
blue.win32.AtomicFileWrite(
filename, blue.marshal.Save((key, ob)))
self.LogInfo('Wrote ', key, ' to file (', filename,
')')
self.lastFileWriteTime[self.__KeyFromFileName(
filename)] = os.path.getmtime(filename)
except Exception:
log.LogException('Error while writing cached data')
sys.exc_clear()
def _RegisterComponents(self, entity, initData=None):
"""
Called when the entity is registered with a scene
"""
with uthread.BlockTrapSection():
with entity.entityLock:
try:
if entity.state == const.cef.ENTITY_STATE_CREATING:
entity.state = const.cef.ENTITY_STATE_READY
entity.scene.AddEntityToRegisteredList(entity)
registerCalls = []
for name, component in entity.components.iteritems():
systems = self.GetComponentSystems(name)
if systems:
for system in systems:
f = getattr(system, 'RegisterComponent',
None)
if f:
registerCalls.append(
(f, (entity, component)))
if registerCalls:
for f, args in registerCalls:
f(*args)
del self.loadingEntities[entity.entityID]
elif entity.state in (const.cef.ENTITY_STATE_UNINITIALIZED,
const.cef.ENTITY_STATE_DEAD,
const.cef.ENTITY_STATE_READY):
self.LogError(
'RegisterComponents: Entity state should be either',
const.cef.ENTITY_STATE_NAMES[
const.cef.ENTITY_STATE_CREATING], 'or',
const.cef.ENTITY_STATE_NAMES[
const.cef.ENTITY_STATE_DESTROYING],
', is instead',
const.cef.ENTITY_STATE_NAMES[entity.state],
'. Entity:', str(entity))
sm.ScatterEvent('OnEntityCreated', entity.entityID)
GameWorld.GetNetworkEntityQueueManager().ClearEntity(
entity.entityID)
except Exception as e:
log.LogException(e)
self._deadEntityList[entity.entityID] = entity
if entity.scene and entity.entityID in entity.scene.entities:
del entity.scene.entities[entity.entityID]
self.entitySceneManager.Unregister(entity.entityID)
def __init__(self):
service.Service.__init__(self)
self.certificates = {}
try:
for key, value in cfg.certificates['certificates'].iteritems():
if hasattr(value, 'recommendedFor'):
recommendedFor = value.recommendedFor
else:
recommendedFor = []
self.certificates[key] = Certificate(key, value.groupID,
value.nameID,
value.descriptionID,
value.skillTypes,
recommendedFor)
except KeyError:
log.LogException()
def Run(self, *args):
service.Service.Run(self, *args)
expire_hours, expire_mins = (2, 5)
expire_ms = 1000 * (3600 * expire_hours + 60 * expire_mins)
self.viewedWrecks = {}
for itemID, time in settings.char.ui.Get('viewedWrecks', {}).iteritems():
try:
if blue.os.TimeDiffInMs(time, blue.os.GetWallclockTime()) < expire_ms:
self.viewedWrecks[itemID] = time
except blue.error:
sys.exc_clear()
try:
self._PersistSettings()
except:
log.LogException()
sys.exc_clear()
def _CreateChannel(self, vivoxChannelName):
self.LogInfo('Requesting Creation of channel with name',
vivoxChannelName)
try:
isPersistent = self.IsChannelPersistent(vivoxChannelName)
isProtected = self.IsChannelProtected(vivoxChannelName)
uri = self.voiceMgr.CreateChannel(vivoxChannelName, isPersistent,
isProtected)
except:
log.LogException()
sys.exc_clear()
finally:
if len(uri) > 0:
uthread.pool('vivox::JoinChannel', self._JoinChannel,
vivoxChannelName)
else:
raise UserError('VivoxError42')
def __LongCallTimer(self):
longWarningSecs = prefs.GetValue('longOutstandingCallWarningSeconds',
DEFAULTLONGWAITWARNINGSECS)
sleepSecs = 60
if longWarningSecs < sleepSecs:
sleepSecs = longWarningSecs
self.LogInfo('__LongCallTimer reporting warnings after',
longWarningSecs, 'seconds and checking every', sleepSecs,
'seconds')
def ShouldWarn(method):
for w in LONGWAITWARNINGMETHODS:
if w in repr(method):
return True
return False
while self.state == service.SERVICE_RUNNING:
if sm.GetService('machoNet').GetGlobalConfig().get(
'disableLongCallWarning'):
self.LogWarn('__LongCallTimer should not be running! Exiting.')
return
blue.pyos.synchro.SleepWallclock(sleepSecs * 1000)
try:
maxDiff = 0
for ct in base.outstandingCallTimers:
method = ct[0]
t = ct[1]
diff = blue.os.GetWallclockTimeNow() - t
if diff > maxDiff and ShouldWarn(method):
maxDiff = diff
if diff > 60 * const.SEC:
self.LogWarn('Have waited', FmtTime(diff), 'for',
method)
if maxDiff > longWarningSecs * const.SEC and self.lastLongCallTimestamp < blue.os.GetWallclockTimeNow(
) - longWarningSecs * const.SEC:
modalWnd = uicore.registry.GetModalWindow()
if modalWnd:
modalWnd.SetModalResult(uiconst.ID_CLOSE)
uthread.new(uicore.Message, 'LongWaitForRemoteCall',
{'time': int(maxDiff / const.MIN)})
self.lastLongCallTimestamp = blue.os.GetWallclockTimeNow()
except:
log.LogException()
sys.exc_clear()
def TryFlyUpdate(self):
"""Update my FlyMode velocity, but only if I'm actually *in* FlyMode."""
me = self.entityService.GetPlayerEntity()
if me is not None:
myMovement = me.GetComponent('movement')
if myMovement and myMovement.IsFlyMode:
newVel = (0, 0, 0)
if self.drive:
activeCamera = self.cameraClient.GetActiveCamera()
cameraDir = geo2.Vec3Subtract(activeCamera.GetPointOfInterest(), activeCamera.GetPosition())
newVel = geo2.Vec3Scale(geo2.Vec3Normalize(cameraDir), myMovement.flySpeed)
try:
myMovement.moveModeManager.GetCurrentMode().velocity = newVel
except AttributeError:
log.LogException()
sys.exc_clear()
myMovement.IsFlyMode = False
def _GetGenderRU(self, typeID, *args, **kwargs):
try:
messageID = cfg.invtypes.Get(typeID).typeNameID
except KeyError:
log.LogException()
return localization.GENDER_MALE
try:
return localization.GetMetaData(
messageID,
'gender',
languageID=localization.LOCALE_SHORT_RUSSIAN)
except KeyError:
localization.LogWarn(
"itemID %s does not have the requested metadata 'gender' in language '%s. Returning masculine gender by default."
% (typeID, localization.LOCALE_SHORT_RUSSIAN))
return localization.GENDER_MALE
def CmdCloseAllWindows(self):
for wnd in uicore.registry.GetWindows()[:]:
if not uicore.registry.IsWindow(wnd):
continue
if wnd.IsKillable():
if hasattr(wnd, 'CloseByUser'):
wnd.CloseByUser()
else:
try:
wnd.Close()
except:
log.LogException()
elif not wnd.InStack():
wnd.Minimize()
return True
def RunWorkerProcesses(self):
seconds = 0
while self.state == service.SERVICE_RUNNING:
if prefs.GetValue('disableProcessHealthService', 0):
self.LogWarn(
'Process Health Service is disabled in prefs. Disabling loop.'
)
return
blue.pyos.synchro.SleepWallclock(10000)
try:
seconds += 10
self.DoOnceEvery10Secs()
if seconds % 600 == 0:
self.DoOnceEvery10Minutes()
except:
log.LogException()
sys.exc_clear()
def GetConditions(self, advancedMatches):
conditions = []
for word, value in advancedMatches:
try:
for kw in self.searchKeywords:
if kw.keyword.lower().startswith(word):
kw.matchFunction(conditions, value)
break
except:
import log
log.LogException()
sm.GetService('assets').LogInfo('Failed parsing keyword', word,
'value', value,
'and happily ignoring it')
return conditions
def OptionalUpgradeGetDescription(self):
try:
n = nasty.GetAppDataCompiledCodePath()
fromversion = n.build or boot.build
if self.upgradeInfo is None:
return
toversion = self.upgradeInfo.build
from appPatch import optionalPatchInfoURLs
url = '%snoformat.asp?from=%s&to=%s' % (optionalPatchInfoURLs[boot.region], fromversion, toversion)
socket = urllib2.urlopen(url)
response = socket.read()
socket.close()
return response
except:
log.LogException()
sys.exc_clear()
return
def _QueueTicker(queue, name, svc):
""" Calls queue.Tick() every 60 seconds, optionally timing out items before each Tick(). """
while queue.ticker is not None:
svc.LogInfo('Started Login Queue Ticker task for queue ', name)
blue.pyos.synchro.SleepWallclock(60000)
if queue.ticker is not None:
try:
if queue.queueTimeout > 0:
l = queue.Timeout(queue.queueTimeout)
if len(l) > 0:
svc.LogWarn('Timed ', len(l),
" clients out of login queue '", name,
"' (timeout = ", queue.queueTimeout,
' sec)')
queue.Tick()
except:
log.LogException('Exception in _QueueTicker tasklet')
def GetSolarSystemTrace(self, itemID, altText=None, traceFontSize=12):
if util.IsStation(itemID):
solarSystemID = cfg.stations.Get(itemID).solarSystemID
else:
solarSystemID = itemID
try:
sec, col = util.FmtSystemSecStatus(
sm.GetService('map').GetSecurityStatus(solarSystemID), 1)
col.a = 1.0
securityLabel = "</b> <color=%s><hint='%s'>%s</hint></color>" % (
util.StrFromColor(col),
localization.GetByLabel('UI/Map/StarMap/SecurityStatus'), sec)
except KeyError:
self.LogError('Neocom failed to get security status for item',
solarSystemID, 'displaying BROKEN')
log.LogException()
sys.exc_clear()
securityLabel = ''
si = cfg.mapSystemCache.Get(solarSystemID)
constellationID = si.constellationID
regionID = si.regionID
if altText:
solarSystemAlt = " alt='%s'" % uiutil.StripTags(
altText, stripOnly=['localized'])
else:
solarSystemAlt = ''
locationTrace = '<url=showinfo:%s//%s%s>%s</url>%s' % (
const.typeSolarSystem, solarSystemID, solarSystemAlt,
cfg.evelocations.Get(solarSystemID).locationName, securityLabel)
if traceFontSize:
locationTrace += '<fontsize=12>'
if not util.IsWormholeRegion(regionID):
seperator = '<fontsize=%(fontsize)s> </fontsize><<fontsize=%(fontsize)s> </fontsize>' % {
'fontsize': 8
}
locationTrace += seperator
locationTrace += '<url=showinfo:%s//%s>%s</url>' % (
const.typeConstellation, constellationID,
cfg.evelocations.Get(constellationID).locationName)
locationTrace += seperator
locationTrace += '<url=showinfo:%s//%s>%s</url>' % (
const.typeRegion, regionID,
cfg.evelocations.Get(regionID).locationName)
return locationTrace
def LogInfoEvent(self,
eventTypeID,
itemID=None,
itemID2=None,
int_1=None,
int_2=None,
int_3=None,
char_1=None,
char_2=None,
char_3=None,
float_1=None,
float_2=None,
float_3=None):
try:
if eventTypeID in self.serverEvents:
if eventTypeID in self.serverOncePerRunEvents:
self.serverOncePerRunEvents.remove(eventTypeID)
self.serverEvents.remove(eventTypeID)
if eventTypeID not in self.loggedEvents:
if eventTypeID in self.logTypeAggregates:
self.aggregateDict[eventTypeID] = {}
self.loggedEvents[eventTypeID] = []
if eventTypeID in self.logTypeAggregates:
if itemID2 is not None:
itemID2 = long(itemID2)
ln = [
blue.os.GetWallclockTime(),
long(itemID), itemID2, int_1, int_2, int_3, char_1,
char_2, char_3, float_1, float_2, float_3
]
valueIx = self.infoTypeParameters[eventTypeID].difference(
self.logTypeAggregates[eventTypeID])
igsUtil.AggregateEvent(eventTypeID, ln, self.loggedEvents,
self.aggregateDict[eventTypeID],
self.logTypeAggregates[eventTypeID],
valueIx)
else:
self.loggedEvents[eventTypeID].append([
blue.os.GetWallclockTime(), itemID, itemID2, int_1,
int_2, int_3, char_1, char_2, char_3, float_1, float_2,
float_3
])
except Exception:
log.LogException('Error logging IGS information')
sys.exc_clear()
def _TearDownComponents(self, entity):
with entity.entityLock:
try:
if entity.state == const.cef.ENTITY_STATE_DESTROYING:
entity.state = const.cef.ENTITY_STATE_DEAD
preTearDownCalls = []
for name, component in entity.components.iteritems():
systems = self.GetComponentSystems(name)
if systems:
for system in systems:
f = getattr(system, 'PreTearDownComponent',
None)
if f:
preTearDownCalls.append(
(f, (entity, component)))
if preTearDownCalls:
uthread.parallel(preTearDownCalls)
tearDownCalls = []
for name, component in entity.components.iteritems():
systems = self.GetComponentSystems(name)
if systems:
for system in systems:
f = getattr(system, 'TearDownComponent', None)
if f:
tearDownCalls.append(
(f, (entity, component)))
if tearDownCalls:
uthread.parallel(tearDownCalls)
else:
self.LogError(
'SetupComponents: Entity state should be ',
const.cef.ENTITY_STATE_NAMES[
const.cef.ENTITY_STATE_DESTROYING],
', is instead ',
const.cef.ENTITY_STATE_NAMES[entity.state],
'. Entity:', str(entity))
sm.ScatterEvent('OnEntityDeleted', entity.entityID,
entity.scene.sceneID)
GameWorld.GetNetworkEntityQueueManager().RemoveEntity(
entity.entityID)
except Exception as e:
self._deadEntityList[entity.entityID] = entity
log.LogException(e)
def GuessNodeIDFromAddress(self, serviceName, address):
"""
Tries to guess which nodeID a address lives at based on some magic mappings
and what's currently in the address cache. But it's only a guess.
Note that server is a serviceName, not a serviceMask name, since this is just
used for bound object which have live at a service rather than a serviceMask
"""
alternatives = []
if service in ('aggressionMgr', 'director', 'entity'):
alternatives = [('beyonce', address)]
for each in ('aggressionMgr', 'director', 'entity'):
alternatives.append((each, address))
elif service == 'brokerMgr':
alternatives = [('station', address)]
elif service in ('i2', 'skillMgr', 'dogmaIM', 'invbroker', 'ship'):
if address[1] == const.groupSolarSystem:
alternatives = [('beyonce', address[0])]
elif address[1] == const.groupStation:
alternatives = [('station', address[0])]
for each in ('i2', 'skillMgr', 'dogmaIM', 'invbroker', 'ship'):
alternatives.append((each, address))
elif service in ('corpStationMgr', 'factory', 'broker'):
alternatives = [('station', address)]
elif service == 'tradeMgr':
alternatives = [('station', address[0])]
elif service == 'station' and macho.mode == 'server':
try:
key = ('beyonce', sm.services['stationSvc'].GetStation(
address, prime=0).solarSystemID)
if key[1]:
alternatives.append(key)
except StandardError:
log.LogException(
'Could not locate the station you asked for without blocking'
)
sys.exc_clear()
for alt_service, alt_address in alternatives:
nodeID = self._addressCache.Get(alt_service, alt_address)
if nodeID is not None:
self._addressCache.Set(serviceName, address, nodeID)
return nodeID
def ExpandGroupBeans(self, compressedGroupBeans):
if isinstance(compressedGroupBeans, dict):
return compressedGroupBeans
res = None
try:
res = blue.marshal.Load(zlib.decompress(compressedGroupBeans))
except (UnmarshalError, zlib.error):
firstBit = '<error encoding>'
with util.ExceptionEater('Encoding some badness in the beancounter'):
firstBit = base64.b64encode(compressedGroupBeans[:1000])
self.LogError('BeanDelivery recieved a non-standard bean payload, likely not exefile in origin. Session:', repr(session), 'First 1000char of compressed payload:', firstBit)
log.LogException('BeanDelivery recieved a non-standard bean payload')
with util.ExceptionEater('Reporting BeanDelivery error to Alert'):
message = 'The following session sent us a set of Beans that are probably all attacky:\n%s\n\n' % (repr(session),)
message += 'The compressed payload follows (base64 encoded):\n%s' % (base64.b64encode(compressedGroupBeans),)
self.Alert('BeanDelivery', 'Non-standard BeanCounting payload', message)
return res
def GetWebRequestParameters(self):
details = {}
try:
details['n'] = boot.build
details['s'] = util.GetServerName()
details['u'] = settings.public.ui.Get('username', '')
details['language_id'] = prefs.GetValue('languageID', 'EN')
details['edition'] = getattr(boot, 'edition', 'classic')
details['protocol'] = 2
details['intended_platform'] = 'win'
details['client_bitcount'] = 32
details['client_fullversion'] = '%s.%s' % (boot.keyval['version'].split('=', 1)[1], boot.build)
if not blue.win32.IsTransgaming():
versionEx = blue.win32.GetVersionEx()
details['actual_platform'] = 'win'
details['platform_version'] = str(blue.os.osMajor) + '.' + str(blue.os.osMinor)
details['platform_extra'] = str(versionEx.get('wServicePackMajor', 0))
if versionEx.get('wProductType', 1) > 1:
details['platform_type'] = 'server'
else:
details['platform_type'] = ['workstation', 'desktop'][versionEx.get('wSuiteMask', 512) & 512 > 0]
if blue.win32.GetNativeSystemInfo().get('ProcessorArchitecture', '') == 'PROCESSOR_ARCHITECTURE_AMD64':
details['platform_bitcount'] = 64
else:
details['platform_bitcount'] = 32
else:
versionEx = blue.win32.TGGetSystemInfo()
details['actual_platform'] = ['mac', 'linux'][blue.win32.TGGetOS() == 'Linux']
details['platform_type'] = versionEx.get('platform_type', 'desktop')
details['platform_version'] = str(versionEx.get('platform_major_version', 0)) + '.' + str(versionEx.get('platform_minor_version', 0))
details['platform_extra'] = versionEx.get('platform_extra', '0')
details['platform_bitcount'] = versionEx.get('platform_bitcount', 32)
cardName = ''
ident = trinity.adapters.GetAdapterInfo(trinity.adapters.DEFAULT_ADAPTER)
cardName = str(ident.description)
cardName = cardName[0:64]
details['card_name'] = cardName
details['affiliate_id'] = self.GetClientAffiliateID()
except:
log.LogException(toAlertSvc=0)
sys.exc_clear()
queryString = urllib.urlencode(details)
return queryString
def GetStaticHeader(self):
"""
Return a bunch of information in the response header about the server if he has not authenticated yet.
The reason this is only returned into the header when you are not authenticated is that this is quite
a lot of data that we don't want to be shoveling out with every request.
The proxy only returns a subset of the data while the server returns the whole thing. Nothing is returned on the client
Most of the information here is fetched once and then stored but online user count is fetched every 5 minutes.
"""
uthread.Lock('http.GetStaticHeader')
try:
if self.staticHeader is None:
self.staticHeader = {}
self.staticHeader['CCP-codename'] = boot.codename
self.staticHeader['CCP-version'] = boot.version
self.staticHeader['CCP-build'] = boot.build
self.staticHeader['CCP-sync'] = boot.sync
self.staticHeader['CCP-clustermode'] = prefs.GetValue('clusterMode', 'n/a')
if boot.role == 'server':
product = sm.GetService('cache').Setting('zsystem', 'Product')
ebsVersion = sm.GetService('DB2').CallProc('zsystem.Versions_Select', product)[0].version
bsdChangeList = sm.GetService('DB2').SQLInt('TOP 1 changeID', 'zstatic.changes', 'submitDate IS NOT NULL', 'submitDate DESC', 'branchID', sm.GetService('BSD').Setting(1))
self.staticHeader['CCP-product'] = product
self.staticHeader['CCP-EBS'] = ebsVersion
self.staticHeader['CCP-StaticBranch'] = sm.GetService('BSD').BranchName()
if len(bsdChangeList) > 0:
self.staticHeader['CCP-StaticCL'] = bsdChangeList[0].changeID
if boot.role == 'proxy':
machoNet = sm.GetService('machoNet')
onlineCountEve = machoNet.GetClusterSessionCounts('EVE:Online')[0]
onlineCountDust = machoNet.GetClusterSessionCounts('DUST:Online')[0]
acl = machoNet.CheckACL(None, espCheck=True)
vipMode = machoNet.vipMode
self.staticHeader['CCP-onlineCount'] = onlineCountEve + onlineCountDust
self.staticHeader['CCP-onlineCountEve'] = onlineCountEve
self.staticHeader['CCP-onlineCountDust'] = onlineCountDust
self.staticHeader['CCP-ACL'] = acl[1] if acl else None
self.staticHeader['CCP-VIP'] = machoNet.vipMode
except Exception:
self.staticHeader = {'BADHEADER': ''}
log.LogException()
finally:
uthread.UnLock('http.GetStaticHeader')
return self.staticHeader
def PerformHorridSessionAttributeUpdate(self, clientID, dict):
try:
if machobase.mode == 'server':
proxyNodeID = self.GetProxyNodeFromID('clientID', clientID)
return self.GetProxySessionManager(
proxyNodeID).PerformHorridSessionAttributeUpdate(
clientID, dict)
s = sm.services['machoNet'].GetSessionByClientID(clientID)
if s:
s.LogSessionHistory(
'Updating session information via sessionMgr::UpdateSessionAttributes'
)
s.SetAttributes(dict)
s.LogSessionHistory(
'Updated session information via sessionMgr::UpdateSessionAttributes'
)
except StandardError:
log.LogException()
sys.exc_clear()
def UnterMachoRemoteServiceCall(self, dude, retvals, sess, nodeID, service, method, args, keywords):
try:
if nodeID == sm.services['machoNet'].GetNodeID():
if 'machoTimeout' in keywords:
keywords = copy.copy(keywords)
del keywords['machoTimeout']
retvals.append((0, nodeID, apply(getattr(sess.ConnectToService(service), method), args, keywords)))
else:
retvals.append((0, nodeID, self.RemoteServiceCallWithoutTheStars(sess, nodeID, service, method, args, keywords)))
except StandardError as e:
log.LogException()
retvals.append((1, nodeID, e))
sys.exc_clear()
except Exception as e:
log.LogTraceback()
retvals.append((1, nodeID, e))
raise
finally:
dude.Done()
def SafeThreadLoop(self, now):
shapesToKill = []
if self.debugRender:
try:
for shape in self.shapes:
shape.Render()
if shape.currentTime > shape.time:
shapesToKill.append(shape)
except:
log.LogException(
'Error rendering shape in debugRenderClient.SafeThreadLoop'
)
self.shapes = []
else:
self.ClearAllShapes()
for shape in shapesToKill:
self.shapes.remove(shape)
