def __updateData(self):
if self.__lazyInitialization:
arbiter = BigWorld.globalData.get('Arbiter', False)
if arbiter:
self.__lazyInitialization = False
for dvKey, keyDescription in self.__dvKeyArray.iteritems():
arbiter.addNewKey(dvKey, wgPickle.dumps(wgPickle.FromServerToServer, keyDescription))
else:
return
else:
_buffer = {}
for dvKey, dataObj in self.__storage.iteritems():
for viewerId, mask in self.__filter.iteritems():
is_new_viewer = viewerId in self.__newViewers
in_mask = dvKey in mask
is_change = self.__storage[dvKey].is_change
if in_mask and (is_change or is_new_viewer):
_buffer.setdefault(viewerId, {})[dvKey] = dataObj.data
self.__storage[dvKey].is_change = False
_puck_buffer = dict(((ID, wgPickle.dumps(wgPickle.FromServerToClient, single_buffer)) for ID, single_buffer in _buffer.iteritems()))
if len(_puck_buffer):
if IS_CLIENT:
fromClient = _puck_buffer.get(-1, None)
if fromClient:
fromClient = wgPickle.loads(wgPickle.FromServerToClient, fromClient)
BigWorld.player().debugViewer_pushToView(wgPickle.dumps(wgPickle.FromServerToServer, fromClient))
else:
BigWorld.globalData['Arbiter'].pushToView(wgPickle.dumps(wgPickle.FromServerToServer, _puck_buffer))
self.__newViewers.clear()
return
def __pushToClientNewKey(self, dvKey, keyDescription):
if IS_CLIENT:
BigWorld.player().debugViewer_addNewKey(dvKey, wgPickle.dumps(wgPickle.FromServerToServer, keyDescription))
else:
arbiter = BigWorld.globalData.get('Arbiter', False)
if arbiter:
arbiter.addNewKey(dvKey, wgPickle.dumps(wgPickle.FromServerToServer, keyDescription))
else:
self.__lazyInitialization = True
def __proccessSending(self, player):
LOG_DEBUG('Send stats data', len(self.__pendingData),
self.__pendingData)
lenToSend = 0
if not self.__pendingData:
self.__sendCallback = None
return
else:
for i, sData in enumerate(self.__pendingData):
lenToSend += len(str(sData[1]))
if i > self.MAX_SEND_STATS_COUNT or lenToSend > self.MAX_SEND_STATS_LENGTH:
break
data = wgPickle.dumps(wgPickle.FromClientToServer,
self.__pendingData[:i + 1])
if len(data) > MAX_SEND_DATA_SIZE:
LOG_ERROR('wrong stats data is to long, ingorred', len(data))
self.__sendCallback = None
return
try:
player.base.updateClientStats(CLIENT_STATS_TYPE.CLIENT_CONTROL,
data)
except:
pass
self.__pendingData = self.__pendingData[i + 1:]
if self.__pendingData:
self.__sendCallback = BigWorld.callback(
0.25, partial(self.__proccessSending, player))
else:
self.__sendCallback = None
return
def updateWaitingStats(self):
if self._account is None or self._newPendingCount == 0:
return
else:
waitData = {}
for waitingType, info in self._pending.iteritems():
infoLen = len(info)
if infoLen > 1:
info.sort()
if len(info) % 2 == 0:
median = info[infoLen // 2]
else:
median = (info[(infoLen + 1) // 2] +
info[(infoLen - 1) // 2]) / 2.0
waitData[waitingType] = [
infoLen, info[0], info[-1],
sum(info) / infoLen, median
]
elif infoLen == 1:
waitData[waitingType] = [
1, info[0], info[0], info[0], info[0]
]
if waitData:
player = self.getPlayer()
if player:
waitData = wgPickle.dumps(wgPickle.FromClientToServer,
waitData.items())
player.base.updateClientStats(
CLIENT_STATS_TYPE.CLIENT_WAITING_TIME, waitData)
self._newPendingCount = 0
return
def sendCmd(self, commandID, callback, targetID, *args):
"""
Double pickle args (cPickle+msgpack) and send them to server
:param commandID: command id (QA_FUNCTIONS)
:param callback: callback(requestID, result, response),
called in onCmdResponse
:param targetID:
:param args: command parameters (unpickled)
"""
requestID = next(idGenerator)
if callback is None:
callback = self.__onCmdCallback
if targetID == -1:
targetID = self.client.id
self.deferredRequests[requestID] = callback
argstr = wgPickle.dumps(wgPickle.FromServerToServer, args)
arg = wgPickle.dumps(wgPickle.FromClientToServer, argstr)
self.server.doCommand(requestID, commandID, targetID, arg)
return
def _sendOperationResponse(self, operation, returnCode, *args):
"""
@type operation: ReceivedOperation
@param returnCode:
@param args:
"""
responseData = wgPickle.dumps(self.__dumpsTransferType, args)
if self.__streamer:
self.__streamer.toClientReceiveResponse(
RESPONSE_TYPE.RESPONSE_TYPE_CMD, operation.invocationId,
returnCode, responseData)
else:
self._sender.receiveOperationResponse(operation.invocationId,
returnCode, responseData)
def sendOperationTo(self, recipient, operationCode, timeout, timeoutClientNotification, *args):
"""
Send operation to specific recipient
@type recipient: MAILBOX
@param operationCode:
@param timeout:
@param timeoutClientNotification:
@param args:
"""
if recipient is None:
raise Exception, 'OperationSender::sendOperationTo: Trying to send operation to recipient which is None'
if timeout is None or timeout <= 0:
timeout = None
operation = self._getNextOperation(operationCode, timeout, timeoutClientNotification)
operationData = wgPickle.dumps(self.__dumpsTransferType, args)
recipient.receiveOperation(operation.invocationId, operationCode, operationData)
return operation
def __init__(self):
self.__newViewers = set()
self.__storage = defaultdict(StorageData)
self.__addSettingsStorage = {}
self.__dvKeyArray = {}
self.__filter = {}
if IS_CLIENT:
self.setFilter(-1, wgPickle.dumps(wgPickle.FromClientToServer, {}))
else:
globalData = BigWorld.globalData
arbiterAllListener = globalData.get('ArbiterAllListener', [])
for viewerId in arbiterAllListener:
key = FILTER_KEY + str(viewerId)
try:
self.setFilter(viewerId, globalData.get(key, None))
except KeyError:
pass
self.__lazyInitialization = False
MultiUpdate.__init__(self, (0.1, self.__updateData))
return
def sendOperationTo(self, recipient, operationCode, timeout, timeoutClientNotification, *args):
"""
Send operation to specific recipient
@type recipient: MAILBOX
@param operationCode:
@param timeout:
@param timeoutClientNotification:
@param args:
"""
if recipient is None:
raise Exception, 'OperationSender::sendOperationTo: Trying to send operation to recipient which is None'
if timeout is None or timeout <= 0:
timeout = None
operation = OperationSender._getNextOperation(self, operationCode, timeout, timeoutClientNotification)
operationData = wgPickle.dumps(wgPickle.FromServerToClient, args)
if self.__receiverBase:
self.__receiverBase.toClientReceiveResponse(RESPONSE_TYPE.RESPONSE_TYPE_OPERATION, operation.invocationId, operationCode, operationData)
else:
if len(operationData) > STREAM_CLIENT.USE_PROXY_STREAM_FROM_SIZE:
LOG_ERROR('Arguments is to log, define base for send by stream functionality op, size', operationCode, len(operationData))
recipient.clientReceiveResponse(RESPONSE_TYPE.RESPONSE_TYPE_OPERATION, 0, operation.invocationId, operationCode, operationData)
return operation
DB_NAME = 'cache.dat'
CACHE_TABLE_NAME = 'cache'
CHECK_TABLE_EXIST = 'SELECT count(*) FROM sqlite_master WHERE type="table" AND name="%s"' % CACHE_TABLE_NAME
CREATE_TABLE = 'CREATE table %s (id INT64 PRIMARY KEY, data BLOB, expiringTime FLOAT)' % CACHE_TABLE_NAME
GET_DATA = 'SELECT data, expiringTime FROM %s WHERE id = ?' % CACHE_TABLE_NAME
SET_DATA = 'INSERT OR REPLACE INTO %s VALUES (?, ?, ?)' % CACHE_TABLE_NAME
DELETE_DATA = 'DELETE FROM %s WHERE id = ?' % CACHE_TABLE_NAME
REINDEX = 'REINDEX'
VACUUM = 'VACUUM'
CLEAR_CACHE_TAG = 'clear-cache'
CLEAR_CACHE_DONE = False
SQL_CONNECTION = None
CACHE_PATH = None
ID_TYPE = int
encoder = lambda data: base64.b64encode(
wgPickle.dumps(wgPickle.FromClientToClient, data, compress=False))
decoder = lambda data: wgPickle.loads(wgPickle.FromClientToClient,
base64.b64decode(data))
def init(cachePath):
global CACHE_PATH
global CLEAR_CACHE_DONE
CACHE_PATH = cachePath
LOG_DEBUG('Init sql cache...')
if CLEAR_CACHE_TAG in sys.argv and not CLEAR_CACHE_DONE:
LOG_DEBUG('Delete sql cache from command line option...')
deleteCache()
CLEAR_CACHE_DONE = True
LOG_DEBUG('Done')
__createCacheStorage()
def pushToView(self, dvKey, *args):
self.__storage[dvKey].data = wgPickle.dumps(wgPickle.FromServerToClient, *args)
def sendSystemMessage(msgType):
import wgPickle
account.sendSystemMessage(time.time(), '', wgPickle.dumps(wgPickle.FromServerToServer, {'memberID': memberID,
'planeID': planeID,
'specializationID': member[BARRACK_KEYS.SPECIALIZATION]}), msgType)