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