Пример #1
0
    def save_certificates(config_dict: dict) -> None:
        """
        Save AWS certificates to files.
        :param config_dict: dict with credentials.
        :return: None
        """
        global cfg
        logging.debug("save_certificates()")
        try:
            mkdir(CERTIFICATES_DIR)
        except:
            pass

        if 'cert_pem' in config_dict.keys():
            certificate_string = config_dict['cert_pem']
            cfg.cert_pem = config_dict['cert_pem']
            with open(CERTIFICATE_PATH, "w", encoding="utf8") as infile:
                infile.write(certificate_string)

        if 'priv_key' in config_dict.keys():
            private_key_string = config_dict['priv_key']
            cfg.private_key = config_dict['priv_key']
            logging.info(private_key_string)
            with open(KEY_PATH, "w", encoding="utf8") as infile:
                infile.write(private_key_string)

        if 'cert_ca' in config_dict.keys():
            ca_certificate_string = config_dict['cert_ca']
            cfg.cert_ca = config_dict['cert_ca']
            with open(CA_CERTIFICATE_PATH, "w", encoding="utf8") as infile:
                infile.write(ca_certificate_string)
Пример #2
0
    def authorization_request() -> str:
        """
        Register your ESP in cloud. It takes password and login from aws_config.json
        :return: JSON Web Token
        """
        global cfg
        logging.debug("Authorization request function")
        headers = DEFAULT_JSON_HEADER
        url = cfg.api_url + API_AUTHORIZATION_URL
        body = {}
        body['is_removed'] = True
        body['created_at'] = 0
        body['username'] = cfg.api_login
        body['password'] = cfg.api_password

        logging.debug('LOGIN: {}, password: {}'.format(cfg.api_login, cfg.api_password))

        body = ujson.dumps(body)
        try:
            response = urequests.post(url, data=body, headers=headers)
        except IndexError as e:
            logging.info("No internet connection: {}".format(e))
            return ""
        except Exception as e:
            logging.info("Failed to authorize in API {}".format(e))
            return ""

        if response.status_code != '200' and response.status_code != 200:
            logging.error(response.text)
            return ""

        response_dict = response.json()
        jwt_token = response_dict.get("data")
        return jwt_token
Пример #3
0
    def axis(self, directionUp, thenWait=0):

        if directionUp:
            if self.type == Motor.MOVE:
                self.signal.on(Pin.DEFAULT_FWD_AXIS_UP)
                self.signal.off(Pin.DEFAULT_FWD_AXIS_DWN)
            elif self.type == Motor.TURN:
                self.signal.on(Pin.DEFAULT_SIDES_AXIS_UP)
                self.signal.off(Pin.DEFAULT_SIDES_AXIS_DWN)
            else:
                RuntimeError("invalid motor definition: %s" % self.type)
        else:
            if self.type == Motor.MOVE:
                self.signal.on(Pin.DEFAULT_FWD_AXIS_DWN)
                self.signal.off(Pin.DEFAULT_FWD_AXIS_UP)
            elif self.type == Motor.TURN:
                self.signal.on(Pin.DEFAULT_SIDES_AXIS_DWN)
                self.signal.off(Pin.DEFAULT_SIDES_AXIS_UP)
            else:
                RuntimeError("invalid motor definition: %s" % self.type)

        if thenWait:

            if self.verbose:
                logger.debug('[Motor(%s)] waiting %s seconds', self.type,
                             thenWait)

            time.sleep(thenWait)
Пример #4
0
    def save() -> None:
        """
        Save config to file.
        :return: None.
        """
        logging.debug("ESPConfig.save()")
        global cfg
        config_dict = cfg.as_dictionary

        with open(CONFIG_FILE_PATH, "w", encoding="utf8") as infile:
            dump(config_dict, infile)
        logging.info("New config saved!")
Пример #5
0
    def subscribe_server(self, key):
        context = zmq.Context()
        socket = context.socket(zmq.SUB)
        socket.connect("tcp://" + config.HOST + ":" + config.PORT_SUB)

        socket.setsockopt(zmq.SUBSCRIBE, key)
        while True:
            try:
                data = socket.recv()
                logging.debug(json.loads(data), "[SUBSCRIBE]")
                self.data_sub.append(json.loads(data))
            except:
                traceback.print_exc()
Пример #6
0
    def subscribe_server(self, key):
        context = zmq.Context()
        socket = context.socket(zmq.SUB)
        socket.connect("tcp://" + config.HOST + ":" + config.PORT_SUB)

        socket.setsockopt(zmq.SUBSCRIBE, key)
        while True:
            try:
                data = socket.recv()
                logging.debug(json.loads(data), "[SUBSCRIBE]")
                self.data_sub.append(json.loads(data))
            except:
                traceback.print_exc()
Пример #7
0
    def update_config_dict(new_config: dict) -> None:
        """
        Updates configuration.
        :param new_config: New configuration.
        :return: None
        """
        logging.debug("update_config_dict()")
        file_path = 'config.json'
        with open(file_path, "r", encoding="utf8") as infile:
            old_config = load(infile)
        modified_entries = 0
        for key in old_config.keys():
            try:
                if old_config[key] != new_config[key]:
                    logging.debug('Changing config entry: {} \n from: {}, to: {}'.format(key,
                                                                                         old_config[key],
                                                                                         new_config[key]))
                    old_config[key] = new_config[key]
                    modified_entries += 1
            except:
                pass

        if modified_entries > 0:
            with open(file_path, "w", encoding="utf8") as infile:
                dump(old_config, infile)
            logging.debug('Modified {} entrires. Config updated succesfully!'.format(modified_entries))
        else:
            logging.debug('No changes to config file were made!')
Пример #8
0
    def load_from_file(self) -> None:
        """
        Load configuration of ESP from file.
        :return: None
        """
        logging.debug("ESPConfig.load_from_file()")
        config_file_exists = True
        if not utils.check_if_file_exists(CONFIG_FILE_PATH):
            with open(CONFIG_FILE_PATH, "w", encoding="utf8") as file:
                config_file_exists = False
                empty_config = {}
                self.device_uid = get_mac_address_as_string()
                dump(empty_config, file)

        with open(CONFIG_FILE_PATH, "r", encoding="utf8") as infile:
            config_dict = load(infile)
            self.ssid = config_dict.get('ssid', DEFAULT_SSID)
            self.password = config_dict.get('password', DEFAULT_PASSWORD)
            self.aws_endpoint = config_dict.get('aws_endpoint', DEFAULT_AWS_ENDPOINT)
            self.aws_client_id = config_dict.get('client_id', DEFAULT_AWS_CLIENT_ID)
            self.aws_topic = config_dict.get('topic', DEFAULT_AWS_TOPIC)
            self.use_aws = config_dict.get('use_aws', DEFAULT_USE_AWS)
            self.data_publishing_period_in_ms = config_dict.get('data_publishing_period_ms',
                                                                DEFAULT_DATA_PUBLISHING_PERIOD_MS)
            self.use_dht = config_dict.get('use_dht', DEFAULT_USE_DHT)
            self.dht_measurement_pin = config_dict.get('dht_measurement_pin', DEFAULT_DHT_MEASUREMENT_PIN)
            self.dht_power_pin = config_dict.get('dht_power_pin', DEFAULT_DHT_POWER_PIN)
            self.dht_type = config_dict.get('dht_type', DEFAULT_DHT_TYPE)
            self.wifi_timeout = config_dict.get('wifi_connection_timeout', DEFAULT_WIFI_TIMEOUT)
            self.mqtt_port = config_dict.get('mqtt_port', DEFAULT_MQTT_PORT)
            self.mqtt_port_ssl = config_dict.get('mqtt_port_ssl', DEFAULT_MQTT_PORT_SSL)
            self.mqtt_timeout = config_dict.get('mqtt_timeout', DEFAULT_MQTT_TIMEOUT)
            self.ap_config_done = config_dict.get('AP_config_done', DEFAULT_AP_CONFIG_DONE)
            self.configuration_after_first_power_on_done = \
                config_dict.get('configuration_after_first_power_on_done',
                                DEFAULT_CONFIGURATION_AFTER_FIRST_POWER_ON_DONE)
            self.QOS = config_dict.get('QOS', DEFAULT_QOS)

            self.tested_connection_cloud = config_dict.get('tested_connection_cloud', DEFAULT_TESTED_CONNECTION_CLOUD)
            self.printed_time = config_dict.get('printed_time', DEFAULT_PRINTED_TIME)
            self.got_sensor_data = config_dict.get('got_sensor_data', DEFAULT_GOT_SENSOR_DATA)
            self.published_to_cloud = config_dict.get('published_to_cloud', DEFAULT_PUBLISHED_TO_CLOUD)
            self.private_key = config_dict.get('private_key', DEFAULT_PRIV_KEY)
            self.cert_pem = config_dict.get('cert_pem', DEFAULT_CERT_PEM)
            self.cert_ca = config_dict.get('cert_ca', DEFAULT_CERT_CA)

            if not self.device_uid:
                self.device_uid = config_dict.get('device_uid', DEFAULT_DEVICE_UID)
        if not config_file_exists:
            self.save()
Пример #9
0
    def read_certificates(parse: bool = False) -> (bool, str, str):
        """
        Read certificates from files.
        :return: Error code (True - OK, False - at least one certificate does not exist), text of certificates.
        """
        logging.debug("read_certificates()")
        result, aws_certificate = utils.read_from_file(CERTIFICATE_PATH)
        result2, aws_key = utils.read_from_file(KEY_PATH)

        if parse:
            aws_certificate.replace('\n', '')
            aws_key.replace('\n', '')
            return (result and result2), aws_certificate, aws_key
        else:
            return (result and result2), aws_certificate, aws_key
Пример #10
0
    def stop(self):
        if self.verbose:
            logger.debug('[Motor(%s)] stopping...', self.type)

        if self.type == Motor.MOVE:
            self.signal.off(Pin.DEFAULT_FWD_AXIS_UP)
            self.signal.off(Pin.DEFAULT_FWD_AXIS_DWN)
        elif self.type == Motor.TURN:
            self.signal.off(Pin.DEFAULT_SIDES_AXIS_UP)
            self.signal.off(Pin.DEFAULT_SIDES_AXIS_DWN)
        else:
            RuntimeError("invalid motor definition: %s" % self.type)

        if self.verbose:
            logger.debug('[Motor(%s)] stopped', self.type)
Пример #11
0
    def push_server(self):
        context = zmq.Context()
        socket = context.socket(zmq.PUSH)

        for port in config.PORT_PUSH:
            socket.connect("tcp://" + config.HOST + ":" + port)

        while True:
            try:
                for data in self.data_push:
                    print logging.debug(data, "[PUSH]")
                    socket.send(data)
                    self.data_push.remove(data)

            except:
                traceback.print_exc()
Пример #12
0
    def push_server(self):
        context = zmq.Context()
        socket = context.socket(zmq.PUSH)

        for port in config.PORT_PUSH:
            socket.connect("tcp://" + config.HOST + ":" + port)

        while True:
            try:
                for data in self.data_push:
                    print logging.debug(data, "[PUSH]")
                    socket.send(data)
                    self.data_push.remove(data)

            except:
                traceback.print_exc()
Пример #13
0
    def subscribe_server(self, key):
        context = zmq.Context()
        socket = context.socket(zmq.SUB)
        socket.connect("tcp://" + config.HOST + ":" + config.PORT_SUB)

        socket.setsockopt(zmq.SUBSCRIBE, str(key))
        while True:
            try:
                data = socket.recv()
                data = " ".join(data.split(" ")[1:])
                print logging.debug(data, "[SUBSCRIBE]")
                self.data_sub.append(json.loads(data))

                # to decrease CPU usage
                time.sleep(0.001)
            except:
                traceback.print_exc()
Пример #14
0
    def update_state(self, room_id, state, deck_state, poker_state, turn):
        if room_id != self.room_id:
            return

        self.state = state
        self.deck_state = deck_state
        self.poker_state = poker_state
        self.turn = get(turn, 'Ok')
        logging.debug(repr(self.state))
        logging.debug(repr(self.deck_state))
        logging.debug(repr(self.poker_state))
        logging.debug(repr(self.turn))
        self.display(False)
Пример #15
0
def incoming():
    message = messages_from_json([request.args['message']])[0]

    if not any(isinstance(message, allowed_type) for allowed_type in ALLOWED_MESSAGE_TYPES):
        logging.debug('Ignoring non allowed message of type {}'.format(message.type))
        return '', 200

    if message.mention and message.mention != Config.BOT_USERNAME:
        logging.debug('Dropping message mentioning another bot. Message is mentioning {}'.format(message.mention))
        return '', 200

    user = BotUser.get_by_id(message.from_user)

    if message.mention:
        # handle the case where we're mentioned inline
        if message.body == '':
            translated = "What do you want translated?"
        elif user.current_state_data()['language'] is None:
            translated = gizoogleshit.gizoogleit(message.body)
        elif user.current_state_data()['language'] == "thug":
            translated = gizoogleshit.gizoogleit(message.body)
        else:
            translated = getTranslation.translateshit(user.current_state_data()['language'], message.body)
        outgoing_messages = [TextMessage(to=message.from_user, body=translated, chat_id=message.chat_id)]
    else:
        outgoing_messages = state_machine.handle_message(message.from_user, message)

    logging.debug('Processing message: {}'.format(message))

    if len(outgoing_messages) > 0:
        kik.send_messages(outgoing_messages)

    return '', 200
Пример #16
0
    def start(self):
        logger.debug('[Diagnostics] diagnostics starting...')

        with Signal.default().prepared():
            logger.debug('[Diagnostics] #### Performing sequencial run ####')
            self.moveFwdThenBack(stop=True)
            self.turnRightThenLeft()

            logger.debug('[Diagnostics] #### Performing parallel run ####')
            self.moveFwdThenBack(stop=False)
            self.turnRightThenLeft()

            self.turnMotor.stop()

        logger.debug('[Diagnostics] diagnostics complete!')
Пример #17
0
    def __init__(self):
        """
        ESPConfig constructor.
        """
        logging.debug("ESPConfig.__init__()")
        self.ssid = DEFAULT_SSID
        self.password = DEFAULT_PASSWORD
        self.aws_endpoint = DEFAULT_AWS_ENDPOINT
        self.aws_client_id = DEFAULT_AWS_CLIENT_ID
        self.aws_topic = DEFAULT_AWS_TOPIC
        self.data_publishing_period_in_ms = DEFAULT_DATA_PUBLISHING_PERIOD_MS
        self.use_dht = DEFAULT_USE_DHT
        self.use_aws = DEFAULT_USE_AWS
        self.dht_measurement_pin = DEFAULT_DHT_MEASUREMENT_PIN
        self.dht_power_pin = DEFAULT_DHT_POWER_PIN
        self.dht_type = DEFAULT_DHT_TYPE
        self.wifi_timeout = DEFAULT_WIFI_TIMEOUT
        self.mqtt_port = DEFAULT_MQTT_PORT
        self.mqtt_port_ssl = DEFAULT_MQTT_PORT_SSL
        self.mqtt_timeout = DEFAULT_MQTT_TIMEOUT
        self.ap_config_done = DEFAULT_AP_CONFIG_DONE
        self.ntp_synchronized = DEFAULT_NTP_SYNCHRONIZED
        self.configuration_after_first_power_on_done = DEFAULT_CONFIGURATION_AFTER_FIRST_POWER_ON_DONE
        self.QOS = DEFAULT_QOS
        self.api_url = DEFAULT_API_URL
        self.api_login = DEFAULT_API_LOGIN
        self.api_password = DEFAULT_API_PASSWORD
        self.device_uid = ""

        self.tested_connection_cloud = DEFAULT_TESTED_CONNECTION_CLOUD
        self.printed_time = DEFAULT_PRINTED_TIME
        self.got_sensor_data = DEFAULT_GOT_SENSOR_DATA
        self.published_to_cloud = DEFAULT_PUBLISHED_TO_CLOUD
        self.private_key = DEFAULT_PRIV_KEY
        self.cert_pem = DEFAULT_CERT_PEM
        self.cert_ca = DEFAULT_CERT_CA
Пример #18
0
    def as_dictionary(self) -> dict:
        """
        Returns configuration as dict.
        :return: Configuration.
        """
        logging.debug("ESPConfig.as_dictionary()")
        config_dict = {}
        config_dict['ssid'] = self.ssid
        config_dict['password'] = self.password
        config_dict['aws_endpoint'] = self.aws_endpoint
        config_dict['client_id'] = self.aws_client_id
        config_dict['topic'] = self.aws_topic
        config_dict['use_aws'] = self.use_aws
        config_dict['data_publishing_period_ms'] = self.data_publishing_period_in_ms
        config_dict['use_dht'] = self.use_dht
        config_dict['dht_measurement_pin'] = self.dht_measurement_pin
        config_dict['dht_power_pin'] = self.dht_power_pin
        config_dict['dht_type'] = self.dht_type
        config_dict['wifi_connection_timeout'] = self.wifi_timeout
        config_dict['mqtt_port'] = self.mqtt_port
        config_dict['mqtt_port_ssl'] = self.mqtt_port_ssl
        config_dict['mqtt_timeout'] = self.mqtt_timeout
        config_dict['AP_config_done'] = self.ap_config_done
        config_dict['configuration_after_first_power_on_done'] = self.configuration_after_first_power_on_done
        config_dict['device_uid'] = self.device_uid
        config_dict['QOS'] = self.QOS
        config_dict['tested_connection_cloud'] = self.tested_connection_cloud
        config_dict['printed_time'] = self.printed_time
        config_dict['got_sensor_data'] = self.got_sensor_data
        config_dict['published_to_cloud'] = self.published_to_cloud

        config_dict['private_key'] = self.private_key
        config_dict['cert_pem'] = self.cert_pem
        config_dict['cert_ca'] = self.cert_ca

        return config_dict
Пример #19
0
 def start(self, **kwargs):
     self.tornadoApp.listen(self.port)
     logger.debug('[start] listening on %s', self.port)
     tornado.ioloop.IOLoop.current().start()
Пример #20
0
    def turnRight(self, *args, **kwargs):
        if self.verbose:
            logger.debug('[Motor(%s)] turn right', self.type)

        self.axis(True, *args, **kwargs)
Пример #21
0
    def turnLeft(self, *args, **kwargs):
        if self.verbose:
            logger.debug('[Motor(%s)] turn left', self.type)

        self.axis(False, *args, **kwargs)
Пример #22
0
    def moveBack(self, *args, **kwargs):
        if self.verbose:
            logger.debug('[Motor(%s)] move backwards', self.type)

        self.axis(False, *args, **kwargs)
Пример #23
0
    def moveForward(self, *args, **kwargs):
        if self.verbose:
            logger.debug('[Motor(%s)] move forward', self.type)

        self.axis(True, *args, **kwargs)