def main():
"""
Start the logging example.
Set up the console logger and then find a device to gather
data from. If anything goes wrong, try to re-estable a
connection to let the log continue.
An address may be explicitly provided on the command-line, or
if none is given the program will scan for devices.
"""
backend = LogBackend()
console_log = ConsoleLogger(backend)
console_thread = Thread(target = console_log.spin, daemon=True)
console_thread.start()
# Set up logging to the GMC.MAP service. Be sure to fill in the IDs!
#gmc_log = GmcmapLogger(backend, "--ID--", "--ID--")
#gmc_thread = Thread(target = gmc_log.spin, daemon=True)
#gmc_thread.start()
# Set up logging to the Radmon service. Be sure to fill in the user/pass!
#radmon_log = RadmonLogger(backend, "--USER--", "--PASSWORD--")
#radmon_thread = Thread(target = radmon_log.spin, daemon=True)
#radmon_thread.start()
# Keep attempting to reconnect if anything goes wrong
while True:
if len(sys.argv) == 1:
address = find_any()
else:
address = sys.argv[1]
spin(address, backend)
def main():
args = _arg_parser_factory().parse_args()
msg: str = args.msg
use_udp: bool = args.udp
host: str = args.host
port: int = args.port
coder = Base85Coder()
logger = ConsoleLogger()
# create socket
if use_udp:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sender = UDPSender(sock, (host, port), coder)
reader = UDPReader(sock, coder)
else:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
sender = TCPSender(sock, coder)
reader = TCPReader(sock, coder)
sender.send(b'')
sender.send(b'msg:' + msg.encode())
for line in reader.read():
logger.log(line.decode())
reader.close()
def lambda_handler(event, context):
dbPers = DBPersistence("config.yaml")
twlogger = ConsoleLogger()
#TweetLogger("config.yaml")
logic = Logic(dbPers, twlogger)
while (logic.IsGameFinished() is not True):
logic.Update()
else:
print("Game already finished")
return 200
def main():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
args = _arg_parser_factory().parse_args()
file_path = Path(args.file)
host = args.host
port = args.port
sock.connect((host, port))
logger: Logger = ConsoleLogger()
coder = Base85Coder()
sender = TCPSender(sock, coder)
reader = TCPReader(sock, coder)
if not file_path.exists():
logger.error(f'{str(file_path)} is not exists.')
exit(-1)
if file_path.is_file():
files = [file_path]
base_path = file_path.parent
else:
files = list(file_path.glob('./**/*.*'))
base_path = file_path
file_sender = FileSender(sender)
# show all the files
logger.log('The following files will be uploaded:')
for file in files:
logger.log(str(file))
proceed = input('proceed?(y/N):').lower() == 'y'
if not proceed:
logger.info('Operation stopped by user.')
exit(0)
for file in files:
file_sender.send_file(file, base_path)
file_sender.close()
for response in reader.read():
if response == b'ok':
logger.info('All file transmission has been done.')
elif response.startswith(b'error'):
logger.error(response.decode())
else:
logger.error('Unknown error occurred.')
reader.close()
def __init__(self, verbosity=0, max_tasks=512):
"""Constructor.
Args:
verbosity: set output verbosity: 0 (default) is none, 3 is debug
max_tasks: the maximum number of tasks asyncio will queue (default 512)
"""
self.tasks = []
self.errors = []
self.fqdn = []
self.ignore_hosts = []
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
self.loop = asyncio.get_event_loop()
self.resolver = aiodns.DNSResolver(loop=self.loop, rotate=True)
self.sem = asyncio.BoundedSemaphore(max_tasks)
self.max_tasks = max_tasks
self.verbosity = verbosity
self.logger = ConsoleLogger(verbosity)
class Main:
logger: Logger = ConsoleLogger()
def main(self):
args = self._arg_parser_factory().parse_args()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = '' # all interfaces are available
port = args.port
backlog = args.backlog
save = Path(args.save_to)
sock.bind((host, port))
sock.listen(backlog)
self.logger.log(f'Server is on. port={port}')
if args.debug:
self.logger.debug('Debugging mode is on.')
else:
self.logger.disable(LogType.debug)
while True:
self.recv_client(sock, save)
@staticmethod
def recv_client(sock: socket.socket, save: Path) -> threading.Thread:
client, address = sock.accept()
Main.logger.info(f"connection established from {address}.")
t = ThreadingFileReceiver(client, save / f'{time()}{address}',
Main.logger)
t.start()
return t
@staticmethod
def _arg_parser_factory():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--port', type=int, default=8686)
parser.add_argument('-b', '--backlog', type=int, default=10)
parser.add_argument('-s', '--save_to', type=str, default='./download')
parser.add_argument('-d',
'--debug',
default=False,
action='store_true')
return parser
from flask import Flask, jsonify, abort
from config_class import Config
from logger import FileLogger, ConsoleLogger
from collector import DbHandler
config = Config()
# get db name from yaml file
db_name = config.db['db_name']
file_logger = FileLogger()
console_logger = ConsoleLogger()
db_handler = DbHandler(db_name=db_name, index_list='')
app = Flask(__name__)
# get_collections
@app.route('/api/indices', methods=['GET'])
def get_collections():
return jsonify({'collections': db_handler.get_db_collections()})
# get_by_collection_name
@app.route('/api/index/<index>', methods=['GET'])
def get_collection_data(index):
is_index_exist(index)
return jsonify({'results': db_handler.get_collection_data(index)})
# get_last_entry_from_collection
@app.route('/api/index/<index>/last', methods=['GET'])
try:
subprocess.check_call(args + [INTERPRETER_AUTODETECTION_FLAG],
stdout=stdout,
stderr=STDOUT)
except CalledProcessError:
continue
if INTERPRETER_AUTODETECTION_VERBOSE_FLAG in sys.argv or ALL_AUTODETECTION_VERSION_FLAG in sys.argv:
print('Re-launching using command line: ' + ' '.join(args))
os.execv(args[0], args)
print(
'Error: One or more required python libraries have not been installed: '
+ str(e))
sys.exit(1)
if not autodetecting:
logger.register(ConsoleLogger())
logger.register(FileLogger())
if EXECUTABLE_AUTODETECTION_VERSION_FLAG in sys.argv or ALL_AUTODETECTION_VERSION_FLAG in sys.argv:
import detect
detect.VERBOSE_DETECT = True
try:
PaladinLinuxClient().run(
mask_exceptions=(not EXCEPTION_BACKTRACE_FLAG in sys.argv and
not ALL_EXCEPTIONS_BACKTRACE_FLAG in sys.argv),
handle_errors=(not ALL_EXCEPTIONS_BACKTRACE_FLAG in sys.argv))
except KeyboardInterrupt as e:
print('')
sys.exit(1)
finally:
__all__ = [
'config',
'model_config',
'machine',
'MachineType'
]
from os.path import dirname, abspath, join, exists
from enum import Enum, auto
import socket
import yaml
from easydict import EasyDict as edict
from logger import ConsoleLogger
from utils.io import ensure_dir, ROOT_DIR
_LOGGER = ConsoleLogger('Config')
class MachineType(Enum):
"""Machine type"""
LOCAL = auto()
AWS = auto()
def load_config() -> dict:
"""Load configuration file
Returns:
dict: dictionary with project configuration information
"""
def main():
args = _arg_parser_factory().parse_args()
host = args.host
port = args.port
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
logger = ConsoleLogger()
coder = Base85Coder()
reader = TCPReader(sock, coder)
sender = TCPSender(sock, coder)
logger.info('Connected to chat server...')
file = show_messages()
msg_receiver = ThreadingMessageReceiver(file, reader)
msg_receiver.start()
closed = False
while not closed and not sock.__getattribute__('_closed'):
try:
data = input('>> ')
if data.startswith('/'):
data = data[1:]
if data == 'login':
command = _login()
elif data == 'register':
command = _register()
elif data == 'logout':
command = _logout()
elif data == 'create':
command = _create()
elif data == 'join':
command = _join()
elif data == 'leave':
command = _leave()
elif data == 'close':
command = _close()
else:
logger.error('unknown command.')
raise Exception()
msg_receiver.command(data)
else:
command = _message(data)
msg_receiver.message(data)
msg_receiver.command('message')
invoker = CommandInvoker()
invoker.store_command(command)
request = invoker.serialize().encode()
sender.send(request)
if isinstance(command, Close):
sock.close()
except Exception as e:
if str(e) != '':
print(str(e))
exit()
def __init__(self):
self.logger = ConsoleLogger()
self.nickname = config['nickname']
self.password = config['password']
self.lineRate = 0.67