Exemple #1
0
class TcpServerComp(object):
    """Component TCP/IP server.

    Attributes
    ----------
    server_cmd : TcpServer
        Server of the command and event.
    server_tel : TcpServer
        Server of the telemetry.
    """
    def __init__(self):

        self.server_cmd = TcpServer()
        self.server_tel = TcpServer()

    async def main(self, ip_addr, port_cmd, port_tel):
        """Main function.

        Parameters
        ----------
        ip_addr : str
            IP address.
        port_cmd : int
            Port of command to connect.
        port_tel : int
            Port of telemetry to connect.
        """

        await asyncio.gather(
            self.server_cmd.main(ip_addr, port_cmd, MsgType.CMDEVL),
            self.server_tel.main(ip_addr, port_tel, MsgType.TEL),
        )
Exemple #2
0
    def __init__(self):
        super().__init__()

        self.read_config_json()
        self.setupUi(self)

        self.setup_new_game()

        self.tcpServer = TcpServer(1234, self.gotTcpServerData)
        self.tcpClient = TcpClient(1234, self.gotTcpClientData)

        self.tablica_1.enable(False)

        self.dlgGraczSieciowyA = None

        #self.setCentralWidget(self.tablica_1)
        #self.setCentralWidget(self.tablica_2)

        #self.setCentralWidget(self.centralwidget)

        # greenBrush = QBrush(Qt.green)
        # blueBrush = QBrush(Qt.blue)
        # blackPen = QPen(Qt.black)
        # blackPen.setWidth(5)

        self.new_game_button.clicked.connect(self.new_game)
        self.save_button.clicked.connect(self.save_state)
        self.load_button.clicked.connect(self.load_state)
        self.exit_button.clicked.connect(sys.exit)
        self.btReplay.clicked.connect(self.start_animation)
        self.undo_button.clicked.connect(self.undo)

        # self.exit_button.clicked.connect(sys.exit)
        # self.save_button.clicked.connect(self.plansza.save_state)
        # self.load_button.clicked.connect(self.plansza.load_state)

        # for x in range (rozmiarPlanszy) :
        #     for y in range(rozmiarPlanszy):
        #         hex = Hexagon(scene, x, y, size)
        #         pola.append([hex, x, y])

        #self.graphicsView_1.setScene(self.scene)

        # self.view = QGraphicsView(self.scene, self)
        # self.view.setGeometry(0, 0, 640, 520)
        # self.setWindowTitle("nazwa")
        # self.setGeometry(300, 200, 640, 520)    # (położenie okna x, położenie okna y, szerokość, wysokość)

        self.typGry = 0
        self.updateTypGry()
        self.show()

        self.animationStep = -1
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.timer_tick)
        self.timer.start(1000)
Exemple #3
0
def main():
    # main function
    kafkaClient = None
    tcpServer = None

    try:
        if confBox.getKafkaServerAddress(
        ) != "" and confBox.getKafkaServerPort() != 0:
            kafkaClient = KafkaClient(confBox.getKafkaServerAddress(),
                                      confBox.getKafkaServerPort(),
                                      confBox.getKafkaServerTopic())
            kafkaClient.start()
        if confBox.getTcpServerAddress() != "" and confBox.getTcpServerPort(
        ) != 0:
            tcpServer = TcpServer( confBox.getTcpServerAddress(), \
                confBox.getTcpServerPort() )
            tcpServer.start()
    except Exception as e:
        logger.error(e)
        if kafkaClient != None:
            kafkaClient.stop()
        if tcpServer != None:
            tcpServer.stop()
        sys.exit(1)

    if kafkaClient != None:
        kafkaClient.join()
    if tcpServer != None:
        tcpServer.join()
Exemple #4
0
 def __init__(self, port=1234, clear_users=True):
     Thread.__init__(self)
     self.users = []
     self.active_users = {}
     self.tcp_server = TcpServer(port, self)
     self.tcp_server.start()
     self.is_listening = True
     self.accepted_img_formats = ['png', 'jpg', 'jpeg']
     try:
         os.mkdir('users')
     except FileExistsError:
         if clear_users:
             shutil.rmtree('users')
             os.mkdir('users')
Exemple #5
0
    class FanEntity(Agent):
        def __init__(self, **kwargs):
            super(FanEntity, self).__init__(**kwargs)

            self.speed = 'slow'
            self.tcpServer = TcpServer(config.get('port'), self)
            Thread(target=self.tcpServer.startServer).start()

        def process_data(self, msg):
            components = msg.split('&')
            data = {}
            # Extract individual fields from the message and create to dictionary for publishing
            for component in components:
                if '=' in component:
                    (key, value) = component.split('=')
                    data.update({key: value})
            self.status_push(data)

        @Core.periodic(settings.HEARTBEAT_PERIOD)
        def publish_status(self):
          self.status_push({'speed': self.speed})

        def status_push(self, data):
            prefix = settings.TYPE_PREFIX + '/' + AGENT_ID + '/data'
            headers = {
                headers_mod.FROM: AGENT_ID,
                headers_mod.CONTENT_TYPE: headers_mod.CONTENT_TYPE.JSON,
                headers_mod.DATE: datetime.datetime.today().isoformat(),
                "Location": config.get('location')
            }
            self.publish_all(data, prefix, headers)
            _log.debug("publishing status: %s", str(data))
 
        def publish_all(self, data, prefix, headers):
            for item in data.keys():
                topic = prefix + '/' + item
                self.vip.pubsub.publish('pubsub', topic, headers, jsonapi.dumps(data[item]))

        def set_speed(self, speed):
            self.speed = speed
            if self.tcpServer.isClientConnected():
                self.tcpServer.sendData("speed={value}".format(value=SPEED_MAPPINGS[speed]))

        @PubSub.subscribe('pubsub', settings.TYPE_PREFIX + '/' + AGENT_ID + '/operations/speed')
        def on_set_speed(self, peer, sender, bus, topic, headers, message):
            print 'Fan Entity got\nTopic: {topic}, {headers}, Message: {message}'.format(topic=topic, headers=headers, message=message)
            self.set_speed(jsonapi.loads(message))
Exemple #6
0
    def __init__(self):

        self.server_cmd = TcpServer()
        self.server_tel = TcpServer()
Exemple #7
0
class Server(Thread):
    def __init__(self, port=1234, clear_users=True):
        Thread.__init__(self)
        self.users = []
        self.active_users = {}
        self.tcp_server = TcpServer(port, self)
        self.tcp_server.start()
        self.is_listening = True
        self.accepted_img_formats = ['png', 'jpg', 'jpeg']
        try:
            os.mkdir('users')
        except FileExistsError:
            if clear_users:
                shutil.rmtree('users')
                os.mkdir('users')

    def run(self):
        while self.is_listening:
            pass
        self.tcp_server.is_listening = False

    def get_user_by_id(self, user_id):
        if user_id >= len(self.users):
            raise exception.NonExistingUser
        return self.users[user_id]

    def get_post_by_id(self, post_id):
        user = self.get_user_by_id(int(post_id / lpn))
        if post_id % lpn >= len(user.posts):
            raise exception.NonExistingPost
        return user.posts[post_id % lpn]

    def generate_salt(self, string_length=10):
        components = string.ascii_letters + string.digits + string.punctuation
        ans = ''
        for i in range(string_length):
            ans = ans + random.choice(components)
        return ans

    def register(self, username, password):
        for user in self.users:
            if user.username == username:
                raise exception.UsedUsername
        new_user = User(username, password, len(self.users), self)
        self.users.append(new_user)

    def login(self, username, password, ip):
        for user in self.users:
            if user.username == username:
                if user.generate_hash(password) == user.password_hash:
                    self.active_users[ip] = user
                    return
                raise exception.IncorrectLogin
        raise exception.IncorrectLogin

    def like(self, post_id, ip):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        self.active_users[ip].like(post_id)

    def send_friend_request(self, ip, target_id):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        self.active_users[ip].send_friend_request(target_id)

    def accept_friend_request(self, ip, fr_index):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        self.active_users[ip].accept_friend_request(fr_index)

    def deny_friend_request(self, ip, fr_index):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        self.active_users[ip].deny_friend_request(fr_index)

    def begin_post(self, caption, file_format, addr):
        ip = addr[0]
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        if file_format not in self.accepted_img_formats:
            raise exception.NotSupportedFormat
        return self.active_users[ip].begin_post(caption, file_format, addr)

    def request_post(self, number, addr):
        ip = addr[0]
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        return self.active_users[ip].request_post(number, addr)

    def number_of_posts(self, ip):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        return self.active_users[ip].number_of_posts()

    def number_of_friend_requests(self, ip):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        return self.active_users[ip].number_of_friend_requests()

    def get_fr(self, position, ip):
        if ip not in self.active_users:
            raise exception.NotLoggedIn
        return self.active_users[ip].get_fr(position)
Exemple #8
0
        def __init__(self, **kwargs):
            super(FanEntity, self).__init__(**kwargs)

            self.speed = 'slow'
            self.tcpServer = TcpServer(config.get('port'), self)
            Thread(target=self.tcpServer.startServer).start()
Exemple #9
0
class Window(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()

        self.read_config_json()
        self.setupUi(self)

        self.setup_new_game()

        self.tcpServer = TcpServer(1234, self.gotTcpServerData)
        self.tcpClient = TcpClient(1234, self.gotTcpClientData)

        self.tablica_1.enable(False)

        self.dlgGraczSieciowyA = None

        #self.setCentralWidget(self.tablica_1)
        #self.setCentralWidget(self.tablica_2)

        #self.setCentralWidget(self.centralwidget)

        # greenBrush = QBrush(Qt.green)
        # blueBrush = QBrush(Qt.blue)
        # blackPen = QPen(Qt.black)
        # blackPen.setWidth(5)

        self.new_game_button.clicked.connect(self.new_game)
        self.save_button.clicked.connect(self.save_state)
        self.load_button.clicked.connect(self.load_state)
        self.exit_button.clicked.connect(sys.exit)
        self.btReplay.clicked.connect(self.start_animation)
        self.undo_button.clicked.connect(self.undo)

        # self.exit_button.clicked.connect(sys.exit)
        # self.save_button.clicked.connect(self.plansza.save_state)
        # self.load_button.clicked.connect(self.plansza.load_state)

        # for x in range (rozmiarPlanszy) :
        #     for y in range(rozmiarPlanszy):
        #         hex = Hexagon(scene, x, y, size)
        #         pola.append([hex, x, y])

        #self.graphicsView_1.setScene(self.scene)

        # self.view = QGraphicsView(self.scene, self)
        # self.view.setGeometry(0, 0, 640, 520)
        # self.setWindowTitle("nazwa")
        # self.setGeometry(300, 200, 640, 520)    # (położenie okna x, położenie okna y, szerokość, wysokość)

        self.typGry = 0
        self.updateTypGry()
        self.show()

        self.animationStep = -1
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.timer_tick)
        self.timer.start(1000)

    def setup_new_game(self):
        self.tablica_1 = Ui_Form(self.wymiar, "Gracz A:", "A", self)
        self.tablica_2 = Ui_Form(self.wymiar, "Gracz B:", "B", self)
        self.tablica_1.setupUi(self, 0)
        self.tablica_2.setupUi(self, 400)

        self.history = []
        self.history.clear()
        self.add_to_history()

    def update_step_info(self, p1, p2):
        self.lbStepInfo.setText(str(p1) + "/" + str(p2))

    def add_to_history(self):
        self.history.append([
            self.tablica_1.plansza.get_pola_copy(),
            self.tablica_2.plansza.get_pola_copy()
        ])
        self.update_step_info(len(self.history), len(self.history))

    def movement(self, idGracza, typRuchu):
        print(idGracza, ":", typRuchu)

        self.add_to_history()

        if self.typGry == 0 or self.typGry == 1:
            return

        self.tablica_1.enable(idGracza == "B")
        self.tablica_2.enable(idGracza == "A")

    def print(self, color, msg):
        print(color[0] + msg + Colors.ENDC[0])
        self.teLog.append(color[1] + msg)
        return

    def keyPressEvent(self, event):

        if event.key() == Qt.Key_Q:
            self.plansza.moveNWFull()
        if event.key() == Qt.Key_E:
            self.plansza.moveNEFull()
        if event.key() == Qt.Key_A:
            self.plansza.moveWFull()
        if event.key() == Qt.Key_D:
            self.plansza.moveEFull()
        if event.key() == Qt.Key_Z:
            self.plansza.moveSWFull()
        if event.key() == Qt.Key_C:
            self.plansza.moveSEFull()
        if event.key() == Qt.Key_N:
            self.plansza.new_game()

        if event.key() == Qt.Key_P:
            self.plansza.save_state()
        if event.key() == Qt.Key_L:
            self.plansza.load_state()

    def mousePressEvent(self, event: PySide2.QtGui.QMouseEvent) -> None:
        super().mousePressEvent(event)
        self.tablica_1.mouse_pressed(event.x(), event.y())
        self.tablica_2.mouse_pressed(event.x(), event.y())

    def mouseReleaseEvent(self, event: PySide2.QtGui.QMouseEvent) -> None:
        super().mouseReleaseEvent(event)
        self.tablica_1.mouse_released(event.x(), event.y())
        self.tablica_2.mouse_released(event.x(), event.y())

    def gotTcpClientData(self, data):
        return

    def gotTcpServerData(self, data):
        print("gotTcpServerData:", data)
        if self.dlgGraczSieciowyA != None:
            self.dlgGraczSieciowyA.close()
        self.tablica_1.enable(True)

    def updateTypGry(self):
        self.tablica_1.enable(False)
        self.tablica_2.enable(False)
        if self.typGry == 1:
            self.tablica_1.enable(True)
        elif self.typGry == 2:
            self.tablica_1.enable(True)
            self.tablica_2.enable(True)
        elif self.typGry == 3:
            self.tcpServer.startListen()
            self.dlgGraczSieciowyA = GraczSieciowyADlg()
            self.dlgGraczSieciowyA.exec()
            self.dlgGraczSieciowyA = None
            #self.tablica_1.enable(True)

    def save_config_json(self, wymiar):
        configObj = Config()
        configObj.wymiar = wymiar
        text_file = open("config.json", "w")
        text_file.write(configObj.toJSON())
        text_file.close()

    def read_config_json(self):
        try:
            text_file = open("config.json", "r")
            json_str = text_file.read()
            #print(json_str)
            text_file.close()
            self.wymiar = int(re.sub("[^0-9]", "", json_str))
        except:
            print("nie udało się odczytać konfiguacji")
            self.wymiar = 3

    def new_game(self):
        dlgWyborGryDlg = WyborGryDlg(self)
        dlgWyborGryDlg.exec()
        self.typGry = dlgWyborGryDlg.typGry
        self.wymiar = dlgWyborGryDlg.wymiar()

        self.save_config_json(self.wymiar)

        self.updateTypGry()
        self.tablica_1.new_game(self.wymiar)
        self.tablica_2.new_game(self.wymiar)

        self.history = []
        self.history.clear()
        self.add_to_history()

    def save_state(self):
        root = tk.Tk()
        root.withdraw()

        file = filedialog.asksaveasfile(filetypes=[("Xml files", "*.xml")])

        xml_doc = ET.Element('root')
        product = ET.SubElement(xml_doc, 'wymiar').text = str(self.wymiar)
        product = ET.SubElement(xml_doc, 'tableAEnabled').text = str(
            self.tablica_1.enabled)
        product = ET.SubElement(xml_doc, 'tableBEnabled').text = str(
            self.tablica_2.enabled)
        product = ET.SubElement(xml_doc, 'typGry').text = str(self.typGry)
        product = ET.SubElement(xml_doc,
                                'saved_state').text = repr(self.history)

        tree = ET.ElementTree(xml_doc)
        tree.write(file.name, encoding='UTF-8', xml_declaration=True)
        # self.logFunction("\n"+self.print_prefix+"ZAPISANO")
        print("zapisano")

    def load_state(self):

        root = tk.Tk()
        root.withdraw()

        file_path = filedialog.askopenfilename(filetypes=[("Xml files",
                                                           "*.xml")])

        try:
            with open(file_path, 'rt') as f:
                fileContent = f.read()
                sets = re.findall(r'<wymiar>(.*)</wymiar>', fileContent)
                self.wymiar = int(sets[0])
                sets = re.findall(r'(\[.*\])', fileContent)
                self.history = ast.literal_eval(sets[0])
            self.print(Colors.RED, "wczytano plik :" + file_path)
            length = len(self.history)
            self.print(Colors.RED, "wczytano ruchów:" + str(length))

            sets = re.findall(r'<tableAEnabled>(.*)</tableAEnabled>',
                              fileContent)
            self.tablica_1.enable(sets[0] == "True")

            sets = re.findall(r'<tableBEnabled>(.*)</tableBEnabled>',
                              fileContent)
            self.tablica_2.enable(sets[0] == "True")

            sets = re.findall(r'<typGry>(.*)</typGry>', fileContent)
            self.typGry = int(sets[0])

            self.tablica_1.new_game(self.wymiar)
            self.tablica_2.new_game(self.wymiar)
            self.tablica_1.plansza.set_pola_copy(self.history[length - 1][0])
            self.tablica_2.plansza.set_pola_copy(self.history[length - 1][1])
            self.tablica_1.create_scene()
            self.tablica_2.create_scene()

            self.update_step_info(len(self.history), len(self.history))

        except:
            self.print(
                Colors.RED,
                "Plik z zapisaną grą nie został znaleziony lub błąd odczytu!")

    #
    #
    # def mouseReleaseEvent(self, event):
    #     #super(Window, self).mouseReleaseEvent(event)
    #     delta_y = event.y() - self.tempy
    #     delta_x = event.x() - self.tempx
    #     vect_len = math.sqrt(delta_x**2+delta_y**2)
    #     angle = 180 + math.atan2(delta_y, -delta_x) * 180 / math.pi
    #     margin = 20
    #     if vect_len > 40:
    #         if angle > 360 - margin or angle < 0 + margin:
    #             self.plansza.moveEFull()
    #         if 60 - margin < angle < 60 + margin:
    #             self.plansza.moveNEFull()
    #         if 120 - margin < angle < 120 + margin:
    #             self.plansza.moveNWFull()
    #         if 180 - margin < angle < 180 + margin:
    #             self.plansza.moveWFull()
    #         if 240 - margin < angle < 240 + margin:
    #             self.plansza.moveSWFull()
    #         if 300 - margin < angle < 300 + margin:
    #             self.plansza.moveSEFull()

    def update_screen_to_history_step(self, idx):
        self.tablica_1.plansza.set_pola_copy(self.history[idx][0])
        self.tablica_2.plansza.set_pola_copy(self.history[idx][1])
        self.tablica_1.create_scene()
        self.tablica_2.create_scene()
        self.update_step_info(idx + 1, len(self.history))

    def timer_tick(self):
        if self.animationStep == -1:
            return
        self.update_screen_to_history_step(self.animationStep)
        self.animationStep += 1
        if self.animationStep == len(self.history):
            print("AnimationStep2 ", self.animationStep)
            self.animationStep = -1
            self.update_step_info(len(self.history), len(self.history))

            self.tablica_1.enable(self.tablica1WasEnabled)
            self.tablica_2.enable(self.tablica2WasEnabled)

            self.new_game_button.setEnabled(True)
            self.save_button.setEnabled(True)
            self.load_button.setEnabled(True)
            self.undo_button.setEnabled(True)
            self.autoplay_button.setEnabled(True)

    def start_animation(self):
        self.tablica1WasEnabled = self.tablica_1.enabled
        self.tablica2WasEnabled = self.tablica_2.enabled

        self.tablica_1.enable(False)
        self.tablica_2.enable(False)

        self.new_game_button.setEnabled(False)
        self.save_button.setEnabled(False)
        self.load_button.setEnabled(False)
        self.undo_button.setEnabled(False)
        self.autoplay_button.setEnabled(False)

        self.animationStep = 0

    def undo(self):
        if len(self.history) > 1:
            self.history.remove(self.history[-1])
            self.update_screen_to_history_step(len(self.history) - 1)
            self.tablica_1.enable(not self.tablica_1.enabled)
            self.tablica_2.enable(not self.tablica_2.enabled)
            if len(self.history) == 1:
                self.tablica_1.enable(True)
                self.tablica_2.enable(True)