BeeWatch/server.py

#!/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 <http://www.gnu.org/licenses/>.
#

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