def main(): for a in sys.argv: if a == '-v': print_version_and_exit() if len(sys.argv) < 2 or sys.argv[1] == '-h': print_usage_and_exit(0) load_settings() command = sys.argv[1] arg_parser = make_arg_parser(command) if command in ('startserver', 'stopserver'): server.main(arg_parser, sys.argv[2:], command[:-6]) elif command == 'sendmail': sendmail.main(arg_parser, sys.argv[2:]) elif command == 'relayevent': relayevent.main(arg_parser, sys.argv[2:]) elif command == 'webhook': webhook.main(arg_parser, sys.argv[2:]) else: sys.stderr.write('unknown command "%s"\n\n' % command) print_usage_and_exit(-1)
def update(self, clickPos, page, serverAddr=""): """ option 1: 1p vs 1p option 2: connect option 3: server option 4: client option 5: server address correct or not """ if self.rect.collidepoint(clickPos): if self.option == 1: pygame.quit() mainScreen.main() elif self.option == 2: page[0] = 2 elif self.option == 3: pygame.quit() server.main() elif self.option == 4: page[0] = 3 elif self.option == 5: ifCorrect = checkAddressFormat(serverAddr) if ifCorrect: pygame.quit() client.main(serverAddr) else: page[0] = -1
def main(): import server as myServer import sys try: myServer.main() except KeyboardInterrupt: sys.exit(0)
def main(): print "Launched." if not os.path.exists("dataSaved.csv"): try: f = open("dataSaved.csv", "w") except IOError: print "Unable to create CSV file. Exiting." return else: f.close() v = Verarbeitung() v.loadData() v.saveDataCSV() t = Thread(target=application.realmain) t.start() print "Web server launched!" try: print "About to launch local server..." server.main(v) except KeyboardInterrupt: pass finally: print "Exiting. Saving data." v.saveData() t._Thread__stop()
def main(args): args['exit'] = threading.Event() args['sv'] = args['db'].server_list(args['defaults']['domain']) args['svlink'] = linkserver args['svlock'] = threading.RLock() for s in args['sv'].values(): cli = linkserver(s, args['defaults']['domain']) if cli.ping() == False: print "%s: %s [%s]" % (s['name'], s['host'], util.red("failed")) sys.exit(1) print "%s: %s [%s]" % (s['name'], s['host'], util.green("OK")) cli.close() chksvth = threading.Thread(target=checkserver, name='chksvth', args=(args, )) chksvth.daemon = True chksvth.start() try: server.main(args) except KeyboardInterrupt: print "" print "Caught KeyboardInterrupt, closing..." args['exit'].set() chksvth.join() if args['defaults']['debug']: print "main exited"
def main(): for a in sys.argv: if a == '-v': print_version_and_exit() if len(sys.argv) < 2 or sys.argv[1] == '-h': print_usage_and_exit(0) load_settings() command = sys.argv[1] arg_parser = make_arg_parser(command) import relayevent import sendmail import server import webhook if command in ('startserver', 'stopserver'): server.main(arg_parser, sys.argv[2:], command[:-6]) elif command == 'sendmail': sendmail.main(arg_parser, sys.argv[2:]) elif command == 'relayevent': relayevent.main(arg_parser, sys.argv[2:]) elif command == 'webhook': webhook.main(arg_parser, sys.argv[2:]) else: sys.stderr.write('unknown command "%s"\n\n' % command) print_usage_and_exit(-1)
def kurmaISLEM(self): self.loader.text.text = u"Þifreleme Anahtarý\nOluþturuluyor..." self.loader.open() self.sifreKEY = self.keySEC() self.acikKEY = cipher.keyTRANS(self.sifreKEY[0]) self.sakliKEY = cipher.keyTRANS(self.sifreKEY[1]) self.sun_EKRAN.kapaliKEY = self.sakliKEY try: self.loader.text.text = "Sunucu Kuruluyor..." self.sunucu = threading.Thread(target=self.kurmaISLEM) self.sunucu.daemon = True server.main(self.sock,self.SIFRE, self.loader, self.parent,int(self.PORT),self.sun_EKRAN,self.acikKEY) except Exception as e: print e self.loader.dismiss() self.error.open() self.sunucu = threading.Thread(target=self.kurmaISLEM) self.sunucu.daemon = True
def run(user_input, log): main() text = "" if user_input == "": text = "Please enter a value\n" else: text = "Test" QMetaObject.invokeMethod(log, "append", Qt.QueuedConnection, Q_ARG(str, text))
def test_main(): fakemodule = FakeSocketModule() success = False try: server.main(fakemodule) except AcceptCalledMultipleTimes: success = True assert success, "something went wrong"
def start(): for d in DIRS: if not os.path.exists(os.getcwd() + '/' + d): print 'This is not a drax project, directory "{}"'\ ' is missing'.format(d) return parser = argparse.ArgumentParser() parser.add_argument('--port', default=8888) parser.add_argument('--auth_token', default=None) args = parser.parse_args(sys.argv[2:]) server.main(os.getcwd(), auth_token=args.auth_token, port=args.port)
def main(argv=None): program_name = os.path.basename(sys.argv[0]) program_version = __version__ program_build_date = "%s" % __updated__ program_version_string = '%%prog %s (%s)' % (program_version, program_build_date) program_longdesc = '''''' # optional - give further explanation about what the program does program_license = u"Copyright 2016 Magosányi Árpád \ Licensed under GNU GPL v3" if argv is None: argv = sys.argv[1:] try: parser = OptionParser(version=program_version_string, epilog=program_longdesc, description=program_license) parser.add_option("-d", "--id", dest="keyid", type="string", help="key id (mandatory!)") parser.add_option("-m", "--module", dest="module", type="string", help="pkcs11 module path") parser.add_option("-p", "--pin", dest="pin", type="string", help="pin [default: %default]") parser.add_option("-M", "--mechanism", dest="mechanism", help="HNAC/sign mechanism to use [default: %default]", type="string") parser.add_option("-H", "--host", dest="host", type="string", help="host [default: %default]") parser.add_option("-P", "--port", dest="port", type="int", help="port [default: %default]") parser.add_option("-v", "--verbose", dest="verbose", action="count", help="verbose to syslog. WARNING: logs PIN! [default: %default]") parser.add_option("-e", "--environment", dest="environment", type="string", help="append var=value to environment [default: %default]") parser.set_defaults(module="/usr/lib/opensc-pkcs11.so", pin=u"0000", mechanism="SHA512-RSA-PKCS", host=u"localhost", port=9999, environment=None) # process options (opts, args) = parser.parse_args(argv) if not opts.keyid: print parser.format_help() sys.exit(1) if opts.environment: (name,value) = opts.environment.split("=",2) print (name,value) os.environ[name]=value syslog.openlog("cryptoserver", logoption=syslog.LOG_PID) syslog.syslog("cryptoserver started at {0} {1}".format(opts.host,opts.port)) server.main(opts) except: excString = traceback.format_exc() syslog.syslog(excString) print excString syslog.syslog("cryptoserver stopped at {0} {1}".format(opts.host,opts.port))
def main(): if len(sys.argv) != 2: usage() sys.exit(1) if sys.argv[1] == 'serve': server.main() elif sys.argv[1] == 'crawl': crawler.main() else: usage() sys.exit(1)
def monitoringWater(message, *something): global waterWork global notWaterWork # 水やり監視起動 if waterWork : message.reply('水やり監視モードが既に起動中です。') elif notWaterWork : message.reply('通常監視モードが既に起動中です。重複起動はできません。') else : message.reply('水やり監視モードを起動します。') waterWork = True server.main()
def startDaemon(): curPath = os.path.dirname(os.path.realpath(__file__)) # Fork and die pid = os.fork() if pid == 0: #The first child #os.chdir("/") os.setsid() os.umask(0) pid2 = os.fork() if pid2 == 0: server.main() #subprocess.call(["python",curPath + '/server.py']) sys.exit()
def test_main(): fakemodule = FakeSocketModule() sys.argv[1] = '-A' sys.argv.append('myapp') success = False try: server.main(fakemodule) except AcceptCalledMultipleTimes: success = True pass assert success, "Something went wrong"
async def main(): queue = asyncio.Queue() port = os.environ.get('SERVER_PORT', 63083) if os.environ.get('SERVER_ONLY'): await asyncio.gather( server.main(queue, port=port) ) else: client = bot.MyClient(queue) await asyncio.gather( server.main(queue, port=port), client.start(os.environ['DISCORD_BOT_TOKEN']) )
def execute(): try: config = readConfig() if config["main"]["torrent"] == "": print("\033[91mTorrent download directory not set! Set by running client.py with -t/--torrent\033[0m") elif config["main"]["quality"] == "": print("\033[91mDownload quality not set! Set by running client.py with -q/--quality\033[0m") elif not config["watchlist"]: print("\033[91mWatchlist is empty! Add shows by running client.py with -a/--add option\033[0m") else: server.main() except KeyboardInterrupt: print("\n\033[91mKeyboard Interrupt Detected. Exiting.\033[0m")
def main(): State.logger.setLevel(logging.DEBUG) State.logger.addHandler(logging.StreamHandler(sys.stderr)) load_config() if not test_config(): exit(1) read_modules() threading.Thread(target=event_thread).start() threading.Thread(target=timer_thread).start() server.main(State)
def transferro(): try: import server,client except: print('Dependencies not found') print('server.py & client.py should be in same directory as transferro.py') sleep(2) exit() choice = input('Welcome to Transferro\nYou are\n1 Sender\n2 Receiver\n') if choice == '1': server.main() else: client.main()
def test_main(mocker, command_line, result): from server import main mocker.patch("sys.argv", command_line) output = main() assert output == result
def main(): parser = argparse.ArgumentParser() parser.add_argument("--host", default="0.0.0.0") parser.add_argument("--port", type=int, default=1155) parser.add_argument("--mongo_host", default="localhost") parser.add_argument("--mongo_port", type=int, default=27017) args = parser.parse_args() try: c = Connection() c.disconnect() except: print "mongo connection not found" exit(1) server.main(args) message = '''
def main(): desc = "A chat app built over TCP" parser = argparse.ArgumentParser(description=desc) group = parser.add_mutually_exclusive_group() group.add_argument('-s', '--server', action='store_true', help='starts the server') group.add_argument('-c', '--client', action='store_true', help='starts the client') parser.add_argument('interface') parser.add_argument('password') args = parser.parse_args() argv = [args.interface, args.password] if args.server: server.main(argv) elif args.client: client.main(argv) else: parser.print_help()
def main(): args = parser().parse_args() if args.server: Interface.schedule(server.main(args.repopulate)) if args.no_client: while Interface.active(): time.sleep(1) client.main("127.0.0.1") Interface.stop()
def test_create_server_input(self): """ Verify the input when creating servers is always correct. """ # This case should cast 8080 to an int sys.argv = ['server.py'] sys.argv.append('-l 127.0.0.1') sys.argv.append('-p 8080') self.assertRaises(SystemExit, server.main) # This case can't cast tasty tacos to integers. # Make sure we get a parser error and invalid int warning sys.argv[1] = '-l 127.0.0.1' sys.argv[2] = '-p taco' out_buff = StringIO() sys.stderr = out_buff try: server.main() except SystemExit, ex: assert ex.message == 2 out_buff.seek(0) assert 'invalid integer' in out_buff.read()
def main(): fileName = sys.argv[1] mrm = master.main(fileName) server.main(mrm, fileName) client.main(mrm, fileName)
parser.add_argument('--brightness', default=100, type=int) parser.add_argument('--duration', type=int, default=10, help='Delay of progress.') parser.add_argument('--special_nest_layout', action='store_true') parser.add_argument('--debug', action="store_true") args = parser.parse_args() argsd = vars(args) logger = logging.getLogger('websockets.server') logger.setLevel(logging.DEBUG) logger.addHandler(logging.StreamHandler()) if args.debug: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) hold_sets = {k for k in problems.HOLDS_SETS if argsd[k]} #problems led_layout = LED_LAYOUT['nest'] if args.special_nest_layout else None MOONBOARD = MoonBoard(args.driver_type, led_layout) loop = asyncio.get_event_loop() loop.run_until_complete(main(logger, MOONBOARD, args.setup, hold_sets)) asyncio.get_event_loop().run_forever()
#!/usr/bin/env python3 import os import sys sys.path.append("src") os.chdir(os.path.dirname(os.path.realpath(__file__))) import server server.main()
def main(): import server server.main()
import sys import os sys.path.append(os.path.abspath('./')) from server import main if __name__ == "__main__": main()
def main(): import logs logs.setup() import server server.main()
#!/usr/bin/env python import os base = os.path.dirname(os.path.abspath(__file__)+'../') os.environ['PYTHON_EGG_CACHE'] = os.path.join(base, '..', 'misc/virtenv/lib/python2.6/site-packages') virtualenv = os.path.join(base, '..', 'misc/virtenv/bin/activate_this.py') execfile(virtualenv, dict(__file__=virtualenv)) sys.path.append(os.path.join(base, "src")) import server server.main(os.environ['OPENSHIFT_DIY_IP'])
from __future__ import print_function from __future__ import unicode_literals from argparse import ArgumentParser import os import os.path import shutil import platform from io import StringIO import subprocess import sys import tarfile import xml.etree.ElementTree as ET import wget import server from lib.util import get_static_resource_path launch_parser = ArgumentParser() server.populate_parser(launch_parser) args = launch_parser.parse_args(['TopicExplorerFolder.ini']) #print (args) #raise Exception("") server.main(args)
def Main(): friendIP = input("enter your friend's IP:") senderThread = threading.Thread(target=server.main()) recieverThread = threading.Thread(target=client.main(), args=(friendIP)) senderThread.start() recieverThread.start()
def run(self): main()
def threadFunc(): server.main()
#!/usr/bin/env python import argparse import os import server parser = argparse.ArgumentParser(description='Run a buildr server.') parser.add_argument('--root', dest='root', default='.', help='path for root of server') parser.add_argument('--port', dest='port', default='8765', help='port to run server on') parser.add_argument('--expose', dest='expose', action='store_true', help='Exose the server to the world?') parser.add_argument('--R', dest='R', default='', help='Path to Rscript (if not on $PATH)') args = parser.parse_args() host = "0.0.0.0" if args.expose else "127.0.0.1" R = args.R if args.R else None server.main(args.root, host, args.port, R)
def runServer(): import server server.main()
result = conn.sent if 'HTTP/1.0 200 OK' not in result: assert False else: pass def test_main(): fakemodule = FakeSocketModule() sys.argv[1] = '-A' sys.argv.append('myapp') success = False try: server.main(fakemodule) except AcceptCalledMultipleTimes: success = True pass assert success, "Something went wrong" class AcceptCalledMultipleTimes(Exception): pass class FakeSocketModule(object): def getfqdn(self): return "fakehost" def socket(self): return FakeConnection("")
#!/usr/bin/env python import os import sys if len(sys.argv) != (1 + 1): raise RuntimeError( 'init.py should be ran with one arg DGRAM or SOCK_STREAM' ) #host = '' settings = { 'host' : '127.0.0.1', 'port' : 3444, 'mode' : sys.argv[1] } if os.fork(): import server server.main(settings) else: import client client.main(settings)
print('proces') host = socket.gethostbyname(socket.getfqdn()) host = host.split('.') print(host) if '192' in host: break code = host[-1] code = list(code) for i, c in enumerate(code): code[i] = chr(int(c) + 65) code = ''.join(code) Display.displayServerCode(code) t = threading.Thread(target=Display.loading) Display.LOADING = True t.start() server.main(players) Display.LOADING = False print('all the players are connected.') Display.bootUp() elif select == 1: CODE = Display.getText('enter the code') IP = '192.168.1.' CODE = list(CODE) for i, c in enumerate(CODE): CODE[i] = str(ord(CODE[i]) - 65) CODE = ''.join(CODE) CODE.replace(' ', '') IP += CODE client.main(IP) elif select == 2: #code for displaying help
# Copyright (C) Jean-Paul Calderone # See LICENSE for details. if __name__ == '__main__': import server raise SystemExit(server.main()) from sys import stdout from socket import SOL_SOCKET, SO_REUSEADDR, socket from OpenSSL.crypto import FILETYPE_PEM, load_privatekey, load_certificate from OpenSSL.SSL import TLSv1_METHOD, Context, Connection def load(domain): crt = open(domain + ".crt") key = open(domain + ".key") result = (load_privatekey(FILETYPE_PEM, key.read()), load_certificate(FILETYPE_PEM, crt.read())) crt.close() key.close() return result def main(): """ Run an SNI-enabled server which selects between a few certificates in a C{dict} based on the handshake request it receives from a client. """ port = socket() port.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
import sys import server server.main([], sys.stdout);
def main(): server.main(settings.project_settings)
seed-hosts= with -H, use these hostnames for initial scan (comma-separated) noserver don't use a separate server process (mostly for debugging) server [internal use only] firewall [internal use only] hostwatch [internal use only] """ o = options.Options('sshuttle', optspec) (opt, flags, extra) = o.parse(sys.argv[1:]) helpers.verbose = opt.verbose try: if opt.server: if len(extra) != 0: o.fatal('no arguments expected') sys.exit(server.main()) elif opt.firewall: if len(extra) != 1: o.fatal('exactly one argument expected') sys.exit(firewall.main(int(extra[0]))) elif opt.hostwatch: sys.exit(hostwatch.hw_main(extra)) else: if len(extra) < 1 and not opt.auto_nets: o.fatal('at least one subnet (or -N) expected') remotename = opt.remote if remotename == '' or remotename == '-': remotename = None if opt.seed_hosts and not opt.auto_hosts: o.fatal('--seed-hosts only works if you also use -H') if opt.seed_hosts:
#!/usr/bin/python2 # ____ _____ ___ ___ # | \ ___ ___ _ _ _| __ |___ _ _ _ ___ |_ | | | # | | | _| .'| | | | -| .'| | | | _| | _|_| | | # |____/|_| |__,|_____|__|__|__,|_____|_| |___|_|___| # ------------ A social website for artists ------------ __version__ = '2.0' __author__ = 'Josh Thomas' import server as server import os, sys from optparse import OptionParser parser = OptionParser() parser.add_option("-q", "--quiet", action="store_false", dest="verbose", default=True, help="Silence all output from DrawRawr") # Run Server if __name__ == "__main__": server.main() else: print("DrawRawr isn't a module, silly.")
from server import main main()
#!/usr/bin/env python # _______ _______ _______ _______ __ __ ___ _______ _______ # | || _ || || || | | || | | || | # | || |_| ||_ _|| ___|| | | || | | || ___| # | || | | | | | __ | |_| || | | || |___ # | _|| | | | | || || || | | _|| ___| # | |_ | _ | | | | |_| || || | | |_ | |___ # |_______||__| |__| |___| |_______||_______||___| |_______||_______| # --------- A Website For the Purchase of Excellent Things ------------ # # Coded by Josh Thomas <*****@*****.**> # Currated & Owned by Catherine Kern <*****@*****.**> # import server as server import os, sys __author__ = "Josh Thomas" __credits__ = ["Josh Thomas", "Catherine Kern"] __license__ = "GPL" __version__ = "0.1" __maintainer__ = "Josh Thomas" __contact__ = "http://github.com/lambdanaut" __email__ = "*****@*****.**" __status__ = "Development" if __name__ == "__main__": server.main()
def hello(): main() return "server closed"
def testException(self): try : server.main(['-p', 'asdgf']) except ValueError: pass
def cli(): kwargs = docopt(__doc__) port = kwargs['<port>'] main(port)
o = options.Options(optspec) (opt, flags, extra) = o.parse(sys.argv[2:]) if opt.daemon: opt.syslog = 1 if opt.wrap: import ssnet ssnet.MAX_CHANNEL = int(opt.wrap) helpers.verbose = opt.verbose try: if opt.server: if len(extra) != 0: o.fatal('no arguments expected') server.latency_control = opt.latency_control sys.exit(server.main()) elif opt.firewall: if len(extra) != 6: o.fatal('exactly six arguments expected') sys.exit( firewall.main(int(extra[0]), int(extra[1]), int(extra[2]), int(extra[3]), extra[4], int(extra[5]), opt.syslog)) elif opt.hostwatch: sys.exit(hostwatch.hw_main(extra)) else: if len(extra) < 1 and not opt.auto_nets and not opt.subnets: o.fatal('at least one subnet, subnet file, or -N expected') includes = extra excludes = ['127.0.0.0/8'] for k, v in flags: if k in ('-x', '--exclude'):
def conectarServer(self): server.main()
logger = logging.getLogger(__name__) # Set the log level to LOG_LEVEL logger.setLevel(LOG_LEVEL) # Make a handler that writes to a file, making a new file at midnight and keeping 3 backups handler = logging.handlers.TimedRotatingFileHandler(LOG_FILENAME, when="midnight", backupCount=3) # Format each log message like this formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(message)s') # Attach the formatter to the handler handler.setFormatter(formatter) # Attach the handler to the logger logger.addHandler(handler) # Make a class we can use to capture stdout and sterr in the log class MyLogger(object): def __init__(self, logger, level): """Needs a logger and a logger level.""" self.logger = logger self.level = level def write(self, message): # Only log if there is a message (not just a new line) if message.rstrip() != "": self.logger.log(self.level, message.rstrip()) # Replace stdout with logging to file at INFO level sys.stdout = MyLogger(logger, logging.INFO) # Replace stderr with logging to file at ERROR level sys.stderr = MyLogger(logger, logging.ERROR) server.main()