def run_game(game, dockers, args, sock_file):
'''
This contains the logic that needs to be cleaned up at the end of a game
If there is something that needs to be cleaned up add it in the try catch
loop surrounding the catch loop surrounding the call of the function
'''
# Start the unix stream server
server.start_server(sock_file, game, dockers)
if args['use_viewer']:
viewer_server = server.start_viewer_server(PORT, game)
# Start the docker instances
for player_key in dockers:
docker_inst = dockers[player_key]
docker_inst.start()
for player_ in game.players:
if player_['id'] == player_key:
player = player_['player']
break
if player.planet == bc.Planet.Earth:
planet = 'earth'
else:
planet = 'mars'
if player.team == bc.Team.Blue:
team = 'blue'
else:
team = 'red'
name = f'[{planet}:{team}]'
logger = Logger(name)
docker_inst.stream_logs(line_action=logger)
player_['logger'] = logger
# Wait until all the code is done then clean up
while not game.game_over:
time.sleep(1)
print(game.disconnected)
print("Dumping matchfile")
match_ptr = open("/player/" + str(args['replay_filename']), mode='w')
match_file = {}
match_file['message'] = game.viewer_messages
if not game.disconnected:
if bc.Team.Red == game.manager.winning_team():
winner = 'player1'
else:
winner = 'player2'
else:
winner = game.winner
match_file['metadata'] = {'player1': args['dir_p1'][8:],
'player2' : args['dir_p2'][8:], 'winner': winner}
json.dump(match_file, match_ptr)
match_ptr.close()
if args['use_viewer']:
viewer_server.shutdown()
return winner
def main(argv):
argv = gflags.FLAGS(argv)
if gflags.FLAGS.port == 0: # default value
port = int(os.environ.get("PORT", 5000))
else:
port = gflags.FLAGS.port
server.start_server(port=port, num_robots_max=gflags.FLAGS.num_robots)
def main(argv):
argv = gflags.FLAGS(argv)
if gflags.FLAGS.port is None:
port = int(os.environ.get("PORT", 5000))
else:
port = gflags.FLAGS.port
server.start_server(port)
def serve(self):
PatchServerHandler.expected_requests = self.expected_requests
PatchServerHandler.builds_path = self.builds_path
for build in os.listdir(self.builds_path):
PatchServerHandler.expected_results.append(build)
PatchServerHandler.expected_results.append("install_%s" % build)
PatchServerHandler.failures_path = self.failures_path
PatchServerHandler.expected_results = os.listdir(self.builds_path)
start_server(PatchServer, PatchServerHandler.check, host=self.address, port=self.port)
def serve(self):
PatchServerHandler.expected_requests = self.expected_requests
PatchServerHandler.builds_path = self.builds_path
for build in os.listdir(self.builds_path):
PatchServerHandler.expected_results.append(build)
PatchServerHandler.expected_results.append("install_%s" % build)
PatchServerHandler.failures_path = self.failures_path
PatchServerHandler.expected_results = os.listdir(self.builds_path)
start_server(PatchServer, PatchServerHandler.check, host=self.address, port=self.port)
def main():
parser = ArgumentParser(description="A simple chat application")
parser.add_argument(
"--server", help="Run server app or client", action="store_true"
)
parser.add_argument("--verboose", action="store_true")
args = parser.parse_args()
if args.server:
start_server(args.verboose)
else:
start_client()
def __init__(self, quit_callback=None):
super(TempoStatusBarApp, self).__init__("", quit_button=None)
self.quit_button = None
self.quit_callback = quit_callback
self.menu = []
self.create_menu()
self.start = time.time()
self.menu_is_open = False
server.start_server()
utils.Timer(2, self.update).start()
log.log("Started Tempo")
def controlarThreejs(cabeza, id, punto, diametro, puntoMedio):
x = punto[0]
y = punto[1]
diametroCara = diametro.value
posicion = Calculador.calcularPosicionCabeza(puntoCentro, (x, y),
diametroCara)
cabeza = Cabeza.Cabeza((x, y), posicion, id)
server.cabeza = cabeza
server.diametro = diametro
server.punto = punto
server.puntoMedio = puntoMedio
server.start_server()
def activate(self, shell):
'''Activate the plugin.
Activate the plugin by setting the shell and starting the server. This
method must be overwritten, as it is indicated by the Rhythmbox
documentation.
'''
print "Activating for shell", shell
self.shell = shell
self.player = shell.get_player()
server.PLUGIN = self
server.start_server()
def main():
"""
The main() function of bord.
Reads/Sets up parameters and calls the
generate/render methods
"""
args = get_cmdline_arguments()
bord_config = configreader.ConfigReader(args.config)
count = create_html(bord_config['content_dir'], bord_config['output_dir'])
print ('Created', count, 'HTML files')
if (args.server):
print ('Serving at:', str(args.server))
server.start_server(bord_config['output_dir'], args.server)
def run_server_command(*args):
"""
Run web server for a given directory root location.
run-server [directory]
This is default command if none given.
"""
root_dir = get_root_dir(*args)
conf_file_name = os.path.join(root_dir, "somememos.conf")
if os.path.exists(conf_file_name):
parse_config_file(conf_file_name)
start_server(root_dir)
async def on_ready(self):
start_server(self)
print('Logged in as')
print(self.user.name)
print(self.user.id)
print('------')
await self.change_presence(activity=discord.Game(
name=
f'type $help for all commands|Currently in {len(self.guilds)} guilds'
))
for guild in self.guilds:
print(guild)
time_trigger_msg = methods.set_interval(database.trigger_time,
config["day_length"],
guild, client)
def setUp(self):
'''
This function sets up up the unix stream server for all the other tests.
It also logs both players in.
'''
num_players = 2
self.game = server.Game(num_players, "")
dockers = {}
try:
os.unlink(SOCK_FILE)
except OSError:
if os.path.exists(SOCK_FILE):
print("File exists at connection point")
raise
self.server = server.start_server(SOCK_FILE, self.game, dockers,
use_docker=False)
self.conn_p1 = create_socket()
login(self.conn_p1, self.game.player_ids[0])
unpacked_data = recv_next_message(self.conn_p1)
self.assertTrue(unpacked_data["logged_in"])
self.assertEqual(unpacked_data["error"], "")
self.conn_p2 = create_socket()
login(self.conn_p2, self.game.player_ids[1])
unpacked_data = recv_next_message(self.conn_p2)
self.assertTrue(unpacked_data["logged_in"])
self.assertEqual(unpacked_data["error"], "")
def run(server_class=HTTPServer, handle_class=ImageHttpServer, port=8070):
socket = server.start_server()
server_address = ('', port)
httpd = server_class(server_address, handle_class)
print("Image Http Server Started")
httpd.serve_forever()
def report():
rep = open("report.csv", "wb")
text = [["\t\t\tCustoms Management Database Management System"],
["\t\t\t Project Amigo"],
["\tReports Generated on:"], ["\t%0.19s" % (datetime.now())], [""],
[
"MANIFEST#", "PRODUCT", "CARRIED BY", "ISSUED BY", "MODE",
"BILL#", "DATE", "COUNTRY", "BILL AMOUNT", "FROM PORT",
"TO PORT", "REMARKS"
]]
writer = csv.writer(rep, delimiter=',')
for each_line in text:
writer.writerow(each_line)
try:
db = MySQLdb.connect("127.0.0.1", "root", "root", "customs")
except:
start_server()
db = MySQLdb.connect("127.0.0.1", "root", "root", "customs")
cursor = db.cursor()
cursor.execute("SELECT manifest_id FROM manifest")
manifest = cursor.fetchall()
db.close()
for man in manifest:
manifest_id = man[0]
result = Search(manifest_id)
[
manifest_id, description, carrier_name, issuer_name,
transport_description, bol_id, date, country, bill_amount,
from_port_name, to_port_name, remarks
] = result
answer = [
manifest_id, description, carrier_name, issuer_name,
transport_description, bol_id, date, country,
"INR %0.2f" % (bill_amount), from_port_name, to_port_name, remarks
]
writer.writerow(answer)
print "Report Generated @ %.19s" % (datetime.now())
rep.close()
#report()
class Manager:
##Screen
width, height = 950, 600
size = width, height
screen = pygame.display.set_mode(size)
pygame.display.set_caption("SpaceInvaders")
#Server
server = start_server()
#InputManager
inputManager = InputManager()
#Introduction state
state = StateGameServer(screen, inputManager)
#Main Loop
def _run(self):
self.gameOn = True
while self.gameOn:
run()
dt = fpsClock.tick(30)
#Inputs
self.inputManager.update()
#Updates
self.update(dt)
#Renders, put in the screen
self.render()
#Update
def update(self, dt):
#state updates
new_state = self.state.update(dt)
if (new_state == 0):
return
def set_state(self, state):
self.state.destroy()
self.state = state
#Render
def render(self):
#state renders
self.state.render()
#updates the display
pygame.display.update()
def recvMessage(self):
try:
client = server.start_server()
# clientMsg = server.client_thread()
print("Connected", client)
# msg = {'msg':clientMsg}
# rply = {'rply':''}
# chatData = readChat.insertMessage(self.userName,msg,rply)
# readChat.updateJson(chatData)
# self.conversation()
except BaseException as ex:
print(ex)
def main():
parser = argparse.ArgumentParser()
for arg in ARGS:
parser.add_argument(arg, **ARGS[arg])
options = parser.parse_args()
os.chdir(options.working)
check_cache()
if options.last:
with open(os.path.join(CACHE_DIR, 'last.txt'), 'w') as lastfile:
for key, value in json.load(lastfile).iteritems():
setattr(options, key, value)
os.chdir(options.working)
else:
with open(os.path.join(CACHE_DIR, 'last.txt'), 'w') as lastfile:
json.dump(vars(options), lastfile)
if not os.path.exists(options.jar):
print "Can't find minecraft_server.jar."
res = raw_input('Download now? [y/N] ')
if res.startswith('y') or res.startswith('Y'):
download_server(options.jar)
else:
print 'fatal: no minecraft_server.jar.'
return 1
options.cachedir = CACHE_DIR
dataname = os.path.join(options.cachedir, 'data.p')
data = datafunc.get_data()
if os.path.exists(dataname):
with open(dataname) as datafile:
data.update(pickle.load(datafile))
datafunc.set_options(options)
disp = ui.get_disp(options)
server.start_server(disp)
disp.wait()
instances.Instance.stop_all()
server.stop_server()
with open(dataname, 'w') as datafile:
pickle.dump(datafunc.get_data(), datafile)
print
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
for arg in ARGS:
parser.add_argument(arg, **ARGS[arg])
options = parser.parse_args()
os.chdir(options.working)
check_cache()
if options.last:
with open(os.path.join(CACHE_DIR, 'last.txt'), 'w') as lastfile:
for key, value in json.load(lastfile).iteritems():
setattr(options, key, value)
os.chdir(options.working)
else:
with open(os.path.join(CACHE_DIR, 'last.txt'), 'w') as lastfile:
json.dump(vars(options), lastfile)
if not os.path.exists(options.jar):
print "Can't find minecraft_server.jar."
res = raw_input('Download now? [y/N] ')
if res.startswith('y') or res.startswith('Y'):
download_server(options.jar)
else:
print 'fatal: no minecraft_server.jar.'
return 1
options.cachedir = CACHE_DIR
dataname = os.path.join(options.cachedir, 'data.p')
data = datafunc.get_data()
if os.path.exists(dataname):
with open(dataname) as datafile:
data.update(pickle.load(datafile))
datafunc.set_options(options)
disp = ui.get_disp(options)
server.start_server(disp)
disp.wait()
instances.Instance.stop_all()
server.stop_server()
with open(dataname, 'w') as datafile:
pickle.dump(datafunc.get_data(), datafile)
print
sys.exit(0)
def test_durability(repeat):
server_log_base = server.log_dir + "dur_server_%d.log" % repeat
client_log_base = server.log_dir + "dur_client_%d.log" % repeat
server.start_server(extra_args=server_args, log=server_log_base+".1")
try:
lsn = 0
client = Client(server.addr, server.port, log=client_log_base+".1")
repeat_deposit(client, repeat, 100)
lsn += repeat + 1
saved = server.save_db()
repeat_deposit(client, repeat, 100)
lsn += repeat
client.log.close()
client = Client(server.addr, server.port, log=client_log_base+".1")
repeat_deposit(client, repeat, 200)
lsn += repeat + 1
client.log.close()
server.stop_server()
server.restore_db(saved)
server.start_server(extra_args=server_args, log=server_log_base+".2", remove_old=False)
client = Client(server.addr, server.port, log=client_log_base+".2", auto_open=False)
client.id = 1
_, _, new = client.deposit(0)
assert new == repeat * 200
client.id = 2
_, _, new = client.deposit(0)
assert new == repeat * 200
lsn += 2
client.log.close()
data.assert_lsn_id(lsn, 2)
finally:
server.stop_server()
def execute_server_backend(self, platform_name, subid, action, row):
'''
后台执行server操作
'''
operation_result = False
name = self.get_select_apikey_name()
if action == 'start':
operation_result = server.start_server(platform_name, name, subid)
elif action == 'stop':
operation_result = server.stop_server(platform_name, name, subid)
elif action == 'restart':
operation_result = server.reboot_server(platform_name, name, subid)
wx.CallAfter(self.callback_execute_server, action, operation_result,
row)
def connect_to_clients(t):
"""Establish the connections to the clients.
Modifies table (t) with Player info in-place
Returns clients (a list of two)
"""
sockets = start_server()
clients = [connect_client(s) for s in sockets]
for i, client in enumerate(clients):
message_to_client('What is your name?', client)
name = answer_from_client(client)
print('{} joined'.format(name))
t.players += [Player(name, PORTS[i])]
return clients
def test_tcp():
''' Testing tcp transport between a client and a server '''
que = queue.Queue()
t_1 = start_server(que, '127.0.0.1', 65410, 10)
t_1.start()
msg = b'EWP 0.2 RPC 0 25\n{"id":1,"method_id":0x00}'
t_2 = start_client('127.0.0.1', 65410, msg)
t_2.start()
t_2.join()
t_1.join()
result = que.get()
if result != msg:
raise AssertionError()
def main():
# print("Configure server parameters :")
# IPAdr = input("IP : ")
# port = int(input("Port : "))
IPAdr = '127.0.0.2'
port = 5000
print("Waiting for planner to connect...")
objectives_coord, static_obj_coord, \
robots_coord, move_list, conf_list \
= server.start_server(IPAdr, port)
simu = Simulator(robots_coord, objectives_coord, static_obj_coord,
move_list, conf_list)
return simu
def setUp(self):
'''
This function setusp up the unix stream server for all the other tests.
'''
num_players = 2
self.game = server.Game(num_players)
dockers = {}
try:
os.unlink(SOCK_FILE)
except OSError:
if os.path.exists(SOCK_FILE):
print("File exists at connection point")
raise
self.server = server.start_server(SOCK_FILE, self.game, dockers,
use_docker=False)
def serve():
"""
Start the server (see server.py) and then check every second to see
if a file changes, if so, rebuild the site.
It's not efficient, it just sees if ANY file that isn't hidden changes.
"""
build_site()
olds=" ".join([" ".join(["%f"%os.stat(dir+"/"+f).st_mtime for f in files if f[0]!='.']) for (dir,subs,files) in os.walk(config['content'])])
pid = server.start_server()
while True:
time.sleep(1)
news=" ".join([" ".join(["%f"%os.stat(dir+"/"+f).st_mtime for f in files if f[0] !='.']) for (dir,subs,files) in os.walk(config['content'])])
if news!=olds:
print "REBUILDING"
build_site()
olds = news
def connect_method(connection_obj):
'''
Establishing a tunnel along to the server,
generating the payload format and then sending it to the client.
'''
socket_obj, buffer_size, logfile = server.start_server()
ip_address = server.connect(socket_obj, buffer_size, logfile)
CRLF, SP = "\r\n", " "
status_code = "204" + SP
message = "HTTP/1.1 204 No Content" + CRLF
server = "Server: " + ip_address + CRLF
connection = "Connection: Keep-Alive" + CRLF
date = sub_methods.current_date() + CRLF
'''
Forming the actual payload/response message by attaching the header values.
'''
payload = status_code + message + server + connection + date
try:
connection_obj.send(payload.encode())
except socket.error as e:
print("Error: {}".format(e))
sys.exit(1)
async def main(config):
common_config = config["common"]
broadcast_config = config["broadcast"]
# Set up debug printing, defaulting to "ALL"
log_lvl = log_levels[common_config.get("debug_level", "ALL")]
log_format = "%(asctime)s %(levelname)s %(message)s"
logging.basicConfig(format=log_format, level=log_lvl, datefmt="%H:%M:%S")
# Create a broadcast server and a data container if broadcast is active.
if broadcast_config["active"]:
container: Optional[DataContainer] = DataContainer()
config["broadcast_container"] = container
else:
container = None
# Choose the listener function based on config.
if common_config["source"] == "network":
listener = network_listener
elif common_config["source"] == "serial":
listener = serial_listener
else:
logging.error("Source is neither 'network' nor 'serial'.")
return
# Start the necessary tasks. Quit on KeyboardInterrupt.
try:
if broadcast_config["active"]:
assert container is not None # for type checking, we know this is true here
await asyncio.gather(uploader(config, listener),
start_server(config, container))
else:
await uploader(config, listener)
except KeyboardInterrupt:
logging.info("Trying to shut down gracefully.")
loop = asyncio.get_event_loop()
loop.stop()
def run_game(game, dockers, args, sock_file):
'''
This contains the logic that needs to be cleaned up at the end of a game
If there is something that needs to be cleaned up add it in the try catch
loop surrounding the catch loop surrounding the call of the function
'''
# Start the unix stream server
main_server = server.start_server(sock_file, game, dockers)
viewer_server = server.start_viewer_server(PORT, game) if args['use_viewer'] else None
# Start the docker instances
for player_key in dockers:
docker_inst = dockers[player_key]
docker_inst.start()
for player_ in game.players:
if player_['id'] == player_key:
player = player_['player']
break
if player.planet == bc.Planet.Earth:
planet = 'earth'
else:
planet = 'mars'
if player.team == bc.Team.Blue:
team = 'blue'
else:
team = 'red'
name = f'[{planet}:{team}]'
logger = Logger(name)
docker_inst.stream_logs(line_action=logger)
player_['logger'] = logger
# Wait until all the code is done then clean up
while not game.game_over:
time.sleep(0.1)
print('Killing game server.')
main_server.shutdown()
try:
main_server.server_close()
except e:
print(e)
match_file = {}
match_file['message'] = game.viewer_messages
if not game.disconnected:
if bc.Team.Red == game.manager.winning_team():
winner = 'player1'
else:
winner = 'player2'
else:
winner = game.winner
match_file['metadata'] = {
'player1': args['dir_p1'][8:],
'player2': args['dir_p2'][8:],
'winner': winner
}
if args['docker']:
match_output = abspath(os.path.join('/player', str(args['replay_filename'])))
else:
match_output = args['replay_filename']
if not os.path.isabs(match_output):
match_output = abspath(os.path.join('..', str(match_output)))
print("Dumping matchfile to", match_output)
match_ptr = open(match_output, 'w')
json.dump(match_file, match_ptr)
match_ptr.close()
if viewer_server is not None:
viewer_server.shutdown()
return winner
import sys, os
from server import start_server
from sqlalchemy import create_engine
from sqlalchemy.orm import relationship, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from app.models.tables import DataBase
from app.settings import DATA_BASE
if __name__ == '__main__':
PORT = "8080"
HOST = "0.0.0.0"
db = DataBase(DATA_BASE)
db.boot_database()
try :
start_server(sys.argv[1])
except :
start_server("%s:%s" % (HOST,PORT))
def main():
chart.update_chart(PATH_GRAPH)
start_server(WEB_PORT, TCP_PORT, on_data)
import server
import amcp
import time
import keyboard
### Small disclaimer, the match has to run, in order for this work.
#Starts the server
try:
print("Initialize FASE 1")
server = server.GSIServer(("127.0.0.1", 3000), "S8RL9Z6Y22TYQK45JB4V8PHRJJMD9DS9")
print("Almost there")
server.start_server()
print("Server started")
except:
print("Oepsie")
# All the Caspar paths.
HTMLTemplate = 'PLAY 1-15 "CASPARJS2/01_INTERVIEW" easenone 1 Linear RIGHT'
TBombPlanted = 'PLAY 1-14 "GUI-ELEMENTS/CSGO-BOMB-GRAPHS/T_BOMB_KABOOM"'
TCleanUpAfterPlant = 'PLAY 1-14 "GUI-ELEMENTS/CSGO-BOMB-GRAPHS/T_CLEAN_UP"'
TClean = 'PLAY 1-14 "GUI-ELEMENTS/CSGO-BOMB-GRAPHS/T_CLEAN"'
CTDefuse = 'PLAY 1-14 "GUI-ELEMENTS/CSGO-BOMB-GRAPHS/CT_DEFUSE"'
CTClean = 'PLAY 1-14 "GUI-ELEMENTS/CSGO-BOMB-GRAPHS/CT_CLEAN"'
# For the UI Elements.
uiSide = "Left"
visible = False
planted = False
config['WIFI_IP'] = ifconfig[0]
config['WIFI_MASK'] = ifconfig[1]
config['WIFI_DNS'] = ifconfig[2]
config['WIFI_GATEWAY'] = ifconfig[3]
config['AUTO_IP_CONFIG'] = "NO"
print('Saving to file...')
with open('config.json', 'w') as f:
json.dump(config, f)
print('saved')
print('Connection successful')
print(station.ifconfig())
print('Writing config.js...')
with open("www/scripts/config.js", 'w') as f:
f.write("const device_ip = \"%s\"" % (config['WIFI_IP']))
mac = ubinascii.hexlify(network.WLAN().config('mac'), ':').decode()
print(mac)
#-----------------------------#
# Web server init
try:
print("Starting web server...")
server.start_server(relay, dht11, DEBUG_MODE)
except:
print("Failed to start server")
print("Attempt to start WebRepl")
webrepl.start()
print("Starting REPL...")
webrepl.start()
#-----------------------------#
def start_backend():
try:
start_server()
except Exception as e:
print("WARNING: Could not start HTTP service: " + str(e))
def testUnknownServerReq(self):
with self.assertRaises(ValueError):
start_server()
def run_processes(stop_event):
child = subprocess.Popen('sketch_150125a\\application.windows64\\sketch_150125a')
server.start_server()
def runserver():
run("mkdir -p static/screenshots")
start_server()
#!/usr/bin/env python
import server
import warnings
import argparse
from lib.log import log
# Get rid of those f*cking warnings of Flask
warnings.filterwarnings("ignore")
parser = argparse.ArgumentParser()
parser.add_argument("-l", "--log", help="Logs the output to a log file.", action="store_true")
args = parser.parse_args()
if args.log:
import sys
import time
sys.stderr = open("./log/%s.txt" %(time.strftime('%d-%m-%y %H:%M:%S')), "w")
sys.stdout = sys.stderr
log("Starting server")
server.start_server()
def server_go(threadName): server.start_server(10000,command,pre_room)
return home(request, response)
def build_routes():
server.add_route('get', '/', home)
server.add_route('get', '/login', login)
server.add_route('post', '/verify', verify)
server.add_route('get', '/profile', profile)
server.add_route('post', '/update_user', update_profile)
server.add_route('get', '/write', write)
server.add_route('post', '/new_blog', new_blog)
server.add_route('get', '/admin', admin)
server.add_route('post', '/new_user', new_user)
def logger(request, response):
print 'Got the', request['method'], 'method from client', request[
'address'], 'for', request['path']
return request
def put_middleware():
server.add_middleware(logger)
if __name__ == "__main__":
port = int(raw_input("PORT>"))
put_middleware()
build_routes()
server.start_server("0.0.0.0", port, 20)
def run_game(game, dockers, args, sock_file, scrimmage=False):
'''
This contains the logic that needs to be cleaned up at the end of a game
If there is something that needs to be cleaned up add it in the try catch
loop surrounding the catch loop surrounding the call of the function
'''
# Start the unix stream server
main_server = server.start_server(sock_file, game, dockers)
viewer_server = server.start_viewer_server(
PORT, game) if args['use_viewer'] else None
try:
# Start the docker instances
for player_key in dockers:
docker_inst = dockers[player_key]
docker_inst.start()
for player_ in game.players:
if player_['id'] == player_key:
player = player_['player']
break
if player.planet == bc.Planet.Earth:
planet = 'earth'
else:
planet = 'mars'
if player.team == bc.Team.Blue:
team = 'blue'
else:
team = 'red'
name = '[{}:{}]'.format(planet, team)
logger = Logger(name,
print=(not args['terminal_viewer']
and not scrimmage))
docker_inst.stream_logs(line_action=logger)
player_['logger'] = logger
# Wait until all the code is done then clean up
while not game.game_over:
time.sleep(0.1)
finally:
main_server.shutdown()
try:
main_server.server_close()
except e:
print(e)
if viewer_server is not None:
viewer_server.shutdown()
match_file = {}
match_file['message'] = game.viewer_messages
if not game.disconnected:
if bc.Team.Red == game.manager.winning_team():
winner = 'player1'
else:
winner = 'player2'
else:
winner = game.winner
match_file['metadata'] = {
'player1': 'player1' if scrimmage else args['dir_p1'][8:],
'player2': 'player2' if scrimmage else args['dir_p2'][8:],
'winner': winner
}
if args['docker']:
match_output = abspath(
os.path.join('/player', str(args['replay_filename'])))
else:
match_output = args['replay_filename']
if not os.path.isabs(match_output):
match_output = abspath(os.path.join('..', str(match_output)))
if not scrimmage:
print("Saving replay to", match_output)
match_ptr = open(match_output, 'w')
json.dump(match_file, match_ptr)
match_ptr.close()
return winner
else:
return winner, match_file
def setup(self):
if G.SINGLEPLAYER:
try:
print 'Starting internal server...'
# TODO: create world menu
G.SAVE_FILENAME = "world"
start_server(internal=True)
sock = socket.socket()
sock.connect(("localhost", 1486))
except socket.error as e:
print "Socket Error:", e
#Otherwise back to the main menu we go
return False
except Exception as e:
print 'Unable to start internal server'
import traceback
traceback.print_exc()
return False
else:
try:
#Make sure the address they want to connect to works
ipport = G.IP_ADDRESS.split(":")
if len(ipport) == 1: ipport.append(1486)
sock = socket.socket()
sock.connect((tuple(ipport)))
except socket.error as e:
print "Socket Error:", e
#Otherwise back to the main menu we go
return False
self.init_gl()
sky_rotation = -20.0 # -20.0
# TERRAIN_CHOICE = self.biome_generator.get_biome_type(sector[0], sector[2])
default_skybox = 'skydome.jpg'
#if TERRAIN_CHOICE == G.NETHER:
# default_skybox = 'skydome_nether.jpg'
#else:
# default_skybox = 'skybox.jpg'
print 'loading ' + default_skybox
self.skydome = Skydome(
'resources/' + default_skybox,
#'resources/skydome.jpg',
0.7,
100.0,
sky_rotation,
)
self.player_ids = {
} # Dict of all players this session, indexes are their ID's [0: first Player on server,]
self.focus_block = Block(width=1.05, height=1.05)
self.earth = vec(0.8, 0.8, 0.8, 1.0)
self.white = vec(1.0, 1.0, 1.0, 1.0)
self.ambient = vec(1.0, 1.0, 1.0, 1.0)
self.polished = GLfloat(100.0)
self.crack_batch = pyglet.graphics.Batch()
#if G.DISABLE_SAVE and world_exists(G.game_dir, G.SAVE_FILENAME):
# open_world(self, G.game_dir, G.SAVE_FILENAME)
self.world = World()
self.packetreceiver = PacketReceiver(self.world, self, sock)
self.world.packetreceiver = self.packetreceiver
G.CLIENT = self.packetreceiver
self.packetreceiver.start()
#Get our position from the server
self.packetreceiver.request_spawnpos()
#Since we don't know it yet, lets disable self.update, or we'll load the wrong chunks and fall
self.update_disabled = self.update
self.update = lambda dt: None
#We'll re-enable it when the server tells us where we should be
self.player = Player(game_mode=G.GAME_MODE)
print('Game mode: ' + self.player.game_mode)
self.item_list = ItemSelector(self, self.player, self.world)
self.inventory_list = InventorySelector(self, self.player, self.world)
self.item_list.on_resize(self.window.width, self.window.height)
self.inventory_list.on_resize(self.window.width, self.window.height)
self.text_input = TextWidget(self.window,
'',
0,
0,
self.window.width,
visible=False,
font_name=G.CHAT_FONT)
self.text_input.push_handlers(on_toggled=self.on_text_input_toggled,
key_released=self.text_input_callback)
self.chat_box = TextWidget(self.window,
'',
0,
self.text_input.y + self.text_input.height +
50,
self.window.width / 2,
height=min(300, self.window.height / 3),
visible=False,
multi_line=True,
readonly=True,
font_name=G.CHAT_FONT,
text_color=(255, 255, 255, 255),
background_color=(0, 0, 0, 100),
enable_escape=True)
self.camera = Camera3D(target=self.player)
if G.HUD_ENABLED:
self.label = pyglet.text.Label('',
font_name='Arial',
font_size=8,
x=10,
y=self.window.height - 10,
anchor_x='left',
anchor_y='top',
color=(255, 255, 255, 255))
#if G.DEBUG_TEXT_ENABLED:
# self.debug_text = TextWidget(self.window, '',
# 0, self.window.height - 300,
# 500, 300,
# visible=True, multi_line=True, readonly=True,
# font_name='Arial', font_size=10,
# text_color=(255, 255, 255, 255),
# background_color=(0, 0, 0, 0))
pyglet.clock.schedule_interval_soft(self.world.process_queue,
1.0 / G.MAX_FPS)
pyglet.clock.schedule_interval_soft(self.world.hide_sectors, 10.0,
self.player)
return True
# random_forecast.py
__author__ = 'fanbin'
import bindata
import math
import random
import event
import talib
import asyncore
from server import start_server
if __name__ == "__main__":
# computation engine initialized
print "Computation engine set up"
# event loop start
print "Waiting for backtesting request"
start_server()
def run_on_server():
server.start_server()
# random_forecast.py
__author__ = 'fanbin'
import bindata
import math
import random
import event
import talib
import asyncore
from server import start_server
if __name__ == "__main__":
# computation engine initialized
print "Computation engine set up"
# event loop start
print "Waiting for backtesting request"
start_server()
def main(cfg):
# Start kraken
print(pyfiglet.figlet_format("kraken"))
logging.info("Starting kraken")
# Parse and read the config
if os.path.isfile(cfg):
with open(cfg, "r") as f:
config = yaml.full_load(f)
global kubeconfig_path, wait_duration
distribution = config["kraken"].get("distribution", "openshift")
kubeconfig_path = config["kraken"].get("kubeconfig_path", "")
chaos_scenarios = config["kraken"].get("chaos_scenarios", [])
publish_running_status = config["kraken"].get("publish_kraken_status",
False)
port = config["kraken"].get("port", "8081")
run_signal = config["kraken"].get("signal_state", "RUN")
litmus_version = config["kraken"].get("litmus_version", "v1.9.1")
litmus_uninstall = config["kraken"].get("litmus_uninstall", False)
wait_duration = config["tunings"].get("wait_duration", 60)
iterations = config["tunings"].get("iterations", 1)
daemon_mode = config["tunings"].get("daemon_mode", False)
deploy_performance_dashboards = config["performance_monitoring"].get(
"deploy_dashboards", False)
dashboard_repo = config["performance_monitoring"].get(
"repo",
"https://github.com/cloud-bulldozer/performance-dashboards.git"
) # noqa
capture_metrics = config["performance_monitoring"].get(
"capture_metrics", False)
kube_burner_url = config["performance_monitoring"].get(
"kube_burner_binary_url",
"https://github.com/cloud-bulldozer/kube-burner/releases/download/v0.9.1/kube-burner-0.9.1-Linux-x86_64.tar.gz", # noqa
)
config_path = config["performance_monitoring"].get(
"config_path", "config/kube_burner.yaml")
metrics_profile = config["performance_monitoring"].get(
"metrics_profile_path", "config/metrics-aggregated.yaml")
prometheus_url = config["performance_monitoring"].get(
"prometheus_url", "")
prometheus_bearer_token = config["performance_monitoring"].get(
"prometheus_bearer_token", "")
run_uuid = config["performance_monitoring"].get("uuid", "")
enable_alerts = config["performance_monitoring"].get(
"enable_alerts", False)
alert_profile = config["performance_monitoring"].get(
"alert_profile", "")
# Initialize clients
if not os.path.isfile(kubeconfig_path):
logging.error(
"Cannot read the kubeconfig file at %s, please check" %
kubeconfig_path)
sys.exit(1)
logging.info("Initializing client to talk to the Kubernetes cluster")
os.environ["KUBECONFIG"] = str(kubeconfig_path)
kubecli.initialize_clients(kubeconfig_path)
# find node kraken might be running on
kubecli.find_kraken_node()
# Set up kraken url to track signal
if not 0 <= int(port) <= 65535:
logging.info("Using port 8081 as %s isn't a valid port number" %
(port))
port = 8081
address = ("0.0.0.0", port)
# If publish_running_status is False this should keep us going in our loop below
if publish_running_status:
server_address = address[0]
port = address[1]
logging.info("Publishing kraken status at http://%s:%s" %
(server_address, port))
server.start_server(address)
publish_kraken_status(run_signal)
# Cluster info
logging.info("Fetching cluster info")
cluster_version = runcommand.invoke("kubectl get clusterversion", 60)
cluster_info = runcommand.invoke(
"kubectl cluster-info | awk 'NR==1' | sed -r "
"'s/\x1B\[([0-9]{1,3}(;[0-9]{1,2})?)?[mGK]//g'", 60) # noqa
logging.info("\n%s%s" % (cluster_version, cluster_info))
# Deploy performance dashboards
if deploy_performance_dashboards:
performance_dashboards.setup(dashboard_repo)
# Generate uuid for the run
if run_uuid:
logging.info("Using the uuid defined by the user for the run: %s" %
run_uuid)
else:
run_uuid = str(uuid.uuid4())
logging.info("Generated a uuid for the run: %s" % run_uuid)
# Initialize the start iteration to 0
iteration = 0
# Set the number of iterations to loop to infinity if daemon mode is
# enabled or else set it to the provided iterations count in the config
if daemon_mode:
logging.info(
"Daemon mode enabled, kraken will cause chaos forever\n")
logging.info("Ignoring the iterations set")
iterations = float("inf")
else:
logging.info(
"Daemon mode not enabled, will run through %s iterations\n" %
str(iterations))
iterations = int(iterations)
failed_post_scenarios = []
litmus_installed = False
# Capture the start time
start_time = int(time.time())
# Loop to run the chaos starts here
while int(iteration) < iterations and run_signal != "STOP":
# Inject chaos scenarios specified in the config
logging.info("Executing scenarios for iteration " + str(iteration))
if chaos_scenarios:
for scenario in chaos_scenarios:
if publish_running_status:
run_signal = server.get_status(address)
if run_signal == "PAUSE":
while publish_running_status and run_signal == "PAUSE":
logging.info(
"Pausing Kraken run, waiting for %s seconds and will re-poll signal"
% str(wait_duration))
time.sleep(wait_duration)
run_signal = server.get_status(address)
if run_signal == "STOP":
logging.info("Received STOP signal; ending Kraken run")
break
scenario_type = list(scenario.keys())[0]
scenarios_list = scenario[scenario_type]
if scenarios_list:
# Inject pod chaos scenarios specified in the config
if scenario_type == "pod_scenarios":
logging.info("Running pod scenarios")
failed_post_scenarios = pod_scenarios.run(
kubeconfig_path, scenarios_list, config,
failed_post_scenarios, wait_duration)
elif scenario_type == "container_scenarios":
logging.info("Running container scenarios")
failed_post_scenarios = pod_scenarios.container_run(
kubeconfig_path, scenarios_list, config,
failed_post_scenarios, wait_duration)
# Inject node chaos scenarios specified in the config
elif scenario_type == "node_scenarios":
logging.info("Running node scenarios")
nodeaction.run(scenarios_list, config,
wait_duration)
# Inject time skew chaos scenarios specified in the config
elif scenario_type == "time_scenarios":
logging.info("Running time skew scenarios")
time_actions.run(scenarios_list, config,
wait_duration)
# Inject litmus based chaos scenarios
elif scenario_type == "litmus_scenarios":
logging.info("Running litmus scenarios")
litmus_namespace = "litmus"
if not litmus_installed:
# Will always uninstall first
common_litmus.delete_chaos(litmus_namespace)
common_litmus.delete_chaos_experiments(
litmus_namespace)
common_litmus.uninstall_litmus(
litmus_version, litmus_namespace)
common_litmus.install_litmus(
litmus_version, litmus_namespace)
common_litmus.deploy_all_experiments(
litmus_version, litmus_namespace)
litmus_installed = True
common_litmus.run(
scenarios_list,
config,
litmus_uninstall,
wait_duration,
litmus_namespace,
)
# Inject cluster shutdown scenarios
elif scenario_type == "cluster_shut_down_scenarios":
shut_down.run(scenarios_list, config,
wait_duration)
# Inject namespace chaos scenarios
elif scenario_type == "namespace_scenarios":
logging.info("Running namespace scenarios")
namespace_actions.run(scenarios_list, config,
wait_duration,
failed_post_scenarios,
kubeconfig_path)
# Inject zone failures
elif scenario_type == "zone_outages":
logging.info("Inject zone outages")
zone_outages.run(scenarios_list, config,
wait_duration)
# Application outages
elif scenario_type == "application_outages":
logging.info("Injecting application outage")
application_outage.run(scenarios_list, config,
wait_duration)
# PVC scenarios
elif scenario_type == "pvc_scenarios":
logging.info("Running PVC scenario")
pvc_scenario.run(scenarios_list, config)
iteration += 1
logging.info("")
# Capture the end time
end_time = int(time.time())
# Capture metrics for the run
if capture_metrics:
logging.info("Capturing metrics")
kube_burner.setup(kube_burner_url)
kube_burner.scrape_metrics(
distribution,
run_uuid,
prometheus_url,
prometheus_bearer_token,
start_time,
end_time,
config_path,
metrics_profile,
)
# Check for the alerts specified
if enable_alerts:
logging.info("Alerts checking is enabled")
kube_burner.setup(kube_burner_url)
if alert_profile:
kube_burner.alerts(
distribution,
prometheus_url,
prometheus_bearer_token,
start_time,
end_time,
alert_profile,
)
else:
logging.error("Alert profile is not defined")
sys.exit(1)
if litmus_uninstall and litmus_installed:
common_litmus.delete_chaos(litmus_namespace)
common_litmus.delete_chaos_experiments(litmus_namespace)
common_litmus.uninstall_litmus(litmus_version, litmus_namespace)
if failed_post_scenarios:
logging.error(
"Post scenarios are still failing at the end of all iterations"
)
sys.exit(1)
run_dir = os.getcwd() + "/kraken.report"
logging.info(
"Successfully finished running Kraken. UUID for the run: %s. Report generated at %s. Exiting"
% (run_uuid, run_dir))
else:
logging.error("Cannot find a config at %s, please check" % (cfg))
sys.exit(1)
def admin(request, response):
with open("./views/admin.html", "r") as fd:
server.send_html_handler(request, response, fd.read())
def new_user(request, response):
content = request['content']
session_data = server.get_session(request, response)
if session_data and 'user' in session_data:
new_user = content['user'][0]
redis_server.sadd('all_users', new_user)
return home(request, response)
def build_routes():
server.add_route('get', '/', home)
server.add_route('get', '/login', login)
server.add_route('post', '/verify', verify)
server.add_route('get', '/profile', profile)
server.add_route('post', '/update_user', update_profile)
server.add_route('get', '/write', write)
server.add_route('post', '/new_blog', new_blog)
server.add_route('get', '/admin', admin)
server.add_route('post', '/new_user', new_user)
if __name__ == "__main__":
port = int(raw_input("PORT>"))
build_routes()
server.start_server("127.0.0.1", port, 20)
def setup(self):
if G.SINGLEPLAYER:
try:
print 'Starting internal server...'
# TODO: create world menu
G.SAVE_FILENAME = "world"
start_server(internal=True)
sock = socket.socket()
sock.connect(("localhost", 1486))
except socket.error as e:
print "Socket Error:", e
#Otherwise back to the main menu we go
return False
except Exception as e:
print 'Unable to start internal server'
import traceback
traceback.print_exc()
return False
else:
try:
#Make sure the address they want to connect to works
ipport = G.IP_ADDRESS.split(":")
if len(ipport) == 1: ipport.append(1486)
sock = socket.socket()
sock.connect((tuple(ipport)))
except socket.error as e:
print "Socket Error:", e
#Otherwise back to the main menu we go
return False
self.init_gl()
sky_rotation = -20.0 # -20.0
# TERRAIN_CHOICE = self.biome_generator.get_biome_type(sector[0], sector[2])
default_skybox = 'skydome.jpg'
#if TERRAIN_CHOICE == G.NETHER:
# default_skybox = 'skydome_nether.jpg'
#else:
# default_skybox = 'skybox.jpg'
print 'loading ' + default_skybox
self.skydome = Skydome(
'resources/' + default_skybox,
#'resources/skydome.jpg',
0.7,
100.0,
sky_rotation,
)
self.player_ids = {} # Dict of all players this session, indexes are their ID's [0: first Player on server,]
self.focus_block = B.Block(width=1.05, height=1.05)
self.earth = vec(0.8, 0.8, 0.8, 1.0)
self.white = vec(1.0, 1.0, 1.0, 1.0)
self.ambient = vec(1.0, 1.0, 1.0, 1.0)
self.polished = GLfloat(100.0)
self.crack_batch = pyglet.graphics.Batch()
#if G.DISABLE_SAVE and world_exists(G.game_dir, G.SAVE_FILENAME):
# open_world(self, G.game_dir, G.SAVE_FILENAME)
self.world = World()
self.packetreceiver = PacketReceiver(self.world, self, sock)
self.world.packetreceiver = self.packetreceiver
G.CLIENT = self.packetreceiver
self.packetreceiver.start()
#Get our position from the server
self.packetreceiver.request_spawnpos()
#Since we don't know it yet, lets disable self.update, or we'll load the wrong chunks and fall
self.update_disabled = self.update
self.update = lambda dt: None
#We'll re-enable it when the server tells us where we should be
self.player = Player(game_mode=G.GAME_MODE)
print('Game mode: ' + self.player.game_mode)
self.item_list = ItemSelector(self, self.player, self.world)
self.inventory_list = InventorySelector(self, self.player, self.world)
self.item_list.on_resize(self.window.width, self.window.height)
self.inventory_list.on_resize(self.window.width, self.window.height)
self.text_input = TextWidget(self.window, '',
0, 0,
self.window.width,
visible=False,
font_name=G.CHAT_FONT)
self.text_input.push_handlers(on_toggled=self.on_text_input_toggled, key_released=self.text_input_callback)
self.chat_box = TextWidget(self.window, '',
0, self.text_input.y + self.text_input.height + 50,
self.window.width / 2, height=min(300, self.window.height / 3),
visible=False, multi_line=True, readonly=True,
font_name=G.CHAT_FONT,
text_color=(255, 255, 255, 255),
background_color=(0, 0, 0, 100),
enable_escape=True)
self.camera = Camera3D(target=self.player)
if G.HUD_ENABLED:
self.label = pyglet.text.Label(
'', font_name='Arial', font_size=8, x=10, y=self.window.height - 10,
anchor_x='left', anchor_y='top', color=(255, 255, 255, 255))
pyglet.clock.schedule_interval_soft(self.world.process_queue,
1.0 / G.MAX_FPS)
pyglet.clock.schedule_interval_soft(self.world.hide_sectors, 10.0, self.player)
return True
