#!/usr/bin/env python3.5 # Copyright 2017 Digital # # This file is part of BeeWatch. # # BeeWatch is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # BeeWatch is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with BeeWatch. If not, see . # import argparse import gi gi.require_version('Notify', '0.7') from gi.repository import Notify import logging import logging.config import logging.handlers import sys import mylibnetwork import threading import socket import traceback import time import yaml import beewatch # import beewatch.server as beeserver import beewatch.server parser = argparse.ArgumentParser( # usage="use this to play", description="BeeWatch Server", ) parser.add_argument( "host", type=str, help="hostname/ip address/filename (only if --use-file was specified)" ) parser.add_argument( "port", type=int, default=80540, nargs="?", help="the port on wich the connection will open up. ignored if --use-file \ is given" ) parser.add_argument( "-d","--debug", default=False, action="store_true", help="enables logging" ) group_af_family = parser.add_mutually_exclusive_group() group_af_family.add_argument( "-u","--af-unix", dest="af_family", # default=False, action="store_const", const="AF_UNIX", help="""use an AF_UNIX socket (a file). can't be used in combination with --af-inet.""" # " will be used \ # instead of an AF_INET socket (hostname/ip address + port)." ) group_af_family.add_argument( "-i","--af_inet", default="AF_INET", dest="af_family", action="store_const", const="AF_INET", help="""use an AF_INET socket (hostname/ip address + port). can't be used with --af-unix""" # (hostname/ip address + port) will be used instead of an AF_INET \ # socket (a file)." ) args = parser.parse_args() print(args) if args.debug: with open("bee_logging.yaml") as f: data = f.read() config = yaml.safe_load(data) logging.config.dictConfig(config) if args.af_family == "AF_UNIX": port = None elif args.af_family == "AF_INET": port = args.port bee_server = beewatch.server.BeeWatchServer( host=args.host, port=args.port, af_family=args.af_family, ) # bee_api = beeserver.BeeAPI() # s = mylibnetwork.Server( # host=args.host, # port=port, # handler=beeserver.ConnHandlerBeeWatch, # handler_kwargs={"bee_api":bee_api} # ) bee_server.run() try: while True: try: if bee_server.is_alive(): bee_server.join(1) else: break except Exception as e: log.warn("an error occured, aborting") log.error(e, exc_info=True) bee_server.stop() break except KeyboardInterrupt: print("\r ", end="\r") logging.warn("keyboardinterrupt! aborting!") bee_server.stop() sys.exit() log = logging.getLogger(__name__+".server") logc = logging.getLogger(__name__+".chat") Notify.init("Bee Watch Server") # # class ConnHandlerBeeWatch(mylibnetwork.ConnHandlerBase): # def __init__(self, socket, addr, server, action=None): # self.status = "init" # self.super_class = super(ConnHandlerBeeWatch, self) # self.super_class.__init__(socket, addr, server) # logc.info('hey') # self.server = server # self.address = addr # self.action=action # self.command_to_function={ # "set_speed":self.action.c.movement_control.set_speed, # "mod_speed":self.action.c.movement_control.change_speed, # "get_speed":self.speedcheck, # "print":self.echo, # "None":None, # } # def welcome_client(self): # self.send("this is the server speaking, hello new client!") # def handle(self, data_decoded): # data_decoded=data_decoded.strip() # logc.info("Client:"+data_decoded) # if data_decoded.find(" ") != -1: # cmd=data_decoded.split()[0] # args=data_decoded.split()[1:] # else: # cmd=data_decoded # args=() # kwargs={} # if cmd in self.command_to_function.keys(): # try: # # self.respond(str(args)) # self.command_to_function[cmd](respond_method=self.respond,*args) # except: # tb = traceback.format_exc() # print(tb) # self.respond(tb) # # for line in tb.split('\n'): # # self.respond(line) # # # print(line) # # # time.sleep(0.001) # # time.sleep(0.1) # # # if line != "\n" # else: # self.respond("Unknown command") # # Notify.Notification.new( # # self.address[0]+" ("+self.server.host+":"+str(self.server.port)+")", # # data_decoded # # ).show() # def echo(self,*args,**kwargs): # logc.info(str(args)) # logc.info(str(kwargs)) # def speedcheck(self,respond_method): # left_speed=str(self.action.c.movement_control.get_speed("left")) # right_speed=str(self.action.c.movement_control.get_speed("right")) # result = "left: "+left_speed+", right: "+right_speed # logc.info(result) # self.respond(result) # def respond(self,text,*args): # self.send(text) # # # logging.basicConfig( # # format = myLogger.fmt + " {process:^^20}", # # datefmt = myLogger.datefmt, # # style = "{", # # level = logging.DEBUG, # # handlers = [ # # myLogger.logHandler_console, # # ] # # ) # # logger_server = logging.getLogger("server") # # logger_server.propagate = False # # logHandler_server_file = logging.handlers.WatchedFileHandler(filename="logs/server.log") # # logHandler_server_file.setFormatter(myLogger.logFormatter) # # logHandler_server_file.setLevel(level=logging.DEBUG) # # logger_server.addHandler(myLogger.logHandler_console) # # logger_server.addHandler(logHandler_server_file) # # logger_beewatch = logging.getLogger("BeeWatch") # # logger_beewatch.propagate = False # # logHandler_beewatch_file = logging.handlers.WatchedFileHandler(filename="logs/beeserver.log") # # logHandler_beewatch_file.setFormatter(myLogger.logFormatter) # # logHandler_beewatch_file.setLevel(level=logging.DEBUG) # # logger_beewatch.addHandler(myLogger.logHandler_console) # # logger_beewatch.addHandler(logHandler_beewatch_file) # # # action=beeserver.BoatAction() # boat_movement=beeserver.BoatMovement(action.boat_api) # action.add_component("movement_control",boat_movement) # # engine_left=beeserver.Engine(logger_beewatch,action,{"name":"engine_left"}) # # engine_right=beeserver.Engine(logger_beewatch,action,{"name":"engine_right"}) # # action.add_component("engine_left",engine_left) # # action.add_component("engine_right",engine_right) # argv_dict = dict(zip(range(0,len(sys.argv)),sys.argv)) # port = argv_dict.get(2,None) # if port != None: # port = int(port) # s = mylibnetwork.Server( # host=sys.argv[1], # port=port, # handler=ConnHandlerBeeWatch, # handler_kwargs={"action":action} # ) # bee_server.run() # while True: # try: # # print("".join(myLogger.list_stream)) # if bee_server.is_alive(): # bee_server.join(1) # else: # break # except KeyboardInterrupt: # print("\r ", end="\r") # logging.warn("keyboardinterrupt! aborting!") # bee_server.stop() # break # except Exception as e: # log.warn("an error occured, aborting") # log.error(e, exc_info=True) # bee_server.stop() # break