def run(config=None):
if config:
config = b3.getAbsolutePath(config)
else:
# search for the config file
config = None
for p in (
"b3.xml",
"conf/b3.xml",
"b3/conf/b3.xml",
"~/b3.xml",
"~/conf/b3.xml",
"~/b3/conf/b3.xml",
"@b3/conf/b3.xml",
):
path = b3.getAbsolutePath(p)
print "Searching for config file: %s" % path
if os.path.isfile(path):
config = path
break
if not config:
Setup(config)
# raise SystemExit('Could not find config file.')
b3.start(config)
def __init__(self, config=None):
"""
Object constructor.
:param config: The B3 configuration file path
"""
if config:
# use the specified configuration file
config = b3.getAbsolutePath(config, True)
if not os.path.isfile(config):
console_exit('ERROR: configuration file not found (%s).\n'
'Please visit %s to create one.' % (config, B3_CONFIG_GENERATOR))
else:
# search a configuration file
for p in ('b3.%s', 'conf/b3.%s', 'b3/conf/b3.%s',
os.path.join(HOMEDIR, 'b3.%s'), os.path.join(HOMEDIR, 'conf', 'b3.%s'),
os.path.join(HOMEDIR, 'b3', 'conf', 'b3.%s'), '@b3/conf/b3.%s'):
for e in ('ini', 'cfg', 'xml'):
path = b3.getAbsolutePath(p % e, True)
if os.path.isfile(path):
print "Using configuration file: %s" % path
config = path
sleep(3)
break
if not config:
console_exit('ERROR: could not find any valid configuration file.\n'
'Please visit %s to create one.' % B3_CONFIG_GENERATOR)
try:
self.config = b3.config.MainConfig(b3.config.load(config))
if self.config.analyze():
raise b3.config.ConfigFileNotValid
except b3.config.ConfigFileNotValid:
console_exit('ERROR: configuration file not valid (%s).\n'
'Please visit %s to generate a new one.' % (config, B3_CONFIG_GENERATOR))
def run_console(options):
"""
Run B3 in console mode.
:param options: command line options
"""
analysis = None # main config analysis result
printexit = False # whether the exit message has been printed alreadty or not
try:
if options.config:
config = b3.getAbsolutePath(options.config, True)
if not os.path.isfile(config):
printexit = True
console_exit('ERROR: configuration file not found (%s).\n'
'Please visit %s to create one.' % (config, B3_CONFIG_GENERATOR))
else:
config = None
for p in ('b3.%s', 'conf/b3.%s', 'b3/conf/b3.%s',
os.path.join(HOMEDIR, 'b3.%s'), os.path.join(HOMEDIR, 'conf', 'b3.%s'),
os.path.join(HOMEDIR, 'b3', 'conf', 'b3.%s'), '@b3/conf/b3.%s'):
for e in ('ini', 'cfg', 'xml'):
path = b3.getAbsolutePath(p % e, True)
if os.path.isfile(path):
print "Using configuration file: %s" % path
config = path
sleep(3)
break
if not config:
printexit = True
console_exit('ERROR: could not find any valid configuration file.\n'
'Please visit %s to create one.' % B3_CONFIG_GENERATOR)
# LOADING MAIN CONFIGURATION
main_config = b3.config.MainConfig(b3.config.load(config))
analysis = main_config.analyze()
if analysis:
raise b3.config.ConfigFileNotValid('invalid configuration file specified')
# START B3
b3.start(main_config, options)
except b3.config.ConfigFileNotValid:
if analysis:
print 'CRITICAL: invalid configuration file specified:\n'
for problem in analysis:
print" >>> %s\n" % problem
else:
print 'CRITICAL: invalid configuration file specified!'
raise SystemExit(1)
except SystemExit, msg:
if not printexit and main_is_frozen():
if sys.stdout != sys.__stdout__:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
print msg
raw_input("press any key to continue...")
raise
def run(options):
"""
Run B3 in console.
:param options: command line options
"""
analysis = None # main config analysis result
printexit = False # whether the exit message has been printed alreadty or not
try:
if options.config:
config = b3.getAbsolutePath(options.config, True)
if not os.path.isfile(config):
printexit = True
console_exit('ERROR: configuration file not found (%s).\n'
'Please visit %s to create one.' % (config, B3_CONFIG_GENERATOR))
else:
config = None
for p in ('b3.%s', 'conf/b3.%s', 'b3/conf/b3.%s',
os.path.join(HOMEDIR, 'b3.%s'), os.path.join(HOMEDIR, 'conf', 'b3.%s'),
os.path.join(HOMEDIR, 'b3', 'conf', 'b3.%s'), '@b3/conf/b3.%s'):
for e in ('ini', 'cfg', 'xml'):
path = b3.getAbsolutePath(p % e, True)
if os.path.isfile(path):
print "Using configuration file: %s" % path
config = path
sleep(3)
break
if not config:
printexit = True
console_exit('ERROR: could not find any valid configuration file.\n'
'Please visit %s to create one.' % B3_CONFIG_GENERATOR)
# LOADING MAIN CONFIGURATION
main_config = b3.config.MainConfig(b3.config.load(config))
analysis = main_config.analyze()
if analysis:
raise b3.config.ConfigFileNotValid('invalid configuration file specified')
# START B3
b3.start(main_config, options)
except b3.config.ConfigFileNotValid:
if analysis:
print 'CRITICAL: invalid configuration file specified:\n'
for problem in analysis:
print" >>> %s\n" % problem
else:
print 'CRITICAL: invalid configuration file specified!'
raise SystemExit(1)
except SystemExit, msg:
if not printexit and main_is_frozen():
if sys.stdout != sys.__stdout__:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
print msg
raw_input("press any key to continue...")
raise
def init(self, config_content=None):
""" load plugin config and initialise the plugin """
if config_content:
self.conf.loadFromString(config_content)
else:
if os.path.isfile(b3.getAbsolutePath('@b3/conf/plugin_chatlogger.ini')):
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_chatlogger.ini'))
else:
raise unittest.SkipTest("default config file '%s' does not exists" % b3.getAbsolutePath('@b3/conf/plugin_chatlogger.ini'))
self.p.onLoadConfig()
self.p.onStartup()
def test_nominal(self):
# GIVEN
existing_file_path = b3.getAbsolutePath('/a/file/that/exists')
when(os.path).isfile(existing_file_path).thenReturn(True)
self.conf.loadFromString(dedent(r"""
[settings]
private_key_file: /a/file/that/exists
"""))
# WHEN
self.p.onLoadConfig()
# THEN
self.assertIsNotNone(self.p.private_key_file)
self.assertEqual(existing_file_path, b3.getAbsolutePath(self.p.private_key_file))
def init(self, config_content=None):
""" load plugin config and initialise the plugin """
if config_content:
self.conf.loadFromString(config_content)
else:
if os.path.isfile(
b3.getAbsolutePath('@b3/conf/plugin_chatlogger.ini')):
self.conf.load(
b3.getAbsolutePath('@b3/conf/plugin_chatlogger.ini'))
else:
raise unittest.SkipTest(
"default config file '%s' does not exists" %
b3.getAbsolutePath('@b3/conf/plugin_chatlogger.ini'))
self.p.onLoadConfig()
self.p.onStartup()
def onStartup(self):
"""
Initialize plugin settings.
"""
self._adminPlugin = self.console.getPlugin('admin')
# patch the admin module
patch_admin_module(self._adminPlugin)
# create database tables (if needed)
if 'cmdgrants' not in self.console.storage.getTables():
sql_path_main = b3.getAbsolutePath('@b3/plugins/cmdmanager/sql')
sql_path = os.path.join(sql_path_main, self.console.storage.dsnDict['protocol'], 'cmdmanager.sql')
self.console.storage.queryFromFile(sql_path)
# register our commands
if 'commands' in self.config.sections():
for cmd in self.config.options('commands'):
level = self.config.get('commands', cmd)
sp = cmd.split('-')
alias = None
if len(sp) == 2:
cmd, alias = sp
func = getCmd(self, cmd)
if func:
self._adminPlugin.registerCommand(self, cmd, level, func, alias)
# register events needed
self.registerEvent('EVT_CLIENT_AUTH', self.onAuth)
# notice plugin started
self.debug('plugin started')
def onStartup(self):
"""
Initialize plugin settings
"""
self.adminPlugin = self.console.getPlugin('admin')
if not self.adminPlugin:
raise AttributeError('could not find admin plugin')
# create database tables (if needed)
if 'nicks' not in self.console.storage.getTables():
sql_path_main = b3.getAbsolutePath('@b3/plugins/nickreg/sql')
sql_path = os.path.join(sql_path_main,
self.console.storage.dsnDict['protocol'],
'nickreg.sql')
self.console.storage.queryFromFile(sql_path)
# register our commands
self.adminPlugin.registerCommand(self, 'registernick', self.min_level,
self.cmd_regnick, 'regnick')
self.adminPlugin.registerCommand(self, 'deletenick', self.min_level,
self.cmd_delnick, 'delnick')
self.adminPlugin.registerCommand(self, 'listnick', self.min_level,
self.cmd_listnick)
# register our events
self.registerEvent('EVT_CLIENT_NAME_CHANGE',
self.on_client_name_change)
self.registerEvent('EVT_GAME_MAP_CHANGE', self.on_map_change)
# install crontab
self.crontab = b3.cron.PluginCronTab(self, self.execute_crontab,
'*/%s' % self.interval)
self.console.cron + self.crontab
def connect(self):
"""
Establish and return a connection with the storage layer.
Will store the connection object also in the 'db' attribute so in the future we can reuse it.
:return The connection instance if established successfully, otherwise None.
"""
try:
import sqlite3
path = b3.getWritableFilePath(self.dsn[9:])
self.console.bot("Using database file: %s" % path)
is_new_database = not os.path.isfile(path)
self.db = sqlite3.connect(path, check_same_thread=False)
self.db.isolation_level = None # set autocommit mode
except Exception as e:
self.db = None
self.console.error('Database connection failed: %s', e)
if self._consoleNotice:
self.console.screen.write('Connecting to DB : FAILED\n')
self._consoleNotice = False
else:
# import SQL script if necessary
if path == ':memory:' or is_new_database:
self.console.info("Importing SQL file: %s..." %
b3.getAbsolutePath("@b3/sql/sqlite/b3.sql"))
self.queryFromFile("@b3/sql/sqlite/b3.sql")
if self._consoleNotice:
self.console.screen.write('Connecting to DB : OK\n')
self._consoleNotice = False
finally:
return self.db
def setUp(self):
SpamcontrolTestCase.setUp(self)
with open(b3.getAbsolutePath(
'@b3/conf/plugin_spamcontrol.ini')) as default_conf:
self.init_plugin(default_conf.read())
self.joe = FakeClient(self.console,
name="Joe",
exactName="Joe",
guid="zaerezarezar",
groupBits=1)
self.joe.connects("1")
# let's say our game has a new event : EVT_CLIENT_RADIO
EVT_CLIENT_RADIO = self.console.Events.createEvent(
'EVT_CLIENT_RADIO', 'Event client radio')
# teach the Spamcontrol plugin how to react on such events
def onRadio(this, event):
new_event = Event(type=event.type,
client=event.client,
target=event.target,
data=event.data['text'])
this.onChat(new_event)
self.p.onRadio = new.instancemethod(onRadio, self.p, SpamcontrolPlugin)
self.p.registerEvent('EVT_CLIENT_RADIO', self.p.onRadio)
# patch joe to make him able to send radio messages
def radios(me, text):
me.console.queueEvent(
Event(type=EVT_CLIENT_RADIO, client=me, data={'text': text}))
self.joe.radios = new.instancemethod(radios, self.joe, FakeClient)
def onStartup(self):
"""
Initialize plugin settings.
"""
self._adminPlugin = self.console.getPlugin('admin')
# patch the admin module
patch_admin_module(self._adminPlugin)
# create database tables (if needed)
if 'cmdgrants' not in self.console.storage.getTables():
sql_path_main = b3.getAbsolutePath('@b3/plugins/cmdmanager/sql')
sql_path = os.path.join(sql_path_main, self.console.storage.dsnDict['protocol'], 'cmdmanager.sql')
self.console.storage.queryFromFile(sql_path)
# register our commands
if 'commands' in self.config.sections():
for cmd in self.config.options('commands'):
level = self.config.get('commands', cmd)
sp = cmd.split('-')
alias = None
if len(sp) == 2:
cmd, alias = sp
func = getCmd(self, cmd)
if func:
self._adminPlugin.registerCommand(self, cmd, level, func, alias)
# register events needed
self.registerEvent('EVT_CLIENT_AUTH', self.onAuth)
# notice plugin started
self.debug('plugin started')
def queryFromFile(self, fp, silent=False):
"""
This method executes an external sql file on the current database.
:param fp: The filepath of the file containing the SQL statements.
:param silent: Whether or not to silence MySQL warnings.
:raise Exception: If the query cannot be evaluated or if the given path cannot be resolved.
"""
# use existing connection or create a new one
# duplicate code of query() method which is needed not to spam the database
# with useless connection attempts (one for each query in the SQL file)
connection = self.getConnection()
if not connection:
raise Exception(
'lost connection with the storage layer during query')
# save standard error output
orig_stderr = sys.stderr
if silent:
# silence mysql warnings and such
sys.stderr = open(os.devnull, 'w')
path = b3.getAbsolutePath(fp)
if not os.path.exists(path):
raise Exception('SQL file does not exist: %s' % path)
with open(path, 'r') as sqlfile:
statements = self.getQueriesFromFile(sqlfile)
for stmt in statements:
# will stop if a single query generate an exception
self.query(stmt)
# reset standard error output
sys.stderr = orig_stderr
def getpath(self, section, setting):
"""
Return an absolute path name and expand the user prefix (~).
:param section: The configuration file section.
:param setting: The configuration file setting.
"""
return b3.getAbsolutePath(self.get(section, setting), decode=True)
def test_no_generic_or_default_warn_reason(self):
# load the default plugin_admin.ini file after having remove the 'generic' setting from section 'warn_reasons'
new_config_content = ""
with open(b3.getAbsolutePath('@b3/conf/plugin_admin.ini')) as config_file:
is_in_warn_reasons_section = False
for line in config_file:
if line == '[warn_reasons]':
is_in_warn_reasons_section = True
if not is_in_warn_reasons_section:
new_config_content += (line + '\n')
else:
if line.startswith('['):
new_config_content += (line + '\n')
is_in_warn_reasons_section = False
else:
if line.startswith("generic") or line.startswith("default"):
pass
else:
new_config_content += (line + '\n')
self.init(new_config_content)
self.joe.message = Mock(lambda x: sys.stdout.write("message to Joe: " + x + "\n"))
self.joe.connects(0)
self.joe.says('!warntest')
self.joe.message.assert_called_once_with('^2TEST: ^1WARNING^7 [^31^7]: ^7behave yourself')
self.joe.message.reset_mock()
self.joe.says('!warntest argue')
self.joe.message.assert_called_once_with('^2TEST: ^1WARNING^7 [^31^7]: ^3Rule #3: No arguing with admins (listen and learn or leave)')
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(
dedent(r"""
[commands]
plugin: superadmin
"""))
self.p = PluginmanagerPlugin(self.console, self.conf)
when(self.console).getPlugin("pluginmanager").thenReturn(
self.adminPlugin)
self.p.onLoadConfig()
self.p.onStartup()
when(self.console.config).get_external_plugins_dir().thenReturn(
b3.getAbsolutePath('@b3\\extplugins'))
# store them also in the console _plugins dict
self.console._plugins['admin'] = self.adminPlugin
self.console._plugins['pluginmanager'] = self.p
def test_default_conf(self):
with open(b3.getAbsolutePath(
'@b3/conf/plugin_spamcontrol.ini')) as default_conf:
self.init_plugin(default_conf.read())
self.assertEqual(self.default_max_spamins, self.p._maxSpamins)
self.assertEqual(self.default_mod_level, self.p._modLevel)
self.assertEqual(self.default_falloff_rate, self.p._falloffRate)
def onStartup(self):
"""
Initialize plugin settings
"""
self.adminPlugin = self.console.getPlugin('admin')
if not self.adminPlugin:
raise AttributeError('could not find admin plugin')
# create database tables (if needed)
if 'nicks' not in self.console.storage.getTables():
sql_path_main = b3.getAbsolutePath('@b3/plugins/nickreg/sql')
sql_path = os.path.join(sql_path_main, self.console.storage.dsnDict['protocol'], 'nickreg.sql')
self.console.storage.queryFromFile(sql_path)
# register our commands
self.adminPlugin.registerCommand(self, 'registernick', self.min_level, self.cmd_regnick, 'regnick')
self.adminPlugin.registerCommand(self, 'deletenick', self.min_level, self.cmd_delnick, 'delnick')
self.adminPlugin.registerCommand(self, 'listnick', self.min_level, self.cmd_listnick)
# register our events
self.registerEvent('EVT_CLIENT_NAME_CHANGE', self.on_client_name_change)
self.registerEvent('EVT_GAME_MAP_CHANGE', self.on_map_change)
# install crontab
self.crontab = b3.cron.PluginCronTab(self, self.execute_crontab, '*/%s' % self.interval)
self.console.cron + self.crontab
def onStartup(self):
"""
Initialize plugin settings.
"""
self.adminPlugin = self.console.getPlugin('admin')
# create database tables (if needed)
if 'callvote' not in self.console.storage.getTables():
sql_path_main = b3.getAbsolutePath('@b3/plugins/callvote/sql')
sql_path = os.path.join(sql_path_main, self.console.storage.dsnDict['protocol'], 'callvote.sql')
self.console.storage.queryFromFile(sql_path)
# unregister the veto command of the admin plugin
if self.console.getPlugin('poweradminurt'):
self.adminPlugin.unregisterCommand('paveto')
# register our commands
if 'commands' in self.config.sections():
for cmd in self.config.options('commands'):
level = self.config.get('commands', cmd)
sp = cmd.split('-')
alias = None
if len(sp) == 2:
cmd, alias = sp
func = getCmd(self, cmd)
if func:
self.adminPlugin.registerCommand(self, cmd, level, func, alias)
self.registerEvent('EVT_CLIENT_CALLVOTE', self.onCallvote)
self.registerEvent('EVT_VOTE_PASSED', self.onCallvoteFinish)
self.registerEvent('EVT_VOTE_FAILED', self.onCallvoteFinish)
# notice plugin started
self.debug('plugin started')
def setUp(self):
super(Test_Tk_default_config, self).setUp()
self.console.gameName = 'f00'
self.conf = CfgConfigParser()
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_tk.ini'))
self.p = TkPlugin(self.console, self.conf)
self.p.onLoadConfig()
def getpath(self, section, setting):
"""
Return an absolute path name and expand the user prefix (~).
:param section: The configuration file section.
:param setting: The configuration file setting.
"""
return b3.getAbsolutePath(self.get(section, setting), decode=True)
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(dedent(r"""
[commands]
plugin: superadmin
"""))
self.p = PluginmanagerPlugin(self.console, self.conf)
when(self.console).getPlugin("pluginmanager").thenReturn(self.adminPlugin)
self.p.onLoadConfig()
self.p.onStartup()
when(self.console.config).get_external_plugins_dir().thenReturn(b3.getAbsolutePath('@b3\\extplugins'))
# store them also in the console _plugins dict
self.console._plugins['admin'] = self.adminPlugin
self.console._plugins['pluginmanager'] = self.p
def setUp(self):
super(Test_Tk_default_config, self).setUp()
self.console.gameName = 'f00'
self.conf = CfgConfigParser()
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_tk.ini'))
self.p = TkPlugin(self.console, self.conf)
self.p.onLoadConfig()
def queryFromFile(self, fp, silent=False):
"""
This method executes an external sql file on the current database.
:param fp: The filepath of the file containing the SQL statements.
:param silent: Whether or not to silence MySQL warnings.
:raise Exception: If the query cannot be evaluated or if the given path cannot be resolved.
"""
# use existing connection or create a new one
# duplicate code of query() method which is needed not to spam the database
# with useless connection attempts (one for each query in the SQL file)
connection = self.getConnection()
if not connection:
raise Exception('lost connection with the storage layer during query')
# save standard error output
orig_stderr = sys.stderr
if silent:
# silence mysql warnings and such
sys.stderr = open(os.devnull, 'w')
path = b3.getAbsolutePath(fp)
if not os.path.exists(path):
raise Exception('SQL file does not exist: %s' % path)
with open(path, 'r') as sqlfile:
statements = self.getQueriesFromFile(sqlfile)
for stmt in statements:
# will stop if a single query generate an exception
self.query(stmt)
# reset standard error output
sys.stderr = orig_stderr
def connect(self):
"""
Establish and return a connection with the storage layer.
Will store the connection object also in the 'db' attribute so in the future we can reuse it.
:return The connection instance if established successfully, otherwise None.
"""
# no need to catch ImportError since we already did that in __new__()
# do not retry too soon because the MySQL server could
# have connection troubles and we do not want to spam it
if time() - self._lastConnectAttempt < self._reconnectDelay:
self.db = None
self.console.bot('New PostgreSQL database connection requested but last connection attempt '
'failed less than %s seconds ago: exiting...' % self._reconnectDelay)
else:
# close the active connection (if any)
self.shutdown()
self.console.bot('Connecting to PostgreSQL database: %(protocol)s://%(user)s:******@%(host)s:%(port)s%(path)s...', self.dsnDict)
try:
import psycopg2
self.db = psycopg2.connect(host=self.dsnDict['host'],
port=self.dsnDict['port'],
user=self.dsnDict['user'],
password=self.dsnDict['password'],
database=self.dsnDict['path'][1:])
self.db.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
self.db.set_client_encoding("UTF8")
self.console.bot('Successfully established a connection with PostgreSQL database')
self._lastConnectAttempt = 0
if self._consoleNotice:
self.console.screen.write('Connecting to DB : OK\n')
self._consoleNotice = False
# check whether the database is ready for usage or if we have to import B3 sql files to generate necessary
# tables: if database is empty, then then AdminPlugin will raise an exception upon loading hence B3 won't be
# operational. I placed the check here since it doesn't make sense to keep loading plugins if B3 will crash.
if not self.getTables():
try:
self.console.info("Missing PostgreSQL database tables: importing SQL file: %s..." % b3.getAbsolutePath("@b3/sql/postgresql/b3.sql"))
self.queryFromFile("@b3/sql/postgresql/b3.sql")
except Exception, e:
self.shutdown()
self.console.critical("Missing PostgreSQL database tables. You need to create the necessary tables for "
"B3 to work. You can do so by importing the following SQL script into your "
"database: %s. An attempt of creating tables automatically just failed: %s" %
(b3.getAbsolutePath("@b3/sql/postgresql/b3.sql"), e))
except Exception, e:
self.console.error('Database connection failed: working in remote mode: %s - %s', e, extract_tb(sys.exc_info()[2]))
self.db = None
self._lastConnectAttempt = time()
if self._consoleNotice:
self.console.screen.write('Connecting to DB : FAILED!\n')
self._consoleNotice = False
def run(config=None):
if config:
config = b3.getAbsolutePath(config)
else:
# search for the config file
config = None
for p in ('b3.xml', 'conf/b3.xml', 'b3/conf/b3.xml', '~/b3.xml', '~/conf/b3.xml', '~/b3/conf/b3.xml', '@b3/conf/b3.xml'):
path = b3.getAbsolutePath(p)
print 'Searching for config file: %s' % path
if os.path.isfile(path):
config = path
break
if not config:
raise SystemExit('Could not find config file.')
b3.start(config)
def _search_config_file(match):
"""
Helper that returns a list of available configuration file paths for the given plugin.
:param match: The plugin name
"""
# first look in the built-in plugins directory
search = '%s%s*%s*' % (b3.getAbsolutePath('@b3\\conf'), os.path.sep, match)
self.debug('searching for configuration file(s) matching: %s' % search)
collection = glob.glob(search)
if len(collection) > 0:
return collection
# if none is found, then search in the extplugins directory
extplugins_dir = self.console.config.get_external_plugins_dir()
search = '%s%s*%s*' % (os.path.join(b3.getAbsolutePath(extplugins_dir), match, 'conf'), os.path.sep, match)
self.debug('searching for configuration file(s) matching: %s' % search)
collection = glob.glob(search)
return collection
def run(config=None):
if config:
config = b3.getAbsolutePath(config)
else:
# search for the config file
config = None
for p in ('b3.xml', 'conf/b3.xml', 'b3/conf/b3.xml', '~/b3.xml', '~/conf/b3.xml', '~/b3/conf/b3.xml', '@b3/conf/b3.xml'):
path = b3.getAbsolutePath(p)
print 'Searching for config file: %s' % path
if os.path.isfile(path):
config = path
break
if not config:
#Setup(config)
raise SystemExit('ERROR: Could not find config file, Please run B3 with option: --setup or -s')
b3.start(config)
def test_default_conf(self):
with open(b3.getAbsolutePath('@b3/conf/plugin_censor.xml')) as default_conf:
self.init_plugin(default_conf.read())
self.assertEqual(40, self.p._maxLevel)
self.assertEqual(3, self.p._ignoreLength)
self.assertEqual(68, len(self.p._badWords))
self.assertEqual(17, len(self.p._badNames))
self.assert_default_badwords_penalty()
self.assert_default_badnames_penalty()
def connect(self):
"""
Establish and return a connection with the storage layer.
Will store the connection object also in the 'db' attribute so in the future we can reuse it.
:return The connection instance if established successfully, otherwise None.
"""
# do not retry too soon because the MySQL server could
# have connection troubles and we do not want to spam it
if time() - self._lastConnectAttempt < self._reconnectDelay:
self.db = None
self.console.bot('New MySQL database connection requested but last connection attempt '
'failed less than %s seconds ago: exiting...' % self._reconnectDelay)
else:
# close the active connection (if any)
self.shutdown()
self.console.bot('Connecting to MySQL database: %(protocol)s://%(user)s:******@%(host)s:%(port)s%(path)s...', self.dsnDict)
try:
# create the connection instance using the specified connector
self.db = self.__driver.connect(host=self.dsnDict['host'],
port=self.dsnDict['port'],
user=self.dsnDict['user'],
passwd=self.dsnDict['password'],
db=self.dsnDict['path'][1:],
charset="utf8")
self.console.bot('Successfully established a connection with MySQL database')
self._lastConnectAttempt = 0
if self._consoleNotice:
self.console.screen.write('Connecting to DB : OK\n')
self._consoleNotice = False
# check whether the database is ready for usage or if we have to import B3 sql files to generate necessary
# tables: if database is empty, then then AdminPlugin will raise an exception upon loading hence B3 won't be
# operational. I placed the check here since it doesn't make sense to keep loading plugins if B3 will crash.
if not self.getTables():
try:
self.console.info("Missing MySQL database tables: importing SQL file: %s..." % b3.getAbsolutePath("@b3/sql/mysql/b3.sql"))
self.queryFromFile("@b3/sql/mysql/b3.sql")
except Exception as e:
self.shutdown()
self.console.critical("Missing MySQL database tables. You need to create the necessary tables for "
"B3 to work. You can do so by importing the following SQL script into your "
"database: %s. An attempt of creating tables automatically just failed: %s" %
(b3.getAbsolutePath("@b3/sql/mysql/b3.sql"), e))
except Exception as e:
self.console.error('Database connection failed: working in remote mode: %s - %s', e, extract_tb(sys.exc_info()[2]))
self.db = None
self._lastConnectAttempt = time()
if self._consoleNotice:
self.console.screen.write('Connecting to DB : FAILED!\n')
self._consoleNotice = False
return self.db
def test_default_conf(self):
with open(b3.getAbsolutePath(
'@b3/conf/plugin_censor.xml')) as default_conf:
self.init_plugin(default_conf.read())
self.assertEqual(40, self.p._maxLevel)
self.assertEqual(3, self.p._ignoreLength)
self.assertEqual(68, len(self.p._badWords))
self.assertEqual(17, len(self.p._badNames))
self.assert_default_badwords_penalty()
self.assert_default_badnames_penalty()
def init(self, config_content=None):
"""
Optionally specify a config for the plugin. If called with no parameter, then the default config is loaded.
"""
if config_content is None:
self.conf.load(b3.getAbsolutePath("@b3/conf/plugin_admin.ini"))
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
def load_config(self, config_content=None):
"""
load the given config content, or the default config if config_content is None.
"""
if config_content is None:
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_welcome.ini'))
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
def init(self, config_content=None):
"""
Optionally specify a config for the plugin. If called with no parameter, then the default config is loaded.
"""
if config_content is None:
self.conf.load(b3.getAbsolutePath("@b3/conf/plugin_admin.ini"))
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
def executeSql(self, filename):
"""This method executes an external sql file"""
sqlFile = b3.getAbsolutePath(filename)
f = open(sqlFile, 'r')
sql_text = f.read()
f.close()
sql_statements = sql_text.split(';')
for s in sql_statements:
if len(s.strip()):
self.query(s)
def executeSql(self, filename):
"""This method executes an external sql file"""
sqlFile = b3.getAbsolutePath(filename)
f = open(sqlFile, "r")
sql_text = f.read()
f.close()
sql_statements = sql_text.split(";")
for s in sql_statements:
if len(s.strip()):
self.query(s)
def load_config(self, config_content=None):
"""
load the given config content, or the default config if config_content is None.
"""
if config_content is None:
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_welcome.ini'))
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
def run(config=None, nosetup=False):
if config:
config = b3.getAbsolutePath(config)
else:
# search for the config file
config = None
for p in ('b3.xml', 'conf/b3.xml', 'b3/conf/b3.xml', '~/b3.xml', '~/conf/b3.xml', '~/b3/conf/b3.xml', '@b3/conf/b3.xml'):
path = b3.getAbsolutePath(p)
print 'Searching for config file: %s' % path
if os.path.isfile(path):
config = path
break
if not config:
# This happens when no config was specified on the commandline and the default configs are missing!
if nosetup:
raise SystemExit('ERROR: Could not find config file, Please run B3 with option: --setup or -s')
else:
Setup(config)
b3.start(config, nosetup)
def init(self, config_content=None):
""" optionally specify a config for the plugin. If called with no parameter, then the default config is loaded """
if config_content is None:
self.conf.load(b3.getAbsolutePath("@b3/conf/plugin_admin.ini"))
else:
self.conf.loadFromString(config_content)
self.p._commands = {}
self.p.onLoadConfig()
self.p.onStartup()
self.joe = FakeClient(self.console, name="Joe", exactName="Joe", guid="joeguid", groupBits=128, team=TEAM_RED)
self.mike = FakeClient(self.console, name="Mike", exactName="Mike", guid="mikeguid", groupBits=1, team=TEAM_BLUE)
def init_plugin(self, config_content=None):
self.conf = CfgConfigParser()
if config_content:
self.conf.loadFromString(config_content)
else:
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_login.ini'))
self.p = LoginPlugin(self.console, self.conf)
self.log.setLevel(logging.DEBUG)
self.log.info("============================= Login plugin: loading config ============================")
self.p.onLoadConfig()
self.log.info("============================= Login plugin: starting =================================")
self.p.onStartup()
def setUp(self):
super(Test_Censor_badname_default_config, self).setUp()
def my_info(text):
print("INFO\t%s" % text)
#self.p.info = my_info
def my_warning(text):
print("WARNING\t%s" % text)
#self.p.warning = my_warning
self.p.config.load(b3.getAbsolutePath('@b3/conf/plugin_censor.xml'))
self.p.onLoadConfig()
self.assertEqual(17, len(self.p._badNames))
def test_value_retrieval_valid(self):
self.assertEqual(self.p.getSetting('section_foo', 'option_str', b3.STRING), 'string value with spaces')
self.assertEqual(self.p.getSetting('section_foo', 'option_int', b3.STRING), '7')
self.assertEqual(self.p.getSetting('section_foo', 'option_int', b3.INTEGER), 7)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool1', b3.BOOLEAN), False)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool2', b3.BOOLEAN), True)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool3', b3.BOOLEAN), False)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool4', b3.BOOLEAN), True)
self.assertEqual(self.p.getSetting('section_foo', 'option_float', b3.STRING), '0.97')
self.assertEqual(self.p.getSetting('section_foo', 'option_float', b3.FLOAT), 0.97)
self.assertEqual(self.p.getSetting('section_foo', 'option_level1', b3.LEVEL), 80)
self.assertEqual(self.p.getSetting('section_foo', 'option_level2', b3.LEVEL), 0)
self.assertEqual(self.p.getSetting('section_foo', 'option_duration1', b3.DURATION), 300)
self.assertEqual(self.p.getSetting('section_foo', 'option_duration2', b3.DURATION), 180)
self.assertEqual(self.p.getSetting('section_foo', 'option_path', b3.PATH), b3.getAbsolutePath('@b3/conf/b3.distribution.ini', decode=True))
def get_host_keys_file(self):
"""
Get the path of the host keys file.
The host key file can either be defined in the plugin config file or well known locations:
~/.ssh/known_hosts
~/ssh/known_hosts
"""
host_keys_file = self.known_hosts_file
for potential_location in ['~/.ssh/known_hosts', '~/ssh/known_hosts']:
if host_keys_file is not None:
break
path = b3.getAbsolutePath(potential_location)
if os.path.isfile(path):
host_keys_file = path
return host_keys_file
def load(filename):
"""
Load a configuration file.
Will instantiate the correct configuration object parser.
"""
if os.path.splitext(filename)[1].lower() == '.xml':
config = XmlConfigParser()
else:
# allow the use of empty keys to support the new b3.ini configuration file
config = CfgConfigParser(allow_no_value=True)
filename = b3.getAbsolutePath(filename, True)
# return the config if it can be loaded
return config if config.load(filename) else None
def get_host_keys_file(self):
"""
Get the path of the host keys file.
The host key file can either be defined in the plugin config file or well known locations:
~/.ssh/known_hosts
~/ssh/known_hosts
"""
host_keys_file = self.known_hosts_file
for potential_location in ['~/.ssh/known_hosts', '~/ssh/known_hosts']:
if host_keys_file is not None:
break
path = b3.getAbsolutePath(potential_location)
if os.path.isfile(path):
host_keys_file = path
return host_keys_file
def load(filename):
"""
Load a configuration file.
Will instantiate the correct configuration object parser.
"""
if os.path.splitext(filename)[1].lower() == '.xml':
config = XmlConfigParser()
else:
# allow the use of empty keys to support the new b3.ini configuration file
config = CfgConfigParser(allow_no_value=True)
filename = b3.getAbsolutePath(filename, True)
# return the config if it can be loaded
return config if config.load(filename) else None
def run(config=None, nosetup=False):
if config:
config = b3.getAbsolutePath(config)
else:
# search for the config file
config = None
for p in ('b3.xml', 'conf/b3.xml', 'b3/conf/b3.xml', '~/b3.xml',
'~/conf/b3.xml', '~/b3/conf/b3.xml', '@b3/conf/b3.xml'):
path = b3.getAbsolutePath(p)
print 'Searching for config file: %s' % path
if os.path.isfile(path):
config = path
break
if not config:
# This happens when no config was specified on the commandline and the default configs are missing!
if nosetup:
raise SystemExit(
'ERROR: Could not find config file, Please run B3 with option: --setup or -s'
)
else:
Setup(config)
b3.start(config, nosetup)
def test_value_retrieval_valid(self):
self.assertEqual(self.p.getSetting('section_foo', 'option_str', b3.STRING), 'string value with spaces')
self.assertEqual(self.p.getSetting('section_foo', 'option_int', b3.STRING), '7')
self.assertEqual(self.p.getSetting('section_foo', 'option_int', b3.INTEGER), 7)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool1', b3.BOOLEAN), False)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool2', b3.BOOLEAN), True)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool3', b3.BOOLEAN), False)
self.assertEqual(self.p.getSetting('section_foo', 'option_bool4', b3.BOOLEAN), True)
self.assertEqual(self.p.getSetting('section_foo', 'option_float', b3.STRING), '0.97')
self.assertEqual(self.p.getSetting('section_foo', 'option_float', b3.FLOAT), 0.97)
self.assertEqual(self.p.getSetting('section_foo', 'option_level1', b3.LEVEL), 80)
self.assertEqual(self.p.getSetting('section_foo', 'option_level2', b3.LEVEL), 0)
self.assertEqual(self.p.getSetting('section_foo', 'option_duration1', b3.DURATION), 300)
self.assertEqual(self.p.getSetting('section_foo', 'option_duration2', b3.DURATION), 180)
self.assertEqual(self.p.getSetting('section_foo', 'option_path', b3.PATH), b3.getAbsolutePath('@b3/conf/b3.distribution.ini', decode=True))
def setUp(self):
super(Test_Censor_badname_default_config, self).setUp()
def my_info(text):
print("INFO\t%s" % text)
#self.p.info = my_info
def my_warning(text):
print("WARNING\t%s" % text)
#self.p.warning = my_warning
self.p.config.load(b3.getAbsolutePath('@b3/conf/plugin_censor.xml'))
self.p.onLoadConfig()
self.assertEqual(17, len(self.p._badNames))
def setUp(self):
self.log = logging.getLogger('output')
self.log.propagate = False
B3TestCase.setUp(self)
admin_conf = CfgConfigParser()
admin_conf.load(b3.getAbsolutePath('@b3/conf/plugin_admin.ini'))
self.adminPlugin = AdminPlugin(self.console, admin_conf)
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.console.gameName = "theGame"
self.console.startup()
self.log.propagate = True
def setUp(self):
SpamcontrolTestCase.setUp(self)
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
with open(b3.getAbsolutePath('@b3/conf/plugin_spamcontrol.ini')) as default_conf:
self.init_plugin(default_conf.read())
self.joe = FakeClient(self.console, name="Joe", guid="zaerezarezar", groupBits=1)
self.joe.connects("1")
self.superadmin = FakeClient(self.console, name="Superadmin", guid="superadmin_guid", groupBits=128)
self.superadmin.connects("2")
def _update_database(storage, update_version):
"""
Update a B3 database.
:param storage: the initialized storage module
:param update_version: the update version
"""
if B3version(b3.__version__) >= update_version:
sql = b3.getAbsolutePath('@b3/sql/%s/b3-update-%s.sql' % (storage.protocol, update_version))
if os.path.isfile(sql):
try:
print '>>> updating database to version %s' % update_version
sleep(.5)
storage.queryFromFile(sql)
except Exception, err:
print 'WARNING: could not update database properly: %s' % err
sleep(3)
def build_database_schema(self):
"""
Build the database tables needed if not present
"""
sql_main = os.path.join(b3.getAbsolutePath('@b3/extplugins/reportcod4/sql'), 'mysql')
current_tables = self.get_tables()
# current_tables = self.console.storage.getTables()
for f in os.listdir(sql_main):
if f[:len(f) - len('.sql')] in current_tables:
self.debug('Table %s found' % f)
else:
# Attempt to create the SQL table if it doesn't exist
self.debug('Table %s NOT found, attempting to create' % f[:len(f) - len('.sql')])
table = open('%s\\%s' % (sql_main, f), 'r').read()
self._query(table)
self.debug('Table %s created' % f[:len(f) - len('.sql')])
def init_plugin(self, config_content=None):
self.conf = CfgConfigParser()
if config_content:
self.conf.loadFromString(config_content)
else:
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_login.ini'))
self.p = LoginPlugin(self.console, self.conf)
self.log.setLevel(logging.DEBUG)
self.log.info(
"============================= Login plugin: loading config ============================"
)
self.p.onLoadConfig()
self.log.info(
"============================= Login plugin: starting ================================="
)
self.p.onStartup()
def queryFromFile(self, file, silent=False):
"""This method executes an external sql file on the current database"""
if self.db or self.connect():
orig_stderr = sys.stderr # save standard error output
if silent:
sys.stderr = open(os.devnull, 'w') # silence the mysql warnings for existing tables and such
sqlFile = b3.getAbsolutePath(file)
if os.path.exists(sqlFile):
f = open(sqlFile, 'r')
sql_text = f.read()
f.close()
sql_statements = sql_text.split(';')
for s in sql_statements:
try:
self.query(s)
except:
pass
else:
raise Exception('sqlFile does not exist: %s' %sqlFile)
sys.stderr = orig_stderr # reset standard error output
return None