def trigger(self, eventName, args=()): Logging.debug("Event: " + str(eventName) + " " + str(args)) for handler in self.allHandlers: handler(eventName, args) try: #Logging.debug("Event handlers: " + str(self.events[eventName])) for event in self.events[eventName]: info = EventInformation.getEventHandlerInfo(event) if info != None: if info.isCommandType: try: cn = args[0] Players = cxsbs.getResource('Events').Players p = Players.player(cn) if not EventInformation.allowEvent(info, p): UI.insufficientPermissions(p.cn) return except: Logging.error("Players probably was not bootstrapped into the event framework. Make sure a Players modules is loaded and does this.") if info != None and info.threaded: ProcessingThread.queue(executeEvent, (event, args)) else: executeEvent(event, args) except KeyError: pass
def frame(self): if self.printFrame: print "Frame %s occurred..." % self.frameCount import cxsbs Events = cxsbs.getResource("Events") Events.update() for generator in self.generators: generator.frame(time.time(), self.frameCount) self.generators = filter(notStale, self.generators)
def trigger(self): import cxsbs Events = cxsbs.getResource("Events") startTime = time.time() Events.triggerServerEvent(self.type, self.args) endTime = time.time() totalEventTime = endTime - startTime if not self.type in eventRunTimes.keys(): eventRunTimes[self.type] = [] eventRunTimes[self.type].append(totalEventTime)
def initializeDatabaseManager(): """returns the correct DatabaseManager instance""" backendName = DatabaseManagerBase.getBackendName() DatabaseManagerBackendModule = cxsbs.getResource(backendName) try: DatabaseManagerBackendClass = DatabaseManagerBackendModule.__getattribute__("DatabaseManagerBackend") except AttributeError: raise MissingResourceComponent(backendName, "DatabaseManagerBackend", "class") if not issubclass(DatabaseManagerBackendClass, DatabaseManagerBase.DatabaseManagerBackend): raise InvalidResourceComponent(backendName, "DatabaseManagerBackend", "class") return DatabaseManagerBackendClass()
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Events = cxsbs.getResource("Events") Players = cxsbs.getResource("Players") Logging = cxsbs.getResource("Logging") ServerCore = cxsbs.getResource("ServerCore") Messages = cxsbs.getResource("Messages") SetMaster = cxsbs.getResource("SetMaster") pluginCategory = 'MasterMode' SettingsManager.addSetting(Setting.BoolSetting ( category=pluginCategory, subcategory="General", symbolicName="reset_when_empty", displayName="Reset when empty", default=True, doc="Whether or not to reset mastermode when the server becomes empty."
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs DatabaseManager = cxsbs.getResource("DatabaseManager") SettingsManager = cxsbs.getResource("SettingsManager") Setting = cxsbs.getResource("Setting") Players = cxsbs.getResource("Players") Messages = cxsbs.getResource("Messages") Commands = cxsbs.getResource("Commands") from sqlalchemy import Column, Integer, String, Boolean, ForeignKey, BigInteger from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound import time, string Base = declarative_base() class ModeratorMessage(Base): __table_args__ = {'extend_existing': True} __tablename__= tableSettings["table_name"]
specManager = PunitiveManager(SpectCore.Spect, "Spectate") ManageCore.registerManager("spec", specManager) def unload(self): pass from sqlalchemy.sql.expression import or_ from sqlalchemy.sql.expression import func import time import timestring import prettytime import cxsbs ServerCore = cxsbs.getResource("ServerCore") Net = cxsbs.getResource("Net") Messages = cxsbs.getResource("Messages") ManageCore = cxsbs.getResource("ManageCore") Colors = cxsbs.getResource("Colors") Players = cxsbs.getResource("Players") Commands = cxsbs.getResource("Commands") DatabaseManager = cxsbs.getResource("DatabaseManager") PunitiveCommands = cxsbs.getResource("PunitiveCommands") Logging = cxsbs.getResource("Logging") BanCore = cxsbs.getResource("BanCore") MuteCore = cxsbs.getResource("MuteCore") SpectCore = cxsbs.getResource("SpectCore") pluginCategory = "ManagePunitive"
eventManager = EventManager.EventManager() policyEventManager = PolicyEventManager.PolicyEventManager() #eventManager.events.clear() #policyEventManager.events.clear() def unload(self): global dont_iterate dont_iterate = True reactor.stop() reactor.runUntilCurrent() #@UndefinedVariable reactor.doIteration(0) #@UndefinedVariable import cxsbs Logging = cxsbs.getResource("Logging") EventInformation = cxsbs.getResource("EventInformation") import cxsbs.AsyncronousExecutor from twisted.internet import reactor import traceback eventManager = None policyEventManager = None exec_queue = [] def registerServerEventHandler(event, func): '''Call function when event has been executed.''' EventInformation.loadEventHandlerInfo(event, func)
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs Messages = cxsbs.getResource("Messages") Logging = cxsbs.getResource("Logging") ServerCore = cxsbs.getResource("ServerCore") Colors = cxsbs.getResource("Colors") UI = cxsbs.getResource("UI") Players = cxsbs.getResource("Players") CommandInformation = cxsbs.getResource("CommandInformation") import cxsbs.Logging Messages.addMessage ( subcategory="Help", symbolicName="available_commands", displayName="Available commands", default="${help}${yellow}Available commands:${white} ${commands}.", doc="Prefix for #listcommands command.", )
cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass from sqlalchemy import Column, Integer, BigInteger, String, func from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound import cxsbs ServerCore = cxsbs.getResource("ServerCore") DatabaseManager = cxsbs.getResource("DatabaseManager") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Commands = cxsbs.getResource("Commands") Events = cxsbs.getResource("Events") Messages = cxsbs.getResource("Messages") Players = cxsbs.getResource("Players") Colors = cxsbs.getResource("Colors") pluginCategory = "AliasTracking" SettingsManager.addSetting( Setting.Setting( category=DatabaseManager.getDbSettingsCategory(), subcategory=pluginCategory,
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs Commands = cxsbs.getResource("Commands") Players = cxsbs.getResource("Players") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") pluginCategory = "PrivateMessage" SettingsManager.addSetting(Setting.TemplateSetting ( category="Messages", subcategory=pluginCategory, symbolicName="pm_prefix", displayName="Pm prefix", default="[pm]: ${message}", doc="Prefix for a private message." )) settings = SettingsManager.getAccessor(category="Messages", subcategory=pluginCategory)
def unload(self): pass from sqlalchemy import Column, Integer, String, Boolean from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound from sqlalchemy.sql.expression import func from twisted.internet.task import LoopingCall import string, time Base = declarative_base() import cxsbs Players = cxsbs.getResource("Players") DatabaseManager = cxsbs.getResource("DatabaseManager") BanCore = cxsbs.getResource("BanCore") Colors = cxsbs.getResource("Colors") Events = cxsbs.getResource("Events") Timers = cxsbs.getResource("Timers") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Messages = cxsbs.getResource("Messages") Commands = cxsbs.getResource("Commands") ClanTags = cxsbs.getResource("ClanTags") Users = cxsbs.getResource("Users") UserModel = cxsbs.getResource("UserModel") pluginCategory = 'UserNames'
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): init() def unload(self): pass import cxsbs.Logging import cxsbs Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") class EventInfo: def __init__(self, event, handler): self.handler = handler self.name = self.handler.__name__ + '@' + self.handler.__module__ self.event = event self.id = id(handler) self.isCommandType = False self.threaded = False self.allowGroups = [] self.denyGroups = [] self.allowFunctionGroups = {} self.denyFunctionGroups = {} self.documentation = ''
def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def reload(self): pass def unload(self): pass import cxsbs ServerCore = cxsbs.getResource("ServerCore") Colors = cxsbs.getResource("Colors") UI = cxsbs.getResource("UI") Server = cxsbs.getResource("Server") Commands = cxsbs.getResource("Commands") teams = ["evil", "good", "other"] def teamName(teamnum): """String representing the team name""" return teams[teamnum] def teamNumber(teamname): """Number representing one of the two major teams"""
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs Commands = cxsbs.getResource("Commands") Messages = cxsbs.getResource("Messages") ServerCore = cxsbs.getResource("ServerCore") Players = cxsbs.getResource("Players") pluginCategory = "ChainSawMode" Messages.addMessage ( subcategory=pluginCategory, symbolicName='action', displayName='action', default="${info}Chainsaw only mode is now ${blue}${status}${white}.", doc="Message to print to show whether or not chainsaw only mode has just been enabled or disabled." ) messager = Messages.getAccessor(subcategory=pluginCategory) @Commands.commandHandler('chainsawmode')
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs DatabaseManagerBase = cxsbs.getResource("DatabaseManagerBase") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") subcategory = "Mysql" SettingsManager.addSetting(Setting.Setting ( category=DatabaseManagerBase.databaseConfigurationFilename, subcategory=subcategory, symbolicName="host", displayName="Host", default="localhost", doc="Database host to connect to.", )) SettingsManager.addSetting(Setting.Setting ( category=DatabaseManagerBase.databaseConfigurationFilename, subcategory=subcategory,
import sys import traceback import cxsbs Logging = cxsbs.getResource("Logging") UI = cxsbs.getResource("UI") EventInformation = cxsbs.getResource("EventInformation") ProcessingThread = cxsbs.getResource("ProcessingThread") def executeEvent(func, args): """Used to execute the event itself""" try: func(*args) except: exceptionType, exceptionValue, exceptionTraceback = sys.exc_info() Logging.error('Uncaught exception occurred in event handler.') Logging.error(traceback.format_exc()) class EventManager: def __init__(self, Players=None): self.Players = Players self.events = {} self.allHandlers = [] def connectAll(self, func): self.allHandlers.append(func) def connect(self, event, func): if not event in self.events.keys(): self.events[event] = [] for i in range(len(self.events[event])): f = self.events[event][i]
cxsbs.Plugin.Plugin.__init__(self) def load(self): global nextRequestId nextRequestId = int(time.time()) global requestIdTable requestIdTable = {} def unload(self): pass import time import cxsbs UserModel = cxsbs.getResource("UserModel") Players = cxsbs.getResource("Players") UserModelBase = cxsbs.getResource("UserModelBase") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Messages = cxsbs.getResource("Messages") Commands = cxsbs.getResource("Commands") Events = cxsbs.getResource("Events") Timers = cxsbs.getResource("Timers") Auth = cxsbs.getResource("Auth") ServerCore = cxsbs.getResource("ServerCore") Email = cxsbs.getResource("Email") CommandInformation = cxsbs.getResource("CommandInformation") ProcessingThread = cxsbs.getResource("ProcessingThread") pluginCategory = 'Users'
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): if settings["default_size"] % 2 == 1: Logging.warn("Even server sizes are recommended for consistent capacity scaling behavior.") def unload(self): pass import cxsbs Server = cxsbs.getResource("Server") Events = cxsbs.getResource("Events") Logging = cxsbs.getResource("Logging") Setting = cxsbs.getResource("Setting") ServerCore = cxsbs.getResource("ServerCore") SettingsManager = cxsbs.getResource("SettingsManager") pluginCategory = 'Capacity' pluginSubcategory = 'General' SettingsManager.addSetting(Setting.BoolSetting ( category=pluginCategory, subcategory=pluginSubcategory, symbolicName="pause_when_vacant", displayName="Pause when vacant", default=True, doc="Whether or not the server should pause itself when it has no clients."
def unload(self): pass from sqlalchemy import Column, Integer, String, ForeignKey from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound from sqlalchemy.orm import relation, mapper from sqlalchemy.schema import UniqueConstraint Base = declarative_base() import ppwgen, time import cxsbs UserModelBase = cxsbs.getResource("UserModelBase") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") DatabaseManager = cxsbs.getResource("DatabaseManager") Auth = cxsbs.getResource("Auth") pluginCategory = 'Users' SettingsManager.addSetting(Setting.Setting ( category=DatabaseManager.getDbSettingsCategory(), subcategory=pluginCategory, symbolicName="user_table", displayName="User table", default="usermanager_users", doc="Table name for storing the users." ))
def unload(self): self.statWriter.stop() from sqlalchemy import Column, Integer, BigInteger, String, Boolean, ForeignKey from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound from sqlalchemy.orm import relation, mapper from sqlalchemy.schema import UniqueConstraint from sqlalchemy.sql.expression import func import time, threading Base = declarative_base() import cxsbs Events = cxsbs.getResource("Events") Players = cxsbs.getResource("Players") Users = cxsbs.getResource("Users") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Messages = cxsbs.getResource("Messages") Game = cxsbs.getResource("Game") DatabaseManager = cxsbs.getResource("DatabaseManager") ServerCore = cxsbs.getResource("ServerCore") pluginCategory = "UserStats" SettingsManager.addSetting(Setting.Setting ( category=DatabaseManager.getDbSettingsCategory(), subcategory=pluginCategory, symbolicName="damage_spent_event_table_name",
def load(self): global spamManager spamManager = SpamManager() Events.registerAllEventHandler(spamManager.all_event_handler) Events.registerServerEventHandler("player_disconnect", spamManager.onDisconnect) Events.registerServerEventHandler("map_changed", spamManager.onNewGame) def unload(self): pass import time import cxsbs MuteCore = cxsbs.getResource("MuteCore") BanCore = cxsbs.getResource("BanCore") SpectCore = cxsbs.getResource("SpectCore") Messages = cxsbs.getResource("Messages") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Logging = cxsbs.getResource("Logging") Events = cxsbs.getResource("Events") ServerCore = cxsbs.getResource("ServerCore") Players = cxsbs.getResource("Players") pluginCategory = "Spam" Messages.addMessage ( subcategory=pluginCategory, symbolicName="spam_warning",
def load(self): #create the circular reference so that Players can be referenced later #from inside Events Events.bootStrapPlayersModule(cxsbs.getResource("Players")) global players players = {} for cn in ServerCore.clients(): addPlayerForCn(cn) def unload(self): pass import cxsbs Events = cxsbs.getResource("Events") UI = cxsbs.getResource("UI") Timers = cxsbs.getResource("Timers") ServerCore = cxsbs.getResource("ServerCore") Logging = cxsbs.getResource("Logging") Net = cxsbs.getResource("Net") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") PlayerDisconnect = cxsbs.getResource('PlayerDisconnect') permissionsCategory = 'Permissions' pluginSubcategory = 'Invisibility' SettingsManager.addSetting(Setting.ListSetting ( category=permissionsCategory, subcategory=pluginSubcategory,
class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): global messagesManager messagesManager = MessagesManager(SettingsManager.settingsManager) def unload(self): pass import operator from groups.Query import Select, Compare import cxsbs Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") UI = cxsbs.getResource("UI") Colors = cxsbs.getResource("Colors") Players = cxsbs.getResource("Players") import sys, traceback class Accessor: '''Thin interface to the settingsManager to clean up sending of messages for a particular plugin''' def __init__(self, messagesManager, category, subcategory): self.messagesManager = messagesManager self.category = category self.subcategory = subcategory def __str__(self):
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import pygeoip, os import cxsbs Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Messages = cxsbs.getResource("Messages") Commands = cxsbs.getResource("Commands") Players = cxsbs.getResource("Players") Net = cxsbs.getResource("Net") Events = cxsbs.getResource("Events") pluginCategory = "GeoIp" SettingsManager.addSetting(Setting.Setting ( category=pluginCategory, subcategory="General", symbolicName="geoIp_db_path", displayName="GeoIp Database Path", default=os.path.abspath("./resources/GeoIP.dat"),
class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): global commandPipe commandPipe = CommandPipe() commandPipe.start() def unload(self): pass import threading, sys, traceback import cxsbs SettingsManager = cxsbs.getResource("SettingsManager") ServerCore = cxsbs.getResource("ServerCore") Messages = cxsbs.getResource("Messages") Players = cxsbs.getResource("Players") pluginCategory = 'CommandPipe' Messages.addMessage ( subcategory=pluginCategory, symbolicName="on_shutdown", displayName="On shutdown", default="${warning}The server is shutting down, you will be disconnected momentarily.", doc="Message to print when the server has been shutdown via the CommandPipe." ) Messages.addMessage (
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs Players = cxsbs.getResource("Players") DatabaseManager = cxsbs.getResource("DatabaseManager") Events = cxsbs.getResource("Events") Timers = cxsbs.getResource("Timers") ServerCore = cxsbs.getResource("ServerCore") SettingsManager = cxsbs.getResource("SettingsManager") Setting = cxsbs.getResource("Setting") Messages = cxsbs.getResource("Messages") Net = cxsbs.getResource("Net") from sqlalchemy import Column, Integer, String, Boolean, ForeignKey, BigInteger from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound import time, string Base = declarative_base()
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs ServerCore = cxsbs.getResource("ServerCore") DISC_NONE = 0 DISC_EOP = 1 DISC_CN = 2 DISC_KICK = 3 DISC_TAGT = 4 DISC_IPBAN = 5 DISC_PRIVATE = 6 DISC_MAXCLIENTS = 7 DISC_TIMEOUT = 8 DISC_OVERFLOW = 9 DISC_NUM = 10 def disconnect(cn, reason): "Disconnect a client for a specified reason." ServerCore.playerDisconnect(cn, reason)
import cxsbs.Plugin class Plugin(cxsbs.Plugin.Plugin): def __init__(self): cxsbs.Plugin.Plugin.__init__(self) def load(self): pass def unload(self): pass import cxsbs ServerCore = cxsbs.getResource("ServerCore") Events = cxsbs.getResource("Events") UI = cxsbs.getResource("UI") Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") Colors = cxsbs.getResource("Colors") Logging = cxsbs.getResource("Logging") Players = cxsbs.getResource("Players") Commands = cxsbs.getResource("Commands") Messages = cxsbs.getResource("Messages") pluginCategory = 'Demo' SettingsManager.addSetting(Setting.BoolSetting ( category=pluginCategory, subcategory="General", symbolicName="persistent_recording", displayName="Persistent recording",
raise InvalidResourceComponent(settings['users_model'], "Model", "class") import re usernameValidator = lambda x: re.match(settings['invalid_username_expression'], x) authenticationTokenValidator = lambda x: re.match(settings['invalid_token_seed_expression'], x) groupValidator = lambda x: re.match(settings['invalid_group_expression'], x) global model model = modelClass() def unload(self): pass import cxsbs Setting = cxsbs.getResource("Setting") SettingsManager = cxsbs.getResource("SettingsManager") UserModelBase = cxsbs.getResource("UserModelBase") pluginCategory = 'Users' SettingsManager.addSetting(Setting.Setting ( category=pluginCategory, subcategory="General", symbolicName="users_model", displayName="User model", default='UserModelIntegrated', doc="User model to use." )) SettingsManager.addSetting(Setting.BoolSetting (