def kajonggServer():
"""start the server"""
from optparse import OptionParser
parser = OptionParser()
defaultPort = InternalParameters.defaultPort()
parser.add_option('', '--port', dest='port',
help=m18n('the server will listen on PORT (%d)' % defaultPort),
type=int, default=defaultPort)
parser.add_option('', '--socket', dest='socket',
help=m18n('the server will listen on SOCKET'), default=None)
parser.add_option('', '--db', dest='dbpath', help=m18n('name of the database'), default=None)
parser.add_option('', '--local', dest='local', action='store_true',
help=m18n('start a local game server'), default=False)
parser.add_option('', '--continue', dest='continueServer', action='store_true',
help=m18n('do not terminate local game server after last client disconnects'), default=False)
parser.add_option('', '--debug', dest='debug',
help=Debug.help())
(options, args) = parser.parse_args()
if args and ''.join(args):
logWarning(m18n('unrecognized arguments:%1', ' '.join(args)))
sys.exit(2)
InternalParameters.continueServer |= options.continueServer
if options.dbpath:
InternalParameters.dbPath = os.path.expanduser(options.dbpath)
if options.local:
InternalParameters.socket = socketName()
if options.socket:
InternalParameters.socket = options.socket
Debug.setOptions(options.debug)
Query.dbhandle = initDb()
realm = MJRealm()
realm.server = MJServer()
kajonggPortal = portal.Portal(realm, [DBPasswordChecker()])
# pylint: disable=E1101
# pylint thinks reactor is missing listen* and run
loadPredefinedRulesets()
try:
if InternalParameters.socket:
if os.name == 'nt':
logInfo('local server listening on 127.0.0.1 port %d' % options.port)
reactor.listenTCP(options.port, pb.PBServerFactory(kajonggPortal),
interface='127.0.0.1')
else:
logInfo('local server listening on UNIX socket %s' % InternalParameters.socket)
reactor.listenUNIX(InternalParameters.socket, pb.PBServerFactory(kajonggPortal))
else:
logInfo('server listening on port %d' % options.port)
reactor.listenTCP(options.port, pb.PBServerFactory(kajonggPortal))
except error.CannotListenError, errObj:
logWarning(errObj)
def parseOptions():
"""parse command line options and save the values"""
args = KCmdLineArgs.parsedArgs()
Internal.app = APP
Options.playOpen |= args.isSet('playopen')
Options.showRulesets|= args.isSet('rulesets')
Options.rulesetName = str(args.getOption('ruleset'))
if args.isSet('host'):
Options.host = str(args.getOption('host'))
if args.isSet('player'):
Options.player = str(args.getOption('player'))
if args.isSet('ai'):
Options.AI = str(args.getOption('ai'))
if args.isSet('csv'):
Options.csv = str(args.getOption('csv'))
if args.isSet('socket'):
Options.socket = str(args.getOption('socket'))
SingleshotOptions.game = str(args.getOption('game'))
Options.gui |= args.isSet('gui')
if args.isSet('table'):
SingleshotOptions.table = int(args.getOption('table'))
if args.isSet('join'):
SingleshotOptions.join = int(args.getOption('join'))
Options.demo |= args.isSet('demo')
Options.demo |= not Options.gui
Internal.autoPlay = Options.demo
msg = Debug.setOptions(str(args.getOption('debug')))
if msg:
print msg
sys.exit(2)
from query import initDb
if not initDb():
raise SystemExit('Cannot initialize database')
initRulesets()
Options.fixed = True # may not be changed anymore
def defineOptions():
"""this is the KDE way. Compare with kajonggserver.py"""
options = KCmdLineOptions()
options.add("playopen",
i18n("all robots play with visible concealed tiles"))
options.add("demo", i18n("start with demo mode"))
options.add("host <HOST>", i18n("login to HOST"))
options.add("table <TABLE>", i18n("start new TABLE"))
options.add("join <TABLE>", i18n("join TABLE "))
options.add("ruleset <RULESET>", i18n("use ruleset without asking"))
options.add("rounds <ROUNDS>",
i18n("play one ROUNDS rounds per game. Only for debugging!"))
options.add("player <PLAYER>", i18n("prefer PLAYER for next login"))
options.add("ai <AI>",
i18n("use AI variant for human player in demo mode"))
options.add("csv <CSV>", i18n("write statistics to CSV"))
options.add("rulesets", i18n("show all available rulesets"))
options.add("game <seed(/(firsthand)(..(lasthand))>",
i18n("for testing purposes: Initializes the random generator"),
"0")
options.add(
"nogui",
i18n("show no graphical user interface. Intended only for testing"))
options.add(
"socket <SOCKET>",
i18n(
"use a dedicated server listening on SOCKET. Intended only for testing"
))
options.add(
"port <PORT>",
i18n(
"use a dedicated server listening on PORT. Intended only for testing"
))
options.add("debug <OPTIONS>", Debug.help())
return options
def parse_options():
"""parse options"""
parser = OptionParser()
parser.add_option('', '--gui', dest='gui', action='store_true',
default=False, help='show graphical user interface')
parser.add_option('', '--autoplay', dest='ruleset',
default='Testset', help='play like a robot using RULESET',
metavar='RULESET')
parser.add_option('', '--ai', dest='aiVariants',
default=None, help='use AI variants: comma separated list',
metavar='AI')
parser.add_option('', '--csv', dest='csv',
default='kajongg.csv', help='write results to CSV',
metavar='CSV')
parser.add_option('', '--game', dest='game',
help='start first game with GAMEID, increment for following games.'
' Without this, random values are used.',
metavar='GAMEID', type=int, default=0)
parser.add_option('', '--count', dest='count',
help='play COUNT games',
metavar='COUNT', type=int, default=0)
parser.add_option('', '--playopen', dest='playopen', action='store_true',
help='all robots play with visible concealed tiles' , default=False)
parser.add_option('', '--clients', dest='clients',
help='start CLIENTS kajongg instances simultaneously',
metavar='CLIENTS', type=int, default=1)
parser.add_option('', '--servers', dest='servers',
help='start SERVERS kajonggserver instances. Default is one server for two clients',
metavar='SERVERS', type=int, default=0)
parser.add_option('', '--fill', dest='fill', action='store_true',
help='fill holes in results', default=False)
parser.add_option('', '--debug', dest='debug',
help=Debug.help())
return parser.parse_args()
def main():
"""parse options, play, evaluate results"""
global OPTIONS # pylint: disable=global-statement
# we want only english in the logs because i18n and friends
# behave differently in kde and kde
os.environ['LANG'] = 'en_US.UTF-8'
(OPTIONS, args) = parse_options()
OPTIONS.csv = os.path.expanduser(
os.path.join('~', '.kajongg', 'kajongg.csv'))
if not os.path.exists(os.path.dirname(OPTIONS.csv)):
os.makedirs(os.path.dirname(OPTIONS.csv))
removeInvalidCommits(OPTIONS.csv)
improve_options()
evaluate(readGames(OPTIONS.csv))
errorMessage = Debug.setOptions(','.join(OPTIONS.debug))
if errorMessage:
print(errorMessage)
sys.exit(2)
if args and ''.join(args):
print('unrecognized arguments:', ' '.join(args))
sys.exit(2)
print()
if OPTIONS.count:
doJobs()
if OPTIONS.csv:
evaluate(readGames(OPTIONS.csv))
def parseArgs():
"""as the name says"""
from optparse import OptionParser
parser = OptionParser()
defaultPort = Internal.defaultPort
parser.add_option('',
'--port',
dest='port',
help=i18n('the server will listen on PORT (%d)' %
defaultPort),
type=int,
default=defaultPort)
parser.add_option('',
'--socket',
dest='socket',
help=i18n('the server will listen on SOCKET'),
default=None)
parser.add_option('',
'--db',
dest='dbpath',
help=i18n('name of the database'),
default=None)
parser.add_option(
'',
'--continue',
dest='continueServer',
action='store_true',
help=i18n(
'do not terminate local game server after last client disconnects'
),
default=False)
parser.add_option('', '--debug', dest='debug', help=Debug.help())
(options, args) = parser.parse_args()
if args and ''.join(args):
logWarning(i18n('unrecognized arguments:%1', ' '.join(args)))
sys.exit(2)
Options.continueServer |= options.continueServer
if options.dbpath:
Options.dbPath = os.path.expanduser(options.dbpath)
if options.socket:
Options.socket = options.socket
Debug.setOptions(options.debug)
Options.fixed = True # may not be changed anymore
del parser # makes Debug.gc quieter
return options
def parse_options():
"""parse options"""
parser = OptionParser()
parser.add_option(
'', '--gui', dest='gui', action='store_true',
default=False, help='show graphical user interface')
parser.add_option(
'', '--ruleset', dest='rulesets', default='ALL',
help='play like a robot using RULESET: comma separated list. If missing, test all rulesets',
metavar='RULESET')
parser.add_option(
'', '--rounds', dest='rounds',
help='play only # ROUNDS per game',
metavar='ROUNDS')
parser.add_option(
'', '--ai', dest='aiVariants',
default=None, help='use AI variants: comma separated list',
metavar='AI')
parser.add_option(
'', '--log', dest='log', action='store_true',
default=False, help='write detailled debug info to ~/.kajongg/log/game/ruleset/commit.'
' This starts a separate server process per job, it sets --servers to --clients.')
parser.add_option(
'', '--game', dest='game',
help='start first game with GAMEID, increment for following games.' +
' Without this, random values are used.',
metavar='GAMEID', type=int, default=0)
parser.add_option(
'', '--count', dest='count',
help='play COUNT games. Default is unlimited',
metavar='COUNT', type=int, default=999999999)
parser.add_option(
'', '--playopen', dest='playopen', action='store_true',
help='all robots play with visible concealed tiles', default=False)
parser.add_option(
'', '--clients', dest='clients',
help='start a maximum of CLIENTS kajongg instances. Default is 2',
metavar='CLIENTS', type=int, default=1)
parser.add_option(
'', '--servers', dest='servers',
help='start a maximum of SERVERS kajonggserver instances. Default is 1',
metavar='SERVERS', type=int, default=1)
parser.add_option(
'', '--git', dest='git',
help='check all commits: either a comma separated list or a range from..until')
parser.add_option(
'', '--debug', dest='debug',
help=Debug.help())
return parser.parse_args()
def main():
"""parse options, play, evaluate results"""
print
(options, args) = parse_options()
options = improve_options(options)
errorMessage = Debug.setOptions(options.debug)
if errorMessage:
print errorMessage
sys.exit(2)
if args and ''.join(args):
print 'unrecognized arguments:', ' '.join(args)
sys.exit(2)
evaluate(readGames(options.csv))
if not options.count and not options.fill:
sys.exit(0)
if not options.aiVariants:
options.aiVariants = 'Default'
serverProcesses = startServers(options)
try:
if options.fill:
jobs = proposeGames(readGames(options.csv), options.aiVariants)
doJobs(jobs, options, serverProcesses)
if options.count:
if options.game:
games = list(
range(int(options.game), options.game + options.count))
else:
games = list(
int(random.random() * 10**9) for _ in range(options.count))
jobs = []
allAis = options.aiVariants.split(',')
for game in games:
jobs.extend([(x, game) for x in allAis])
doJobs(jobs, options, serverProcesses)
finally:
stopServers(serverProcesses)
evaluate(readGames(options.csv))
def main():
"""parse options, play, evaluate results"""
print
(options, args) = parse_options()
options = improve_options(options)
errorMessage = Debug.setOptions(options.debug)
if errorMessage:
print errorMessage
sys.exit(2)
if args and ''.join(args):
print 'unrecognized arguments:', ' '.join(args)
sys.exit(2)
evaluate(readGames(options.csv))
if not options.count and not options.fill:
sys.exit(0)
if not options.aiVariants:
options.aiVariants = 'Default'
serverProcesses = startServers(options)
try:
if options.fill:
jobs = proposeGames(readGames(options.csv), options.aiVariants)
doJobs(jobs, options, serverProcesses)
if options.count:
if options.game:
games = list(range(int(options.game), options.game+options.count))
else:
games = list(int(random.random() * 10**9) for _ in range(options.count))
jobs = []
allAis = options.aiVariants.split(',')
for game in games:
jobs.extend([(x, game) for x in allAis])
doJobs(jobs, options, serverProcesses)
finally:
stopServers(serverProcesses)
evaluate(readGames(options.csv))
def defineOptions():
"""this is the KDE way. Compare with kajonggserver.py"""
options = KCmdLineOptions()
options.add("playopen", ki18n("all robots play with visible concealed tiles"))
options.add("demo", ki18n("start with demo mode"))
options.add("host <HOST>", ki18n("login to HOST"))
options.add("table <TABLE>", ki18n("start new TABLE"))
options.add("join <TABLE>", ki18n("join TABLE "))
options.add("ruleset <RULESET>", ki18n("use ruleset without asking"))
options.add("player <PLAYER>", ki18n("prefer PLAYER for next login"))
options.add("ai <AI>", ki18n("use AI variant for human player in demo mode"))
options.add("csv <CSV>", ki18n("write statistics to CSV"))
options.add("rulesets", ki18n("show all available rulesets"))
options.add("game <seed/hand/discard>", ki18n("for testing purposes: Initializes the random generator"), "0")
options.add("nogui", ki18n("show no graphical user interface. Intended only for testing"))
options.add("socket <SOCKET>", ki18n("use a dedicated server listening on SOCKET. Intended only for testing"))
options.add("debug <OPTIONS>", ki18n(Debug.help()))
return options
def parseOptions():
"""parse command line options and save the values"""
args = KCmdLineArgs.parsedArgs()
Internal.app = APP
Options.playOpen |= args.isSet("playopen")
Options.showRulesets |= args.isSet("rulesets")
Options.rulesetName = str(args.getOption("ruleset"))
if args.isSet("host"):
Options.host = str(args.getOption("host"))
if args.isSet("player"):
Options.player = unicodeString(args.getOption("player"))
if args.isSet("rounds"):
Options.rounds = int(args.getOption("rounds"))
if args.isSet("ai"):
Options.AI = str(args.getOption("ai"))
if args.isSet("csv"):
Options.csv = str(args.getOption("csv"))
if args.isSet("socket"):
Options.socket = str(args.getOption("socket"))
if args.isSet("port"):
Options.port = str(args.getOption("port"))
SingleshotOptions.game = str(args.getOption("game"))
Options.gui |= args.isSet("gui")
if args.isSet("table"):
SingleshotOptions.table = int(args.getOption("table"))
if args.isSet("join"):
SingleshotOptions.join = int(args.getOption("join"))
Options.demo |= args.isSet("demo")
Options.demo |= not Options.gui
Internal.autoPlay = Options.demo
msg = Debug.setOptions(str(args.getOption("debug")))
if msg:
Internal.logger.debug(msg)
logging.shutdown()
sys.exit(2)
from query import initDb
if not initDb():
raise SystemExit("Cannot initialize database")
initRulesets()
Options.fixed = True # may not be changed anymore
def defineOptions():
"""this is the KDE way. Compare with kajonggserver.py"""
options = KCmdLineOptions()
options.add("playopen", ki18n("all robots play with visible concealed tiles"))
options.add("demo", ki18n("start with demo mode"))
options.add("host <HOST>", ki18n("login to HOST"))
options.add("table <TABLE>", ki18n("start new TABLE"))
options.add("join <TABLE>", ki18n("join TABLE "))
options.add("ruleset <RULESET>", ki18n("use ruleset without asking"))
options.add("rounds <ROUNDS>", ki18n("play one ROUNDS rounds per game. Only for debugging!"))
options.add("player <PLAYER>", ki18n("prefer PLAYER for next login"))
options.add("ai <AI>", ki18n("use AI variant for human player in demo mode"))
options.add("csv <CSV>", ki18n("write statistics to CSV"))
options.add("rulesets", ki18n("show all available rulesets"))
options.add(
"game <seed(/(firsthand)(..(lasthand))>", ki18n("for testing purposes: Initializes the random generator"), "0"
)
options.add("nogui", ki18n("show no graphical user interface. Intended only for testing"))
options.add("nokde", ki18n("Do not use KDE bindings. Intended only for testing"))
options.add("qt5", ki18n("Force using Qt5. Currently Qt4 is used by default on Linux and Qt5 on Windows"))
options.add("socket <SOCKET>", ki18n("use a dedicated server listening on SOCKET. Intended only for testing"))
options.add("port <PORT>", ki18n("use a dedicated server listening on PORT. Intended only for testing"))
options.add("debug <OPTIONS>", ki18n(Debug.help()))
return options
def parse_options():
"""parse options"""
parser = OptionParser()
parser.add_option('',
'--gui',
dest='gui',
action='store_true',
default=False,
help='show graphical user interface')
parser.add_option('',
'--ruleset',
dest='ruleset',
default='Testset',
help='play like a robot using RULESET',
metavar='RULESET')
parser.add_option('',
'--ai',
dest='aiVariants',
default=None,
help='use AI variants: comma separated list',
metavar='AI')
parser.add_option('',
'--csv',
dest='csv',
default='kajongg.csv',
help='write results to CSV',
metavar='CSV')
parser.add_option(
'',
'--game',
dest='game',
help='start first game with GAMEID, increment for following games.'
' Without this, random values are used.',
metavar='GAMEID',
type=int,
default=0)
parser.add_option('',
'--count',
dest='count',
help='play COUNT games. Default is 99999',
metavar='COUNT',
type=int,
default=99999)
parser.add_option('',
'--playopen',
dest='playopen',
action='store_true',
help='all robots play with visible concealed tiles',
default=False)
parser.add_option('',
'--clients',
dest='clients',
help='start CLIENTS kajongg instances simultaneously',
metavar='CLIENTS',
type=int,
default=1)
parser.add_option(
'',
'--servers',
dest='servers',
help=
'start SERVERS kajonggserver instances. Default is one server for two clients',
metavar='SERVERS',
type=int,
default=0)
parser.add_option('',
'--fill',
dest='fill',
action='store_true',
help='fill holes in results',
default=False)
parser.add_option('', '--debug', dest='debug', help=Debug.help())
return parser.parse_args()
def __init__(self, kind):
Debug.__init__(self, verbosity)
self.__byteorder = BYTE_ORDER
self.__data = self.__pack("B", kind)
def __init__(self, data):
Debug.__init__(self, verbosity)
self.__byteorder = BYTE_ORDER
self.args = self.__getArgs(data)
def __init__(self, kind):
Debug.__init__(self, verbosity)
self.__byteorder = BYTE_ORDER
self.__data = self.__pack("B", kind)
def __init__(self, data):
Debug.__init__(self, verbosity)
self.__byteorder = BYTE_ORDER
self.args = self.__getArgs(data)
