def configure(self, args, backend, env):
"""Start a webserver for the visualization."""
server_addr = mosaik_api._parse_addr(args['--serve'])
server_sock = backend.TCPSocket.server(env, server_addr)
self.server = server.Server(env, server_sock)
# MachineList: all the info of the Machine
# Machine: a Single Machine
# MachineList_Source: source for the MachineList
# Machine_Source: source for the singe Machine
# author: ChuXiaokai
# date: 2016/3/24
"""
from flask import Flask, request, jsonify
from flask.ext.httpauth import HTTPBasicAuth
from flask.ext.sqlalchemy import SQLAlchemy
import server
# server point
host = server.Server()
auth = HTTPBasicAuth()
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///webappdb'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
db = SQLAlchemy(app)
### database ###########################################################################
# table User
class User(db.Model):
user = db.Column(db.String(40), primary_key=True)
passwd = db.Column(db.String(40))
num_mcs = db.Column(db.Integer)
#CODE USAGE for SERVER
import server
import time
import sys
print '############################'
print 'SERVER SIDE STARTED'
print '############################'
print '\n'
s = server.Server('Server', 'localhost', 6666, 'localhost', 6789)
time.sleep(2)
s.connect()
time.sleep(1)
s.push_data()
print 'TOTAL number of TRY: {}'.format(s.stats.dat[s.stats.TRY])
str(_ANDROID_NEGATIVE_FILTER.keys())))
options, args = parser.parse_args()
options.chromedriver = util.GetAbsolutePathOfUserPath(options.chromedriver)
if not options.chromedriver or not os.path.exists(options.chromedriver):
parser.error('chromedriver is required or the given path is invalid.' +
'Please run "%s --help" for help' % __file__)
global _CHROMEDRIVER_BINARY
_CHROMEDRIVER_BINARY = options.chromedriver
if (options.android_package
and options.android_package not in _ANDROID_NEGATIVE_FILTER):
parser.error('Invalid --android-package')
chromedriver_server = server.Server(_CHROMEDRIVER_BINARY, options.log_path)
global _CHROMEDRIVER_SERVER_URL
_CHROMEDRIVER_SERVER_URL = chromedriver_server.GetUrl()
global _REFERENCE_CHROMEDRIVER
_REFERENCE_CHROMEDRIVER = util.GetAbsolutePathOfUserPath(
options.reference_chromedriver)
global _CHROME_BINARY
if options.chrome:
_CHROME_BINARY = util.GetAbsolutePathOfUserPath(options.chrome)
else:
_CHROME_BINARY = None
global _ANDROID_PACKAGE_KEY
_ANDROID_PACKAGE_KEY = options.android_package
def get_connection(server_num=5):
return server.Server(server_num)
def init_server(self, members):
self.node.server = server.Server(self.node, members)
def main():
server.Server()
help="Reset database with test data",
action="store_true")
args = parser.parse_args(sys.argv[1:])
database_path = vars(args).get("database")
if database_path is None:
print("Option --database not given")
sys.exit(1)
if vars(args).get("reset_with_testdata"):
try:
os.remove(database_path)
except FileNotFoundError:
pass
port_str = vars(args).get("port")
if port_str is None:
print("Option --port not given")
sys.exit(1)
port = int(port_str)
server = server.Server(database_path)
if vars(args).get("reset_with_testdata"):
util.setup_test_data(server.database)
app = server.get_app()
app.listen(port)
loop = tornado.ioloop.IOLoop.current()
loop.start()
cls = lambda: print("\033[2J\033[;H", end='')
cls()
"""
Day 54 - Higher Lower
"""
import server
import random
answer_number = random.randint(1, 10)
flask_server = server.Server(answer_number)
app = flask_server.app
lower_list = []
higher_list = []
for i in range(9):
if i < answer_number:
lower_list.append(i)
if i > answer_number:
higher_list.append(i)
@app.route("/")
def home():
return "<h1> Higher Lower Game </h1>\n<hr>\n<img src=https://media.giphy.com/media/3o7aCSPqXE5C6T8tBC/giphy.gif>\n <p> Try guessing a number in the URL between 1 and 9."
@app.route('/<int:appitemid>')
def check(appitemid):
if appitemid < answer_number:
return "<h1> Lower </h1>\n<hr>\n<p>You should try to aim a little higher here</p>"
def testRender(self):
obj = server.Server(None)
self.assertEquals("<body>\n<h1> Test </h1>\n</body>",obj._render("= Test =\n"))
def runExperiment(args):
# Set the random seed
random.seed(args.seed)
numpy.random.seed(args.seed)
Simulation.initialize()
servers = []
clients = []
workloadGens = []
constants.NW_LATENCY_BASE = args.nwLatencyBase
constants.NW_LATENCY_MU = args.nwLatencyMu
constants.NW_LATENCY_SIGMA = args.nwLatencySigma
constants.NUMBER_OF_CLIENTS = args.numClients
assert args.expScenario != ""
serviceRatePerServer = []
if (args.expScenario == "base"):
# Start the servers
for i in range(args.numServers):
serv = server.Server(i,
resourceCapacity=args.serverConcurrency,
serviceTime=(args.serviceTime),
serviceTimeModel=args.serviceTimeModel)
servers.append(serv)
elif (args.expScenario == "multipleServiceTimeServers"):
# Start the servers
for i in range(args.numServers):
serv = server.Server(i,
resourceCapacity=args.serverConcurrency,
serviceTime=((i + 1) * args.serviceTime),
serviceTimeModel=args.serviceTimeModel)
servers.append(serv)
elif (args.expScenario == "heterogenousStaticServiceTimeScenario"):
baseServiceTime = args.serviceTime
assert args.slowServerFraction >= 0 and args.slowServerFraction < 1.0
assert args.slowServerSlowness >= 0 and args.slowServerSlowness < 1.0
assert not (args.slowServerSlowness == 0
and args.slowServerFraction != 0)
assert not (args.slowServerSlowness != 0
and args.slowServerFraction == 0)
if (args.slowServerFraction > 0.0):
slowServerRate = (args.serverConcurrency *
1/float(baseServiceTime)) *\
args.slowServerSlowness
numSlowServers = int(args.slowServerFraction * args.numServers)
slowServerRates = [slowServerRate] * numSlowServers
numFastServers = args.numServers - numSlowServers
totalRate = (args.serverConcurrency * 1 / float(args.serviceTime) *
args.numServers)
fastServerRate = (totalRate - sum(slowServerRates))\
/ float(numFastServers)
fastServerRates = [fastServerRate] * numFastServers
serviceRatePerServer = slowServerRates + fastServerRates
else:
serviceRatePerServer = [
args.serverConcurrency * 1 / float(args.serviceTime)
] * args.numServers
random.shuffle(serviceRatePerServer)
# print sum(serviceRatePerServer), (1/float(baseServiceTime)) * args.numServers
assert sum(serviceRatePerServer) > 0.99 *\
(1/float(baseServiceTime)) * args.numServers
assert sum(serviceRatePerServer) <=\
(1/float(baseServiceTime)) * args.numServers
# Start the servers
for i in range(args.numServers):
st = 1 / float(serviceRatePerServer[i])
serv = server.Server(i,
resourceCapacity=args.serverConcurrency,
serviceTime=st,
serviceTimeModel=args.serviceTimeModel)
servers.append(serv)
elif (args.expScenario == "timeVaryingServiceTimeServers"):
assert args.intervalParam != 0.0
assert args.timeVaryingDrift != 0.0
# Start the servers
for i in range(args.numServers):
serv = server.Server(i,
resourceCapacity=args.serverConcurrency,
serviceTime=(args.serviceTime),
serviceTimeModel=args.serviceTimeModel)
mup = muUpdater.MuUpdater(serv, args.intervalParam,
args.serviceTime, args.timeVaryingDrift)
Simulation.activate(mup, mup.run(), at=0.0)
servers.append(serv)
else:
print "Unknown experiment scenario"
sys.exit(-1)
baseDemandWeight = 1.0
clientWeights = []
assert args.highDemandFraction >= 0 and args.highDemandFraction < 1.0
assert args.demandSkew >= 0 and args.demandSkew < 1.0
assert not (args.demandSkew == 0 and args.highDemandFraction != 0)
assert not (args.demandSkew != 0 and args.highDemandFraction == 0)
if (args.highDemandFraction > 0.0 and args.demandSkew >= 0):
heavyClientWeight = baseDemandWeight *\
args.demandSkew/args.highDemandFraction
numHeavyClients = int(args.highDemandFraction * args.numClients)
heavyClientWeights = [heavyClientWeight] * numHeavyClients
lightClientWeight = baseDemandWeight *\
(1 - args.demandSkew)/(1 - args.highDemandFraction)
numLightClients = args.numClients - numHeavyClients
lightClientWeights = [lightClientWeight] * numLightClients
clientWeights = heavyClientWeights + lightClientWeights
else:
clientWeights = [baseDemandWeight] * args.numClients
assert sum(clientWeights) > 0.99 * args.numClients
assert sum(clientWeights) <= args.numClients
# Start the clients
for i in range(args.numClients):
c = client.Client(id_="Client%s" % (i),
serverList=servers,
replicaSelectionStrategy=args.selectionStrategy,
accessPattern=args.accessPattern,
replicationFactor=args.replicationFactor,
backpressure=args.backpressure,
shadowReadRatio=args.shadowReadRatio,
rateInterval=args.rateInterval,
cubicC=args.cubicC,
cubicSmax=args.cubicSmax,
cubicBeta=args.cubicBeta,
hysterisisFactor=args.hysterisisFactor,
demandWeight=clientWeights[i])
clients.append(c)
# Start workload generators (analogous to YCSB)
latencyMonitor = Simulation.Monitor(name="Latency")
# This is where we set the inter-arrival times based on
# the required utilization level and the service time
# of the overall server pool.
arrivalRate = 0
interArrivalTime = 0
if (len(serviceRatePerServer) > 0):
print serviceRatePerServer
arrivalRate = (args.utilization * sum(serviceRatePerServer))
interArrivalTime = 1 / float(arrivalRate)
else:
arrivalRate = args.numServers *\
(args.utilization * args.serverConcurrency *
1/float(args.serviceTime))
interArrivalTime = 1 / float(arrivalRate)
for i in range(args.numWorkload):
w = workload.Workload(i, latencyMonitor, clients, args.workloadModel,
interArrivalTime * args.numWorkload,
args.numRequests / args.numWorkload)
Simulation.activate(w, w.run(), at=0.0),
workloadGens.append(w)
# Begin simulation
Simulation.simulate(until=args.simulationDuration)
#
# Print a bunch of timeseries
#
pendingRequestsFD = open(
"../%s/%s_PendingRequests" % (args.logFolder, args.expPrefix), 'w')
waitMonFD = open("../%s/%s_WaitMon" % (args.logFolder, args.expPrefix),
'w')
actMonFD = open("../%s/%s_ActMon" % (args.logFolder, args.expPrefix), 'w')
latencyFD = open("../%s/%s_Latency" % (args.logFolder, args.expPrefix),
'w')
latencyTrackerFD = open(
"../%s/%s_LatencyTracker" % (args.logFolder, args.expPrefix), 'w')
rateFD = open("../%s/%s_Rate" % (args.logFolder, args.expPrefix), 'w')
tokenFD = open("../%s/%s_Tokens" % (args.logFolder, args.expPrefix), 'w')
receiveRateFD = open(
"../%s/%s_ReceiveRate" % (args.logFolder, args.expPrefix), 'w')
edScoreFD = open("../%s/%s_EdScore" % (args.logFolder, args.expPrefix),
'w')
for clientNode in clients:
printMonitorTimeSeriesToFile(pendingRequestsFD, clientNode.id,
clientNode.pendingRequestsMonitor)
printMonitorTimeSeriesToFile(latencyTrackerFD, clientNode.id,
clientNode.latencyTrackerMonitor)
printMonitorTimeSeriesToFile(rateFD, clientNode.id,
clientNode.rateMonitor)
printMonitorTimeSeriesToFile(tokenFD, clientNode.id,
clientNode.tokenMonitor)
printMonitorTimeSeriesToFile(receiveRateFD, clientNode.id,
clientNode.receiveRateMonitor)
printMonitorTimeSeriesToFile(edScoreFD, clientNode.id,
clientNode.edScoreMonitor)
for serv in servers:
printMonitorTimeSeriesToFile(waitMonFD, serv.id,
serv.queueResource.waitMon)
printMonitorTimeSeriesToFile(actMonFD, serv.id,
serv.queueResource.actMon)
print "------- Server:%s %s ------" % (serv.id, "WaitMon")
print "Mean:", serv.queueResource.waitMon.mean()
print "------- Server:%s %s ------" % (serv.id, "ActMon")
print "Mean:", serv.queueResource.actMon.mean()
print "------- Latency ------"
print "Mean Latency:",\
sum([float(entry[1].split()[0]) for entry in latencyMonitor])/float(len(latencyMonitor))
printMonitorTimeSeriesToFile(latencyFD, "0", latencyMonitor)
assert args.numRequests == len(latencyMonitor)
import contextlib
with contextlib.redirect_stdout(None):
import pygame
import r2d2
import server
import sys
pygame.init()
serv = server.Server(None)
serv.start()
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
PURPLE = (255, 0, 255)
size = s_w, s_h = (500, 500)
screen = pygame.display.set_mode(size)
pygame.display.set_caption('R2D2 GUI')
all_sprites_list = pygame.sprite.Group()
r2 = r2d2.R2D2()
r2.set_center_position(x=r2.rect.width/2, y=s_h-r2.rect.height/2)
r2.set_socket_delegate(serv)
all_sprites_list.add(r2)
carry_on = True # continue until explicit exit
def pickle_turn(player_id, rolls):
string = "{}|{}".format(player_id, "|".join(map(str, rolls)))
return string
def unpickle_turn(string):
tokens = string.split("|")
player_id = int(tokens[0])
rolls = [int(roll) for roll in tokens[1:]]
return (player_id, rolls)
if inp == "host":
HOST_ID = 0
host = server.Server(ip, port) # make host
PLAYER_COUNT = int(input("Number of players: ")) # get no. of players
host.listen(PLAYER_COUNT - 1) # hold until server gets N connections
for client_id, client in enumerate(host.clients): # send players their ids
host.send(client, str(client_id + 1))
host.broadcast(str(PLAYER_COUNT)) # broadcasts total players
b = player.Board(PLAYER_COUNT)
players = [player.Player(b, i) for i in range(PLAYER_COUNT)]
die = player.Die()
player_id = HOST_ID
while True:
if player_id: # deal with clients
while True:
pickled = host.receive()
def get_connection():
return server.Server()
import server
import sys
if __name__ == "__main__":
try:
server.Server().serve()
except KeyboardInterrupt as msg:
sys.exit(0)
import server
import client
ckFlag = int(raw_input('Enter 0 to become the server and 1 for client'))
if ckFlag == 0:
servObj= server.Server()
servObj.start()
else:
ip = raw_input('Enter the ip address of the server')
port = int(raw_input('Enter the port number of the server'))
cliObj = client.Client(ip, port)
cliObj.start()
parser.add_option(
'',
'--filter',
type='string',
default='*',
help=(
'Filter for specifying what tests to run, "*" will run all. E.g., '
'*testStartStop'))
parser.add_option('', '--android-package', help='Android package name')
options, args = parser.parse_args()
if not options.chromedriver or not os.path.exists(options.chromedriver):
parser.error('chromedriver is required or the given path is invalid.' +
'Please run "%s --help" for help' % __file__)
chromedriver_server = server.Server(os.path.abspath(options.chromedriver))
global _CHROMEDRIVER_SERVER_URL
_CHROMEDRIVER_SERVER_URL = chromedriver_server.GetUrl()
global _REFERENCE_CHROMEDRIVER
_REFERENCE_CHROMEDRIVER = options.reference_chromedriver
global _CHROME_BINARY
if options.chrome:
_CHROME_BINARY = os.path.abspath(options.chrome)
else:
_CHROME_BINARY = None
global _ANDROID_PACKAGE
_ANDROID_PACKAGE = options.android_package
def run_server(i, addr):
s = server.Server(addr)
service = center_service.CenterService(s, i, centers)
s.add_service(service)
s.set_keep_alive(2, 3)
s.run()
import server as server s = server.Server(8010, "127.0.0.1") s.soc_bind() s.start_listening(1) s.main() s.soc.close()
def start_control_server(self, server_port, channel):
self.server = server.Server(server_port, channel)
server_thread = threading.Thread(target=self.server.run)
server_thread.daemon = True
server_thread.start()
import server
import select
import generatedata
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("port", help="the socket port", type=int)
parser.add_argument("x", help="the target x-coordinates", type=float)
parser.add_argument("y", help="the target y-coordinates", type=float)
parser.add_argument("nb_stations", help="the number of stations", type=int)
args = parser.parse_args()
target_coord = [args.x, args.y]
my_server = server.Server()
my_data = generatedata.GenerateData(args.nb_stations, target_coord)
my_server.launch(args.port)
try:
while my_server.server_launch:
asked_connections, wlist, xlist = \
select.select([my_server.serversock], [], [], 0.05)
for connection in asked_connections:
client_connection, info_connection = connection.accept()
my_server.connected_client.append(client_connection)
msg = my_data.convert_stations_coord()
my_server.mysend(msg.encode(), client_connection)
start_time = time.time()
GPIO.setmode(GPIO.BOARD)
GPIO.setup(21, GPIO.OUT)
led = GPIO.PWM(21, 2)
led.start(0.5)
print("##########################################################\n"
"### RC-Car\n"
"### Server Version 0.7.1b - Expecting client version 0.7b\n"
"### Server is going to be hosted on {}\n".format(IP_ADDRESS) +
"###")
servo_control = servo.PwmServo()
server = server.Server(IP_ADDRESS, 9999)
tps = TPSCounter(servo_control)
tps.start()
print("### Initialization finished in {:1.4f} seconds".format(
(time.time() - start_time)))
print("##########################################################\n\n")
while not server.termination_pending:
print("\tWaiting for incoming connection...")
led.ChangeDutyCycle(0.5)
# wait until a connection is established
server.await_connection()
while server.connection_active:
########################### #### CONFIG ##### ########################### magnet_pin = 4 led_pin = 14 gpio.setmode(gpio.BCM) gpio.setup(magnet_pin, gpio.OUT) gpio.setup(led_pin, gpio.OUT) magnet_off() if sn == 0: connection = server.Server(64, PORT, localIP) else: if localConnection == True: connection = client.Client(64, PORT, localIP) else: connection = client.Client(64, PORT, globalIP) start_blink() connection.connect() stop_blink() if turn == sn: led_on() else: led_off()
def __init__(self, configname, appname): self.loader = loader.Loader(configname, appname) self.app = self.loader.loadapp_file() self.server = server.Server(self.app, '0.0.0.0', 8000)
import animator_server_controller
import config
import machine
import server
import status_server_controller
import utils
utils.printInfo("ANIMATOR", "boot up")
utils.createSyncDateTimeTimer()
animatorServerController = animator_server_controller.AnimatorServerController(
machine.Pin(config.ANIMATOR_PIN, machine.Pin.OUT))
statusController = status_server_controller.StatusServerController(
'Animator', [animatorServerController])
_server = server.Server(config.SERVER_PORT,
[statusController, animatorServerController])
try:
_server.run()
except KeyboardInterrupt:
utils.printInfo("ANIMATOR", "stopped by the user")
utils.deleteTimers()
except Exception as e:
utils.printWarn("ANIMATOR", "exception during server run: %s" % e)
machine.reboot()
def setUp(self):
address = 'localhost:8099'
self.server = server.Server(address)
# Gregary C. Zweigle, 2020
import eventlet
from flask import Flask, render_template
from flask_socketio import SocketIO
import server
eventlet.monkey_patch()
app = Flask(__name__)
app.config['SECRET_KEY'] = 'put_secret_key_here'
socket_io = SocketIO(app)
ss = server.Server()
@app.route('/')
def main_page():
print("Rendering initial HTML page.")
return render_template('MidiDrum.html')
@socket_io.on('client_ready')
def pass_along_data_from_client(message):
ss.server(socket_io)
if __name__ == '__main__':
socket_io.run(app, port=5000, debug=True)
def __init__(self, port):
QtCore.QThread.__init__(self)
ServerThread.server = server.Server(int(port))
skipped_tests = process_skip_list(skip_list, test_results, path_finder,
port, test_path, test_shard)
options.chromedriver = util.GetAbsolutePathOfUserPath(options.chromedriver)
if (not os.path.exists(options.chromedriver)
and util.GetPlatformName() == 'win'
and not options.chromedriver.lower().endswith('.exe')):
options.chromedriver = options.chromedriver + '.exe'
if not os.path.exists(options.chromedriver):
parser.error('Path given by --chromedriver is invalid.\n' +
'Please run "%s --help" for help' % __file__)
# Due to occasional timeout in starting ChromeDriver, retry once when needed.
try:
chromedriver_server = server.Server(options.chromedriver,
options.log_path)
except RuntimeError as e:
_log.warn('Error starting ChromeDriver, retrying...')
chromedriver_server = server.Server(options.chromedriver,
options.log_path)
if not chromedriver_server.IsRunning():
_log.error('ChromeDriver is not running.')
sys.exit(1)
set_up_config(path_finder, chromedriver_server)
start_time = time.time()
sys.path.insert(0, WEBDRIVER_CLIENT_ABS_PATH)
try:
if options.isolated_script_test_filter:
import server, time, socket
serv = server.Server()
while (True):
try:
print serv.acceptSock()
except socket.timeout: # Whenever acceptSock() doesn't add anything
pass # a Timeout Exception is thrown
except KeyboardInterrupt:
print "close server"
serv.close()
exit()
try:
serv.broadcastMessages()
except socket.timeout: # Whenever a timeout fires
pass # a Timeout Exception is thrown
except KeyboardInterrupt:
print "close server"
serv.close()
exit()
