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 (
