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()