def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def init(self):
self.tryPrepareWGCLogin()
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def run(self, total_servers: int, total_arrival: int,
threshold: int) -> None:
""" Begin the simulation and record the system variables during execution.
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
- threshold :: The number of servers that must remain open for top
priority callers.
"""
# Initialise the beginning parameters of the simulation
self.servers = Servers(total_servers) # Set up server handler
self.events = M1M2EventHandler() # Set up the event handler
self.events.start() # Create the first event
# Begin iteration of events, record arrivals for checking
self.num_arrival = 0
self.arrival = {"handover": 0, "newcall": 0}
while (sum(self.num_arrival) < total_arrival):
# Collect next event from the event handler
currentEvent = self.events.next()
# Update simulation time
self.sim_time = currentEvent.time()
if currentEvent.type == "arrival":
# Arrival event received
priority = currentEvent.path
self.num_arrival += 1
self.arrival[priority] += 1
# Create new arrival event
self.events.add(
M1M2Event(priority, "arrival", currentEvent.time()))
# Check server availablity
if (len(self.servers) > threshold) or \
(priority == "handover" and self.servers.isFree()) :
# Begin serving the client.
currentEvent.servedBy(self.servers.allocate())
# All event handler to manage departure
self.events.add(currentEvent)
continue
# No servers were available therefore the event is blocked
self.events.block(
currentEvent) # Arriving client has been blocked
else:
# Departure event received
self.servers.deallocate(
currentEvent.servedBy()) # Free the server
self.events.depart(currentEvent) # Event recorded as departed.
def run(self, total_servers: int, total_arrival: int) -> None:
""" Begin the simulation of a MMCC system. Process the information until
termination criteria is meet.
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
"""
# Initialise the beginning parameters of the simulation
self.servers = Servers(total_servers) # Set up server handler
self.events = EventHandler() # Set up the event handler
startingEvent = Event("arrival", 0) # Construct the first event object
startingEvent.departure_time -= startingEvent.arrival_time # Reset times
startingEvent.arrival_time = 0 # Reset times
self.events.add(startingEvent) # Create the first event
# Begin iteration of events, record arrivals for checking
self.num_arrival = 0
while (self.num_arrival < total_arrival):
# Collect next event from the event handler
currentEvent = self.events.next()
# Update simulation time
self.sim_time = currentEvent.time()
if currentEvent.type == "arrival":
# Arrival event received
self.num_arrival += 1 # Record number of arrivals
# Create new arrival event
self.events.add(Event("arrival", currentEvent.time()))
# Check if any server is available
if not self.servers.isFree():
self.events.block(
currentEvent) # Arriving client is blocked
continue
# Begin serving the client.
currentEvent.servedBy(self.servers.allocate())
# All event handler to manage departure
self.events.add(currentEvent)
else:
# Departure event received
self.servers.deallocate(
currentEvent.servedBy()) # Free the server
self.events.depart(currentEvent) # Record departure
def init(self):
if WGC.prepare():
self.__wgcPublication = WGC.getPublication()
else:
_logger.error('WGC API initialization failed')
self.tryPrepareWGCLogin()
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def run(self, total_servers: int, arrival_total: int, threshold: int):
"""
Modified run function that adds threshold value
:param total_servers: Number of servers
:param arrival_total: Number of events
:param threshold: Servers reserved for handover calls
"""
# Setup servers, event handler and add first events
self.servers = Servers(total_servers)
self.events = EventHandlerVariant()
self.events.start()
# Start counter and iteration
self.arrival_number = 0
self.arrival = {"handover": 0, "newcall": 0}
while (sum(self.arrival_number) < arrival_total):
# Iterate to next event with handler and update sim time
current_event = self.events.next()
self.simulation_time = current_event.time()
# If arrival, update counter and add to appropriate list
if current_event.event_type == "arrival":
priority = current_event.path
self.arrival_number += 1
self.arrival[priority] += 1
self.events.add(
EventVariant(priority, "arrival", current_event.time()))
# Check server availability by priority and threshold
if (len(self.servers) > threshold) or (
priority == "handover" and self.servers.is_free()):
# Assign server to event
current_event.served_by(self.servers.allocate())
self.events.add(current_event)
continue
# Arrival has been blocked
self.events.block(current_event)
# If departure, free server and depart event
else:
self.servers.deallocate(current_event.served_by())
self.events.depart(current_event)
def run(self, server_number: int, arrival_total: int):
"""
Run simulation with specified parameters
:param server_number: Number of servers
:param arrival_total: Number of events
"""
# Initialise Servers and EventHandler
self.servers = Servers(server_number)
self.events = EventHandler()
# Create and add initial event
starting_event = Event("arrival", 0)
starting_event.departure_time -= starting_event.arrival_time
starting_event.arrival_time = 0
self.events.add(starting_event)
# Run simulation until number of events handled
self.arrival_number = 0
while (self.arrival_number < arrival_total):
# Iterate to next event and update simulation time
current_event = self.events.next()
self.simulation_time = current_event.time()
# If arrival, update counter and add to appropriate list
if current_event.event_type == "arrival":
self.arrival_number += 1
self.events.add(Event("arrival", current_event.time()))
# If no servers free, block event
if not self.servers.is_free():
self.events.block(current_event)
continue
# Assign server to event
current_event.served_by(self.servers.allocate())
self.events.add(current_event)
# If departure, free server and depart
else:
self.servers.deallocate(current_event.served_by())
self.events.depart(current_event)
class Manager(ILoginManager):
lobbyContext = dependency.descriptor(ILobbyContext)
connectionMgr = dependency.descriptor(IConnectionManager)
def __init__(self):
self._preferences = None
self.__servers = None
self.__wgcManager = None
self.__triedToInitWGC = False
return
@property
def wgcAvailable(self):
return self.__wgcManager is not None
def init(self):
self.tryPrepareWGCLogin()
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def fini(self):
self.connectionMgr.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
self.stopWgc()
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser):
isToken2Login = isSocialToken2Login or self._preferences['token2']
authMethod = CONNECTION_METHOD.TOKEN2 if isToken2Login else CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if not isSocialToken2Login:
self._preferences['login_type'] = 'credentials'
self.connectionMgr.initiateConnection(loginParams, password, serverName)
self.connectionMgr.setLastLogin(email)
def initiateRelogin(self, login, token2, serverName):
if self.wgcAvailable:
self.__wgcManager.relogin(token2, serverName)
else:
loginParams = {'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2}
self._preferences['server_name'] = serverName
self.connectionMgr.initiateConnection(loginParams, '', serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
self.lobbyContext.setCredentials(name, token2)
if self.wgcAvailable and self.__wgcManager.onLoggedOn(responseData):
self._preferences.clear()
self._preferences.writeLoginInfo()
NonRecruitNotifierSingleton().getInstance().resetFirstShowState()
return
loginCount = self._preferences.get('loginCount', 0)
self._preferences['loginCount'] = 1 if loginCount >= _LIMIT_LOGIN_COUNT else loginCount + 1
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
loginCount = self._preferences['loginCount']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences['loginCount'] = loginCount
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
NonRecruitNotifierSingleton().getInstance().resetFirstShowState()
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'})
SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and self.connectionMgr.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps((self.connectionMgr.peripheryID, time.time() + _PERIPHERY_DEFAULT_LIFETIME))
self._preferences.writeLoginInfo()
@staticmethod
def getAvailableSocialNetworks():
raise SoftException('This method should not be reached in this context')
def initiateSocialLogin(self, socialNetworkName, serverName, rememberUser, isRegistration):
raise SoftException('This method should not be reached in this context')
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(pickledData)
except Exception:
LOG_DEBUG("Couldn't to read pickled periphery data. Connecting to {0}.".format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString('user', name)
Settings.g_instance.save()
def addOnWgcErrorListener(self, listener):
if self.wgcAvailable:
self.__wgcManager.onWgcError += listener
else:
_logger.warning('Try to addOnWgcErrorListener while WGC is not available')
def removeOnWgcErrorListener(self, listener):
if self.wgcAvailable:
self.__wgcManager.onWgcError -= listener
else:
_logger.warning('Try to removeOnWgcErrorListener while WGC is not available')
def tryWgcLogin(self, serverName=None):
if not self.wgcAvailable:
_logger.warning('WGC is not available, no possibility to login via it, so return')
return
else:
if serverName is None:
selectedServer = self.__servers.selectedServer
if not selectedServer:
_logger.warning('No server was selected when WGC connect happened, so return')
return
serverName = selectedServer['data']
hostName = self._getHost(CONNECTION_METHOD.TOKEN, serverName)
self.__wgcManager.login(hostName)
return
def stopWgc(self):
if self.wgcAvailable:
self.__wgcManager.destroy()
self.__wgcManager = None
return
def tryPrepareWGCLogin(self):
if self.wgcAvailable:
if not BigWorld.WGC_prepareLogin():
self.stopWgc()
elif not self.__triedToInitWGC:
if BigWorld.WGC_prepareLogin():
self.__wgcManager = _WgcModeManager()
self.__triedToInitWGC = True
def checkWgcCouldRetry(self, status):
return self.__wgcManager.checkWgcCouldRetry(status) if self.wgcAvailable else False
class Manager(object):
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def fini(self):
connectionManager.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser):
authMethod = CONNECTION_METHOD.BASIC
self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod}
if isSocialToken2Login or self._preferences['token2']:
loginParams['auth_method'] = CONNECTION_METHOD.TOKEN2
loginParams['token2'] = self._preferences['token2']
if isSocialToken2Login:
self._preferences['login_type'] = self._preferences['login_type']
else:
self._preferences['login_type'] = 'credentials'
connectionManager.initiateConnection(loginParams, password, serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
g_lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if not constants.IS_DEVELOPMENT:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if constants.IS_DEVELOPMENT:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences.writeLoginInfo()
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'})
SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
return
class Manager(object):
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def fini(self):
connectionManager.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser):
isToken2Login = isSocialToken2Login or self._preferences['token2']
if isToken2Login:
authMethod = CONNECTION_METHOD.TOKEN2
else:
authMethod = CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if isSocialToken2Login:
self._preferences['login_type'] = self._preferences['login_type']
else:
self._preferences['login_type'] = 'credentials'
connectionManager.initiateConnection(loginParams, password, serverName)
def initiateRelogin(self, login, token2, serverName):
loginParams = {'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2}
self._preferences['server_name'] = serverName
connectionManager.initiateConnection(loginParams, '', serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
g_lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self.writePeripheryLifetime()
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'})
SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and connectionManager.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps((connectionManager.peripheryID, time.time() + _PERIPHERY_DEFAULT_LIFETIME))
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(pickledData)
except:
LOG_DEBUG("Couldn't to read pickled periphery data. Connecting to {0}.".format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
""" Dump user name to the preferences.xml (required by WGLeague's anti-cheat).
See WOTD-55587. This method doesn't belong to Preferences class, so it's placed here.
"""
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString('user', name)
Settings.g_instance.save()
class MMCC:
"""
Class to simulate M/M/C/C system
"""
def run(self, server_number: int, arrival_total: int):
"""
Run simulation with specified parameters
:param server_number: Number of servers
:param arrival_total: Number of events
"""
# Initialise Servers and EventHandler
self.servers = Servers(server_number)
self.events = EventHandler()
# Create and add initial event
starting_event = Event("arrival", 0)
starting_event.departure_time -= starting_event.arrival_time
starting_event.arrival_time = 0
self.events.add(starting_event)
# Run simulation until number of events handled
self.arrival_number = 0
while (self.arrival_number < arrival_total):
# Iterate to next event and update simulation time
current_event = self.events.next()
self.simulation_time = current_event.time()
# If arrival, update counter and add to appropriate list
if current_event.event_type == "arrival":
self.arrival_number += 1
self.events.add(Event("arrival", current_event.time()))
# If no servers free, block event
if not self.servers.is_free():
self.events.block(current_event)
continue
# Assign server to event
current_event.served_by(self.servers.allocate())
self.events.add(current_event)
# If departure, free server and depart
else:
self.servers.deallocate(current_event.served_by())
self.events.depart(current_event)
def blocking_probability(self) -> float:
"""
Obtain blocking probability of previous run
:return: Blocking probability
"""
return len(self.events.blocked) / self.arrival_number
def server_utilisation(self) -> float:
"""
Obtain server utilisation of previous run
:return: Server utilisation
"""
return sum([e.service_time()
for e in self.events.departed]) / self.simulation_time
class Manager(ILoginManager):
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
connectionManager.onLoggedOn += self._onLoggedOn
def fini(self):
connectionManager.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login,
rememberUser):
isToken2Login = isSocialToken2Login or self._preferences['token2']
if isToken2Login:
authMethod = CONNECTION_METHOD.TOKEN2
else:
authMethod = CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(
self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {
'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod
}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if not isSocialToken2Login:
self._preferences['login_type'] = 'credentials'
connectionManager.initiateConnection(loginParams, password, serverName)
def initiateRelogin(self, login, token2, serverName):
loginParams = {
'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2
}
self._preferences['server_name'] = serverName
connectionManager.initiateConnection(loginParams, '', serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
g_lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString(
'html_templates:lobby/system_messages', 'link', {
'text': _ms(
SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'
})
SystemMessages.pushI18nMessage(
'#system_messages:securityMessage/%s' % securityWarningType,
type=SystemMessages.SM_TYPE.Warning,
link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and connectionManager.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps(
(connectionManager.peripheryID,
time.time() + _PERIPHERY_DEFAULT_LIFETIME))
self._preferences.writeLoginInfo()
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(
pickledData)
except:
LOG_DEBUG(
"Couldn't to read pickled periphery data. Connecting to {0}."
.format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
""" Dump user name to the preferences.xml (required by WGLeague's anti-cheat).
See WOTD-55587. This method doesn't belong to Preferences class, so it's placed here.
"""
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString(
'user', name)
Settings.g_instance.save()
class M1M2MCC(MMCC):
"""
Class to simulate M1/M2/M/C/C system
"""
def run(self, total_servers: int, arrival_total: int, threshold: int):
"""
Modified run function that adds threshold value
:param total_servers: Number of servers
:param arrival_total: Number of events
:param threshold: Servers reserved for handover calls
"""
# Setup servers, event handler and add first events
self.servers = Servers(total_servers)
self.events = EventHandlerVariant()
self.events.start()
# Start counter and iteration
self.arrival_number = 0
self.arrival = {"handover": 0, "newcall": 0}
while (sum(self.arrival_number) < arrival_total):
# Iterate to next event with handler and update sim time
current_event = self.events.next()
self.simulation_time = current_event.time()
# If arrival, update counter and add to appropriate list
if current_event.event_type == "arrival":
priority = current_event.path
self.arrival_number += 1
self.arrival[priority] += 1
self.events.add(
EventVariant(priority, "arrival", current_event.time()))
# Check server availability by priority and threshold
if (len(self.servers) > threshold) or (
priority == "handover" and self.servers.is_free()):
# Assign server to event
current_event.served_by(self.servers.allocate())
self.events.add(current_event)
continue
# Arrival has been blocked
self.events.block(current_event)
# If departure, free server and depart event
else:
self.servers.deallocate(current_event.served_by())
self.events.depart(current_event)
def blocking_probability(self):
"""
Obtain aggregated blocking probability of previous run
:return: Blocking probability
"""
HFP = len(self.events.blocked_handover) / self.arrival["handover"] \
if self.arrival["handover"] else 0
CBP = len(self.events.blocked_newcall) / self.arrival["newcall"] \
if self.arrival["newcall"] else 0
return CBP + (10 * HFP)
class MMCC:
""" Simulation object tasked with conducting the MMCC system """
def run(self, total_servers: int, total_arrival: int) -> None:
""" Begin the simulation of a MMCC system. Process the information until
termination criteria is meet.
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
"""
# Initialise the beginning parameters of the simulation
self.servers = Servers(total_servers) # Set up server handler
self.events = EventHandler() # Set up the event handler
startingEvent = Event("arrival", 0) # Construct the first event object
startingEvent.departure_time -= startingEvent.arrival_time # Reset times
startingEvent.arrival_time = 0 # Reset times
self.events.add(startingEvent) # Create the first event
# Begin iteration of events, record arrivals for checking
self.num_arrival = 0
while (self.num_arrival < total_arrival):
# Collect next event from the event handler
currentEvent = self.events.next()
# Update simulation time
self.sim_time = currentEvent.time()
if currentEvent.type == "arrival":
# Arrival event received
self.num_arrival += 1 # Record number of arrivals
# Create new arrival event
self.events.add(Event("arrival", currentEvent.time()))
# Check if any server is available
if not self.servers.isFree():
self.events.block(
currentEvent) # Arriving client is blocked
continue
# Begin serving the client.
currentEvent.servedBy(self.servers.allocate())
# All event handler to manage departure
self.events.add(currentEvent)
else:
# Departure event received
self.servers.deallocate(
currentEvent.servedBy()) # Free the server
self.events.depart(currentEvent) # Record departure
def blockingProbability(self) -> float:
""" Calculate the blocking probability for the previous simulation run.
Returns:
- float :: Probability of blocking
"""
return len(self.events.blocked) / self.num_arrival
def serverUtilisation(self) -> float:
""" Calculate the server utilisation for the previous simulation run.
Returns:
- float :: Server utilisation value
"""
return sum([e.serviceTime()
for e in self.events.departed]) / self.sim_time
def report(self) -> None:
""" Display the results of the simulation is a readible fashion. """
print("\tEvents Handled ::")
print("\t\tArrival:", self.num_arrival)
incomplete = self.num_arrival - (len(self.events.departed) +
len(self.events.blocked))
print("\t\tIncomplete events:", incomplete)
print("\t\tDeparture:", len(self.events.departed))
print("\t\tBlocked:", len(self.events.blocked))
print("\tBlocking rate:", self.blockingProbability())
print("\tServer Utilisation:", self.serverUtilisation())
def __init__(self):
self.servers = Servers()
self.IP = dict() #2^24
self.p0 = self.p1 = self.p2 = self.p3 = self.p4 = 0
self.serverTimeOut = 1
self.pcktCount = 0
class Manager(ILoginManager):
lobbyContext = dependency.descriptor(ILobbyContext)
connectionMgr = dependency.descriptor(IConnectionManager)
def __init__(self):
self._preferences = None
self.__servers = None
return
def init(self):
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def fini(self):
self.connectionMgr.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login,
rememberUser):
isWgcLogin = BigWorld.WGC_processingState(
) == constants.WGC_STATE.LOGIN_IN_PROGRESS
if not isWgcLogin:
isToken2Login = isSocialToken2Login or self._preferences['token2']
if isToken2Login:
authMethod = CONNECTION_METHOD.TOKEN2
else:
authMethod = CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(
self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {
'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod
}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if not isSocialToken2Login:
self._preferences['login_type'] = 'credentials'
else:
loginParams = BigWorld.WGC_loginData()
if loginParams is None:
return
authMethod = loginParams.get('auth_method', None)
if authMethod is None:
return
serverName = self._getHost(authMethod, serverName)
self.connectionMgr.initiateConnection(loginParams, password,
serverName)
self.connectionMgr.setLastLogin(email)
return
def initiateRelogin(self, login, token2, serverName):
loginParams = None
if login == 'wgc':
if not BigWorld.WGC_prepareLogin():
return
loginParams = BigWorld.WGC_loginData()
if loginParams is None:
loginParams = {
'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2
}
self._preferences['server_name'] = serverName
self.connectionMgr.initiateConnection(loginParams, '', serverName)
return
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
if BigWorld.WGC_processingState() == constants.WGC_STATE.LOGGEDIN:
BigWorld.WGC_storeToken2(responseData['token2'])
else:
self.lobbyContext.setCredentials(name, token2)
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString(
'html_templates:lobby/system_messages', 'link', {
'text': _ms(
SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'
})
SystemMessages.pushI18nMessage(
'#system_messages:securityMessage/%s' % securityWarningType,
type=SystemMessages.SM_TYPE.Warning,
link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and self.connectionMgr.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps(
(self.connectionMgr.peripheryID,
time.time() + _PERIPHERY_DEFAULT_LIFETIME))
self._preferences.writeLoginInfo()
@staticmethod
def getAvailableSocialNetworks():
raise SoftException(
'This method should not be reached in this context')
def initiateSocialLogin(self, socialNetworkName, serverName, rememberUser,
isRegistration):
raise SoftException(
'This method should not be reached in this context')
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(
pickledData)
except Exception:
LOG_DEBUG(
"Couldn't to read pickled periphery data. Connecting to {0}."
.format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString(
'user', name)
Settings.g_instance.save()
class M1M2CC(MMCC):
def run(self, total_servers: int, total_arrival: int,
threshold: int) -> None:
""" Begin the simulation and record the system variables during execution.
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
- threshold :: The number of servers that must remain open for top
priority callers.
"""
# Initialise the beginning parameters of the simulation
self.servers = Servers(total_servers) # Set up server handler
self.events = M1M2EventHandler() # Set up the event handler
self.events.start() # Create the first event
# Begin iteration of events, record arrivals for checking
self.num_arrival = 0
self.arrival = {"handover": 0, "newcall": 0}
while (sum(self.num_arrival) < total_arrival):
# Collect next event from the event handler
currentEvent = self.events.next()
# Update simulation time
self.sim_time = currentEvent.time()
if currentEvent.type == "arrival":
# Arrival event received
priority = currentEvent.path
self.num_arrival += 1
self.arrival[priority] += 1
# Create new arrival event
self.events.add(
M1M2Event(priority, "arrival", currentEvent.time()))
# Check server availablity
if (len(self.servers) > threshold) or \
(priority == "handover" and self.servers.isFree()) :
# Begin serving the client.
currentEvent.servedBy(self.servers.allocate())
# All event handler to manage departure
self.events.add(currentEvent)
continue
# No servers were available therefore the event is blocked
self.events.block(
currentEvent) # Arriving client has been blocked
else:
# Departure event received
self.servers.deallocate(
currentEvent.servedBy()) # Free the server
self.events.depart(currentEvent) # Event recorded as departed.
def blockingProbability(self):
""" Calculate the blocking probability for the previous simulation run.
Returns:
- float :: Probability of blocking
"""
HFP = len(self.events.hblocked)/self.arrival["handover"] \
if self.arrival["handover"] else 0
CBP = len(self.events.nblocked)/self.arrival["newcall"] \
if self.arrival["newcall"] else 0
return CBP + (10 * HFP)
def report(self) -> None:
""" Display the results of the simulation is a readible fashion. """
print("\tEvents Handled ::")
print("\t\tArrival:", self.num_arrival)
print("\t\tHandover:", self.arrival["handover"])
print("\t\tNew call:", self.arrival["newcall"])
incomplete = self.num_arrival - \
(len(self.events.departed) + len(self.events.hblocked) + len(self.events.nblocked))
print("\t\tIncomplete events:", incomplete)
print("\t\tDeparture:", len(self.events.departed))
print("\t\tBlocked:",
len(self.events.hblocked) + len(self.events.nblocked))
print("\t\tHandover blocked:", len(self.events.hblocked))
print("\t\tNew call blocked:", len(self.events.nblocked))
print("\tBlocking rate:", self.blockingProbability())
print("\tServer Utilisation:", self.serverUtilisation())
