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())