Beispiel #1
0
class Main():
    def __init__(self):
        self.commans = (Play(), Variable(), Speech(), Info(), Sinoptik())
        self.db = DBConnector()
        # Очищаем список команд. Список не актуален.        
        self.db.IUD("delete from core_execute")
        self.db.commit()
        self.run()
        
    def run(self):        
        while True:
            try:
                for row in self.db.select("select * from core_execute order by ID"):
                    print(str(row[1], "utf-8"))
                    for c in str(row[1], "utf-8").split("\n"):
                        self.execute(c.strip())
                    self.db.IUD("delete from core_execute where ID = %s" % row[0])
                    self.db.commit()
                time.sleep(0.2)

                # Дергаем секундный таймер, может кому пригодится
                for cmd in self.commans:
                    cmd.time_handler()  
            except mysql.connector.Error as e:
                self.execute('speech("пропала связь с базой")')
                time.sleep(10)
            
    def execute(self, command):
        print("[%s] выполняется %s" % (time.strftime("%d-%m-%Y %H:%M"), command))
        for cmd in self.commans:
            if cmd.check_comm(self.db, command):
                break
Beispiel #2
0
 def __init__(self):
     self.commans = (Play(), Variable(), Speech(), Info(), Sinoptik())
     self.db = DBConnector()
     # Очищаем список команд. Список не актуален.        
     self.db.IUD("delete from core_execute")
     self.db.commit()
     self.run()
 def __init__(self):
     if (os.environ.get('ENV') != 'prod'):  # We are not in Heroku
         github_token = os.environ.get('GITHUB_TOKEN')
     else:
         github_token = os.environ['GITHUB_TOKEN']
     self.github = github3.login(token=github_token)
     self.db = DBConnector()
Beispiel #4
0
 def __init__(self):
     self.player = False
     self.db = DBConnector()
     self.timer_id = 101
     self.timer_on = 102
     self.timer_len = 0.5
     self.get_start_time()
     self.volume = 0
     self.run()
class TestDBConnector(unittest.TestCase):
    def setUp(self):
        if os.environ.get('TRAVIS') == None:
            self.db = DBConnector()

    def test_add_and_delete_data(self):
        if os.environ.get('TRAVIS') == None:
            github_data_import = GitHubData(
                                    date_updated=datetime.datetime.now(),
                                    language='repo_name',
                                    pull_requests=0,
                                    open_issues=0,
                                    number_of_commits=0,
                                    number_of_branches=0,
                                    number_of_releases=0,
                                    number_of_contributors=0,
                                    number_of_watchers=0,
                                    number_of_stargazers=0,
                                    number_of_forks=0
                                    )
            res = self.db.add_data(github_data_import)
            self.assertTrue(isinstance(res, GitHubData))
            res = self.db.delete_data(res.id, 'github_data')
            self.assertTrue(res)

            packagedata = PackageManagerData(
                                    date_updated=datetime.datetime.now(),
                                    csharp_downloads=0,
                                    nodejs_downloads=0,
                                    php_downloads=0,
                                    python_downloads=0,
                                    ruby_downloads=0
                                    )
            res = self.db.add_data(packagedata)
            self.assertTrue(isinstance(res, PackageManagerData))
            res = self.db.delete_data(res.id, 'package_manager_data')
            self.assertTrue(res)

    def test_get_data(self):
        if os.environ.get('TRAVIS') == None:
            github_data = self.db.get_data(GitHubData)
            self.assertTrue(isinstance(github_data, list))
            self.assertTrue(isinstance(github_data[0], GitHubData))
class GitHub(object):
    """Collect time stamped repository data from GitHub and store in a DB"""
    def __init__(self):
        if (os.environ.get('ENV') != 'prod'):  # We are not in Heroku
            github_token = os.environ.get('GITHUB_TOKEN')
        else:
            github_token = os.environ['GITHUB_TOKEN']
        self.github = github3.login(token=github_token)
        self.db = DBConnector()

    def update_library_data(self, repo_user, repo_name):
        """Gets data from a given GitHub repo and adds it to the DB

        :param repo_user: the username of the repo's owner
        :param repo_name: the name of the GitHub repo
        :type repo_user:  string
        :type repo_name:  string

        :returns: Returns the data object that was added to the DB
        :rtype:   Data object
        """
        github_data = self.github.repository(repo_user, repo_name)
        lib_data = {}
        lib_data['num_pull_requests'] \
            = sum(1 for i in github_data.iter_pulls())
        lib_data['num_issues'] \
            = sum(1 for i in github_data.iter_issues())
        lib_data['num_commits'] \
            = sum(1 for i in github_data.iter_commits())
        lib_data['num_branches'] \
            = sum(1 for i in github_data.iter_branches())
        lib_data['num_releases'] \
            = sum(1 for i in github_data.iter_releases())
        lib_data['num_contributors'] \
            = sum(1 for i in github_data.iter_contributors())
        lib_data['num_watchers'] \
            = sum(1 for i in github_data.iter_subscribers())
        lib_data['num_stargazers'] \
            = sum(1 for i in github_data.iter_stargazers())
        lib_data['num_forks'] = github_data.forks_count
        github_data_import = GitHubData(
                        date_updated=datetime.datetime.now(),
                        language=repo_name,
                        pull_requests=lib_data['num_pull_requests'],
                        open_issues=lib_data['num_issues'],
                        number_of_commits=lib_data['num_commits'],
                        number_of_branches=lib_data['num_branches'],
                        number_of_releases=lib_data['num_releases'],
                        number_of_contributors=lib_data['num_contributors'],
                        number_of_watchers=lib_data['num_watchers'],
                        number_of_stargazers=lib_data['num_stargazers'],
                        number_of_forks=lib_data['num_forks']
                        )
        return self.db.add_data(github_data_import)
Beispiel #7
0
 def __init__(self):
     self.db = DBConnector()
     self.db.IUD("update core_scheduler set ACTION_DATETIME = NULL")
     self.db.commit()
     
     print("-- Предстоящие задачи --")
     for row in self.db.select("select ID, COMM, ACTION, ACTION_DATETIME, INTERVAL_TIME_OF_DAY, INTERVAL_DAY_OF_TYPE, INTERVAL_TYPE from core_scheduler"):
         next_time = self.parse_time(None, str(row[4], "utf-8"), str(row[5], "utf-8"), row[6])
         print("[%s] %s" % (datetime.datetime.fromtimestamp(next_time), str(row[1], "utf-8")))
     print("------------------------")
     self.check_time()
     self.run()
def write_to_redis(num_to_generate=0):
    db = DBConnector(config.REDIS_HOST,config.REDIS_PORT, config.REDIS_PASSWORD).redis_connection()
    num = 0
    if num_to_generate == 0:
        num_to_generate = int(raw_input("Please provide a number of users you would like to spawn: "))
    start = datetime.now()
    print "Starting to insert {} docs at {}.".format(num_to_generate,start)
    for num in xrange(num_to_generate):
        doc = dg.generate_user_doc()
        print doc
        print doc['last_name']
        print doc['first_name']
        print doc['age']
        print doc['date_joined']
        to_hash = "{}{}{}{}".format(doc['last_name'],
        doc['first_name'],doc['age'],doc['date_joined'])
        print to_hash
        doc_hash = hashlib.sha256(to_hash).hexdigest()
        print doc_hash
        db.hmset(doc_hash, doc)
        db.lpush('doc_list', doc_hash)
        num += 1
        end = datetime.now()
        print "Finished inserting {} docs at {}.".format(num,end)
        print "Took {} to complete.".format(end-start)
    return db.hgetall('users')
Beispiel #9
0
    def do_GET(self):
        try:
            s = "/speech_text?text="
            self.path.index(s)

            url_data = parse.urlsplit(self.path)
            p = parse.parse_qs(url_data.query)
            s = p["text"][0]
            
            self.send_response(200)
            self.send_header('content-type', "text/html")
            self.send_header('charset', 'UTF8')
            self.end_headers()
            self.flush_headers()            

            from db_connector import DBConnector
            db = DBConnector()
            db.IUD("insert into core_execute (COMMAND) values ('speech(\"%s\")')" % s)
            db.commit()
            db.disconnect()
        except:
            self._execute_query(parse.urlsplit(self.path))
class TestPackageManagers(unittest.TestCase):
    def setUp(self):
        if os.environ.get('TRAVIS') == None:
            self.pm = PackageManagers()
            self.db = DBConnector()
            self.config = Config()

    def test_update_package_manager_data(self):
        if os.environ.get('TRAVIS') == None:
            res = self.pm.update_package_manager_data(
                self.config.package_manager_urls)
            self.assertTrue(isinstance(res, PackageManagerData))
            res = self.db.delete_data(res.id, 'package_manager_data')
            self.assertTrue(res)
class TestGitHub(unittest.TestCase):
    def setUp(self):
        if os.environ.get('TRAVIS') == None:
            self.github = GitHub()
            self.db = DBConnector()
            self.config = Config()

    def test_update_library_data(self):
        if os.environ.get('TRAVIS') == None:
            res = self.github.update_library_data(self.config.github_user,
                                                self.config.github_repos[0])
            self.assertTrue(isinstance(res, GitHubData))
            res = self.db.delete_data(res.id, 'github_data')
            self.assertTrue(res)
Beispiel #12
0
    def __init__(self):
        self.fast_timeput = 0.05
        self.check_lan_error = False
        self.sync_error_counter = []
        
        # Connect to serial port
        try:
            self.serialPort = serial.Serial(self.SERIAL_PORT, self.SERIAL_SPEED, parity='O', timeout=self.fast_timeput)
        except:
            print("Ошибка подключения к '%s'" % self.SERIAL_PORT)

        self.db = DBConnector()
        self.db.load_controllers()
        self.queue = []

        # Run main loop
        self.run()
Beispiel #13
0
class Main():
    def __init__(self):
        self.db = DBConnector()
        self.run()
        
    def run(self):
        while True:
            relIds = []
            for keys in self.db.select("select CORE_GET_LAST_CHANGE_ID()"):
                if keys[0] - 1 > self.db.lastVarChangeID:
                    # c.ID, c.VARIABLE_ID, c.VALUE, v.APP_CONTROL, v.GROUP_ID
                    for row in self.db.variable_changes():
                        if row[3] == 1: # Слежение за светом
                            relIds += [str(row[1]), ","]

                    if len(relIds) > 0:
                        for row in self.db.select("select v.APP_CONTROL, c.NAME, p.NAME, v.VALUE "
                                                  "  from core_variables v, core_variable_controls c, plan_parts p "
                                                  " where v.ID in (%s) "
                                                  "   and v.APP_CONTROL = c.ID "
                                                  "   and v.GROUP_ID = p.ID "
                                                  " order by v.ID" % ("".join(relIds[:-1]),)):
                            s = [str(row[2], "utf-8"), ". ", str(row[1], "utf-8"), " "]
                            if row[3]:
                                s += ["включен"]
                            else:
                                s += ["выключен"]
                                
                            self._add_command('speech("%s")' % "".join(s).lower())
            time.sleep(0.2)
            
    def _add_command(self, command):
        print("[%s] %s" % (time.strftime("%d-%m-%Y %H:%M"), command))
        """
        for row in self.db.select("select ID from core_execute where COMMAND = '%s'" % command):
            self.db.IUD("delete from core_execute where ID = %s" % row[0])
            self.db.commit()
        """
        if self.get_quiet_time():
            try:
                command.index("speech(")
                command = "speech(\"\")"
            except:
                pass
        self.db.IUD("insert into core_execute (COMMAND) values ('%s')" % command)
        self.db.commit()

    def get_quiet_time(self):
        for rec in self.db.select("select VALUE from core_variables where NAME = 'QUIET_TIME'"):
            if rec[0]:
                return True
        return False
Beispiel #14
0
from interface import Interface
from config_manager import ConfigManager
from db_connector import DBConnector
from logger_connector import LoggerConnector
from file_connector import LoggerFileConnector
from file_connector import DbFileConnector
import i18n

config_manager = ConfigManager("config.json")

# i18n setup
i18n.load_path.append('./translations')
i18n.set('filename_format', '{locale}.{format}')
i18n.set('fallback', 'en')
i18n.set('file_format', 'json')
i18n.set('locale', config_manager.language)

logger_file_connector = LoggerFileConnector(config_manager)
db_file_connector = DbFileConnector(config_manager)

logger_connector = LoggerConnector(logger_file_connector)
db_connector = DBConnector(db_file_connector)

application = Interface(db_connector, logger_connector, config_manager)
application.menu()
 def setUp(self):
     if os.environ.get('TRAVIS') == None:
         self.github = GitHub()
         self.db = DBConnector()
         self.config = Config()
Beispiel #16
0
 def __init__(self):        
     self.prev_val = 0
     #self.play_file("samples/on.wav")
     self.db = DBConnector()
     self.run()
class RecipientManager:
    """
    RecipientManager provides an interface that allows the user to manage
    the list of individuals who are notified when notifications are sent
    out. Recipient manager lets the user add or remove recipients from the
    list as well as list all current recipients.

    The list/database managed by RecipientManager SHOULD be remote because
    the purpose of this tool is to verify system integrity. Relying on a
    local list means that the integrity of the tool could be compromised
    in the same manner as the files whose interity it is trying to verify.

    The list/database CAN be kept on the same server as the checksum database
    because the integrity of that server is assumed to be intact for the
    purposes of verification.

    +---------+-------------+------+-----+---------+-------+
    | Field   | Type        | Null | Key | Default | Extra |
    +---------+-------------+------+-----+---------+-------+
    | email   | varchar(254)| YES  |     | NULL    |       |
    +---------+-------------+------+-----+---------+-------+


    Questions/Notes:

    Should the recipient manager be allowed to add the same email twice?
    How do we protect against sql injections?
    Errors should be logged, not printed.
    How do we customize the manager? Config file? Passed in as argument?
    How much customization should be allowed?
    More options means more opportunities for bugs.
    Pass arguments to functions vs using class member variables.
    What to return case where affect already exists. I.e. creating table that already exists. Return True?
    To above: Unix Philosophy is only complain if there is an error.
    More specialized handeling of errors.
    """
    def __init__(self, table_name="RECIPIENTS", db_connector=None):
        """
        Connects to the database that stores the recipient table.

        :param table_name: Table in the database where we will store the
                           recipient information.
        """
        if db_connector == None:
            self.connector = DBConnector()
        else:
            self.connector = db_connector
        self.connection = self.connector.get_connection()
        self.table_name = table_name
        self.email_field_length = 254
        self.logger = Logger()

    def create_recipient_table(self):
        """
        Creates a table if it doesn't exits in database to hold recipients.

        :return: bool -- True if the table is created or already exists,
                         False otherwise
        """
        try:
            cursor = self.connection.cursor()
            sql = """CREATE TABLE IF NOT EXISTS %s (EMAIL VARCHAR(%d) NOT
            NULL PRIMARY KEY)""" % (self.table_name, self.email_field_length)
            cursor.execute(sql)
            self.logger.log_generic_message("Table created: {}".format(
                self.table_name))
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            return False

    def delete_recipient_table(self):
        """
        Deletes the database table containing all recipient information.

        :return: bool -- True if the table is deleted or does not exist.
                         False otherwise
        """
        try:
            cursor = self.connection.cursor()
            sql = "DROP TABLE IF EXISTS %s" % self.table_name
            cursor.execute(sql)
            self.logger.log_generic_message("Table deleted: {}".format(
                self.table_name))
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            return False

    def table_exists(self):
        """
        Checks if the table with the table named passed to the recipient
        manager exists.

        :return: bool -- True if the table exists. False otherwise.
        """
        try:
            cursor = self.connection.cursor()
            sql = "SHOW TABLES LIKE '%s'" % self.table_name
            cursor.execute(sql)
            result = cursor.fetchone()
            if result:
                return True
            else:
                return False
        except Exception as err:
            self.logger.log_generic_message(err)
            return False

    def add_recipient(self, recipient):
        """
        Adds a new recipient to the database of users who recieve an email
        when notifications are sent

        :param recipient: Email to be added to the recipient list
        :type subject: string


        :returns: bool -- True if add was successful, False otherwise
        """

        if not validate_email(recipient, verify=False):
            return False

        if len(recipient) > 254:
            return False

        if not self.create_recipient_table():
            return False

        try:
            cursor = self.connection.cursor()
            sql = """INSERT INTO %s (
            EMAIL) VALUES ('%s')""" % (self.table_name, recipient)
            cursor.execute(sql)
            self.connection.commit()
            self.logger.log_generic_message(
                "Recipient added: {}".format(recipient))
            return True
        except Exception as err:
            print err
            self.logger.log_generic_message(err)
            self.connection.rollback()
            return False

    def print_table(self):
        """
        For Debugging purposes, a print of table.
        """
        try:
            sql = "SELECT * FROM %s" % self.table_name
            cursor = self.connector.connection.cursor()
            cursor.execute(sql)
            results = cursor.fetchall()
            for row in results:
                print(row[0])
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            return False

    def remove_recipient(self, recipient):
        """
        Removes emails from the list of recipients that matches the
        string 'recipient'

        :param recipient: Email to be removed from the recipient list
        :type subject: string
        :returns: bool -- True if remove was successful, False otherwise
        """

        if not self.table_exists():
            msg = "Table does not exist from which email is to be removed"
            self.logger.log_generic_message(msg)
            return False

        try:
            cursor = self.connector.connection.cursor()
            sql = "DELETE FROM %s WHERE EMAIL = '%s'" % (self.table_name,
                                                         recipient)
            cursor.execute(sql)
            results = cursor.fetchall(
            )  #: To let the system know that there are no results to fetch from and it return False
            self.connector.connection.commit()
            self.logger.log_generic_message(
                "Recipient removed: {}".format(recipient))
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            self.connector.connection.rollback()
            return False

    def get_recipients(self):
        """
        Get a list of emails contained in the recipient list.

        returns: list -- String list containing recipient emails.
        """

        if not self.table_exists():
            return []

        try:
            recipient_emails = []
            sql = "SELECT * FROM %s" % self.table_name
            cursor = self.connector.connection.cursor()
            cursor.execute(sql)
            results = cursor.fetchall()
            for row in results:
                recipient_emails.append(str(row[0]))
            return recipient_emails
        except Exception as err:
            self.logger.log_generic_message(err)
            return []
Beispiel #18
0
class ChecksumManager:
    """
    Provides an interface to control checksum/filename pair table.

    Checksum Database Table

    +----------+--------------+------+-----+---------+-------+
    | Field    | Type         | Null | Key | Default | Extra |
    +----------+--------------+------+-----+---------+-------+
    | filename | varchar(255) | YES  |     | NULL    |       |
    | checksum | varchar(64)  | YES  |     | NULL    |       |
    | filepath | varchar(255) | YES  |     | NULL    |       |
    +----------+--------------+------+-----+---------+-------+

    The filepath in the table is stored as the absolute filename.

    NOTE: The checksum manager should be able to specify the absolute path
    of the file, but the filename itself needs to be stored as the key
    so that the user can delete it by just specifying the filename. It has to be
    split and added as both a file and filename.
    """
    def __init__(self, table_name="CHECKSUMS", db_connector=None):
        self.filename_field_length = 255
        self.checksum_field_length = 64
        self.filepath_field_length = 255

        if db_connector == None:
            self.connector = DBConnector()
        else:
            self.connector = db_connector()

        self.connection = self.connector.get_connection()
        self.table_name = table_name
        self.checksum_calculator = ChecksumCalculator()
        self.logger = Logger(__name__)

    def checksum_table_exists(self):
        """
        Check to see if the checksum table exists in the database.

        :return: bool -- True if the table exists. False otherwise.
        """
        try:
            cursor = self.connection.cursor()
            sql = "SHOW TABLES LIKE '%s'" % self.table_name
            cursor.execute(sql)
            result = cursor.fetchone()
            if result:
                return True
            else:
                return False
        except Exception as err:
            self.logger.log_generic_message(err)
            return False

    def create_checksum_table(self):
        """
        Creates a new checksum table in the database with the same properties
        as described in the class documentation.

        :return: bool -- True if the table was created or already existed.
                         False otherwise.
        """
        try:
            cursor = self.connection.cursor()
            sql = """CREATE TABLE IF NOT EXISTS %s (filename VARCHAR(%d) NOT
            NULL PRIMARY KEY, checksum VARCHAR(%d) NOT NULL, filepath VARCHAR(%d) NOT NULL)""" % (
                self.table_name, self.filename_field_length,
                self.checksum_field_length, self.filepath_field_length)
            cursor.execute(sql)
            self.logger.log_generic_message("Table created: {}".format(
                self.table_name))
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            return False

    def add_checksum_pair(self, filename):
        """
        Calculates the checksum of file filename and then add the new
        checksum/filename entry to the database. If the table does
        not yet exist, then the table is first created and then the checksum
        pair is added.

        TODO: If the user supplies an absolute path at the filename, the name
        of the file has to be stripped of the path to be used as the key.

        TODO: Check the robustness of connection rollback.

        :param filename: The name of the file whose filename/checksum is added
        :type filename: string
        :return: bool -- True if added successfuly. False otherwise.
        """

        if not self.create_checksum_table():
            return False

        if len(filename) > self.filename_field_length:
            return False

        checksum = self.checksum_calculator.calculate_checksum(filename)
        filepath = self.get_abspath(filename)

        if checksum:
            try:
                cursor = self.connection.cursor()
                sql = """INSERT INTO %s (
                filename,checksum,filepath) VALUES ('%s','%s','%s')""" % (
                    self.table_name, filename, checksum, filepath)
                cursor.execute(sql)
                self.connection.commit()
                self.logger.log_generic_message("Pair added: {}({})".format(
                    filename, checksum))
                return True
            except Exception as err:
                self.logger.log_generic_message(err)
                self.connection.rollback()
                return False

        else:
            return False

    def remove_checksum_pair(self, filename):
        """
        Removes the entry with filename filename in the checksum table. If
        the checksum pair does not exist in the database or was not removed,
        the function returns False.

        :param filename: The name of the file whose filename/checksum pair is being removed.
        :type filename: string
        :return: bool -- True if removed successfuly. False otherwise.
        """
        if not self.checksum_table_exists():
            return True

        try:
            cursor = self.connector.connection.cursor()
            sql = "DELETE FROM %s WHERE filename = '%s'" % (self.table_name,
                                                            filename)
            cursor.execute(sql)
            self.connector.connection.commit()
            self.logger.log_generic_message(
                "file removed: {}".format(filename))
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            self.connector.connection.rollback()
            return False

    def get_checksum_pairs(self):
        """
        Returns a list of tuples formated as follows: (filename, hash, absolute filename)

        :return: list -- List of string tuples
                         Return an empty list if no checksum pairs exist
                         or the table/database does not exist.
        """
        if not self.checksum_table_exists():
            return []

        try:

            checksum_pairs = []
            sql = "SELECT * FROM %s" % self.table_name
            cursor = self.connector.connection.cursor()
            cursor.execute(sql)
            results = cursor.fetchall()
            for row in results:
                entry = []
                entry.append(str(row[0]))
                entry.append(str(row[1]))
                entry.append(str(row[2]))
                checksum_pairs.append(entry)
            return checksum_pairs
        except Exception as err:
            self.logger.log_generic_message(err)
            return []

    def get_abspath(self, filename):
        """
        Returns the absolute path of filename

        :param filename: filename of the file whose path we want to find
        :returns: string -- Absolute path if succssful. None otherwise
        """

        if os.path.exists(filename):
            return os.path.abspath(filename)
        else:
            return None

    def delete_checksum_table(self):
        """
        Deletes the database table containing all recipient information.

        :return: bool -- True if the table is deleted or does not exist.
                         False otherwise
        """
        try:
            cursor = self.connection.cursor()
            sql = "DROP TABLE IF EXISTS %s" % self.table_name
            cursor.execute(sql)
            self.logger.log_generic_message("Table deleted: {}".format(
                self.table_name))
            return True
        except Exception as err:
            self.logger.log_generic_message(err)
            return False
Beispiel #19
0
class Main():
    SERIAL_PORT = "/dev/ttyUSB0"
    SERIAL_SPEED = 57600

    PACK_SYNC = 1
    PACK_COMMAND = 2
    PACK_ERROR = 3

    def __init__(self):
        self.fast_timeput = 0.1 #0.05
        self.check_lan_error = False
        
        # Connect to serial port
        try:
            self.serialPort = serial.Serial(self.SERIAL_PORT, self.SERIAL_SPEED, parity='O', timeout=self.fast_timeput)
        except:
            print("Ошибка подключения к '%s'" % self.SERIAL_PORT)

        self.db = DBConnector()
        self.db.load_controllers()
        self.queue = []

        # Run main loop
        self.run()

    def send_pack(self, dev_id, pack_type, pack_data, flush=True):
        buf = json.dumps([dev_id, pack_type, pack_data]).encode("utf-8")
        buf += bytearray([0x0])

        c = 5
        for err in range(c):
            self.serialPort.write(buf)
            if flush:
                self.serialPort.flush()
            #print(buf)
            res = self.check_lan()
            if self.check_lan_error == False:
                break
            if err < (c - 1):
                self.check_lan_error = False
        return res

    def _store_variable_to_db(self, dev_id, pack_data):
        for var in pack_data:
            if len(var) > 1:
                self.db.set_variable_value(var[0], var[1], dev_id)

    def check_lan(self):
        try:
            buf = self.serialPort.readline()
            if len(buf) > 0:
                #print(buf)
                resp = buf.decode("utf-8")
                data = []
                for pack in resp.split(chr(0x0)):
                    if len(pack) > 0:
                        d = json.loads(pack)
                        data += [d]
                        if d[1] == self.PACK_ERROR:
                            self.check_lan_error = True
                            for s in d[2]:
                                self._command_info("%s" % s)
                return data
            else:
                return False
        except Exception as e:
            self.check_lan_error = True
            self._command_info("EXCEPT {}".format(e.args))
            return False

    def _sync_variables(self):
        # Зачитываем изменения в БД
        var_data = self.db.variable_changes()
        recv_valid = False

        # Шлем посылку никому, чтобы контроллеры приготовились принимать
        self.send_pack(0, self.PACK_SYNC, [])
        time.sleep(0.02)
        # Рассылаем изменения в БД и паралельно читаем обновления
        for dev in self.db.controllers:
            for rep in range(3): # 3 попытки отослать пакет
                pack_data = []
                lt = time.localtime()
                t = time.mktime((2000, 1, 1, 0, 0, 0, 0, 0, lt.tm_isdst))
                pack_data += [[-100, round(time.time() - t)]] #Передаем системное время в контроллеры
                for var in var_data:
                    if var[2] != dev[0]:
                        pack_data += [[var[0], var[1]]]

                date = datetime.datetime.now().strftime('%H:%M:%S')
                print("[%s] SYNC. '%s': " % (date, dev[1]), end="")
                cl = self.send_pack(dev[0], self.PACK_SYNC, pack_data)
                if cl:
                    for res_pack in cl:
                        if res_pack[2] == "RESET":
                            print("RESET ", end="")
                            is_ok = self.send_pack(dev[0], self.PACK_SYNC, self._reset_pack()) != False
                            for r in range(30):
                                if self.check_lan():
                                    is_ok = True
                            if is_ok:
                                print("OK\n")
                                recv_valid = True
                            else:
                                print("ERROR\n")
                        else:
                            self._store_variable_to_db(res_pack[0], res_pack[2])
                            print("OK")
                            print("   >> ", pack_data)
                            print("   << ", res_pack[2], "\n")
                            recv_valid = True
                else:
                    print("ERROR\n")

                time.sleep(0.02)
                
                if recv_valid: # Обмен прошел успешно повторы не требуются
                    break

    def _reset_pack(self):
        return self.db.all_variables();

    def _command_info(self, text, replace_text = None):
        text = text.replace("'", "`")
        text = text.replace('"', '\"')
        s = self.db.get_property('RS485_COMMAND_INFO')
        if replace_text == None:
            text = text.replace("<", "&lt;")
            text = text.replace(">", "&gt;")
            print(text)
            self.db.set_property('RS485_COMMAND_INFO', s + '<p>' + text + '</p>')
        else:
            self.db.set_property('RS485_COMMAND_INFO', s.replace(text, replace_text))

    def _send_commands(self):
        command = self.db.get_property('RS485_COMMAND')

        if command == "":
            return

        self.db.set_property('RS485_COMMAND_INFO', '')
        
        for dev in self.db.controllers:            
            error_text = "Контроллер '%s' не ответил." % dev[1]

            if command == "SCAN_OW":
                self._command_info("Запрос поиска OneWire устройств для контроллера '%s'..." % dev[1])
                if self.send_pack(dev[0], self.PACK_COMMAND, ["SCAN_ONE_WIRE", ""]):
                    self._command_info("Пауза 3с...")
                    time.sleep(3)
                    self._command_info("Запрос списка найденых на шине OneWire устройств для контроллера '%s'" % dev[1])
                    is_ok = False
                    for res_pack in self.send_pack(dev[0], self.PACK_COMMAND, ["LOAD_ONE_WIRE_ROMS", ""]):
                        count = 0
                        allCount = len(res_pack[2][1])
                        is_ok = True
                        for rom in res_pack[2][1]:
                            rom_s = []
                            for r in rom:
                                ss = hex(r).upper()
                                if len(ss) == 3:
                                    ss = ss.replace("0X", "0x0")
                                else:
                                    ss = ss.replace("0X", "0x")
                                rom_s += [ss]
                                rom_s += [", "]
                            self._command_info("".join(rom_s[:-1]))
                            if self.db.append_scan_rom(dev[0], rom):
                                count += 1
                        self._command_info("Всего найдено устройств: %s. Новых: %s" % (allCount, count))
                        
                    if is_ok == False:
                        self._command_info(error_text)
                else:
                    self._command_info(error_text)
            elif command == "CONFIG_UPDATE":
                self.serialPort.timeout = 2
                time.sleep(0.1)
                try:
                    self._command_info("CONFIG FILE UPLOAD '%s'..." % dev[1])
                    #pack_data = self._str_to_hex(generate_config_file(self.db))
                    pack_data = generate_config_file(self.db)
                    self._command_info(str(len(pack_data)) + ' bytes.')

                    #bts = 512
                    #bts = 128
                    bts = 1024
                    cou = math.ceil(len(pack_data) / bts)
                    is_ok = False
                    c_pack = self.send_pack(dev[0], self.PACK_COMMAND, ["SET_CONFIG_FILE", cou, False], False)
                    if c_pack and self.check_lan_error == False:
                        prev_command = "Начало загрузки..."
                        self._command_info(prev_command)
                        for i in range(cou):
                            t = i * bts
                            s = pack_data[t:t + bts]
                            c_pack = self.send_pack(dev[0], self.PACK_COMMAND, ["SET_CONFIG_FILE", i + 1, s], i == cou - 1)
                            if c_pack != False and self.check_lan_error or (i == cou - 1):
                                is_ok = True
                                if i != cou - 1:
                                    #Значит не долили файл
                                    self._command_info("ВНИМАНИЕ: Загрузка прервана");
                                break
                            else:
                                new_command = self._gen_text_progress(i, cou)
                                self._command_info(prev_command, new_command)
                                prev_command = new_command                                
                        self._command_info(prev_command, self._gen_text_progress(cou, cou))
                        
                    if is_ok:
                        self._command_info("OK")
                    else:
                        self._command_info(error_text)
                except:
                    pass
                self.serialPort.timeout = self.fast_timeput
                self.check_lan_error = False
            elif command == "REBOOT_CONTROLLERS":
                self.serialPort.timeout = 1
                self._command_info("Запрос перезагрузки контроллера '%s'..." % dev[1])
                if self.send_pack(dev[0], self.PACK_COMMAND, ["REBOOT_CONTROLLER", ""]):
                    self._command_info("OK")
                else:
                    self._command_info(error_text)
                self.serialPort.timeout = self.fast_timeput
            elif command == "GET_OW_VALUES":
                pass
                
        self.db.set_property('RS485_COMMAND', '')
        self._command_info("Готово.")
        time.sleep(2)
        self._command_info("TERMINAL EXIT")

    def _gen_text_progress(self, pos, max_pos):
        i = round(pos * 100 / max_pos)
        s = "<center>["
        s += ("<span style=\"color:#ffffff;\">|</span>") * (i + 1)
        s += ("<span style=\"color:#000000;\">|</span>") * (100 - i - 1)
        s += "] " + str(i) + "% </center>"
        return s

    """
    def _str_to_hex(self, text):
        res = []
        for c in text:
            s = hex(ord(c)).replace('0x', '')
            if len(s) == 1:
                s = '0' + s
            res += [s]
        return "".join(res)
    """

    SYNC_STATE = ""
            
    def run(self):
        serialPort = self.serialPort        
        while True:
            # Синхронизируем переменные между сервером и контроллерами
            SYNC_STATE = self.db.get_property('SYNC_STATE')

            stateChange = SYNC_STATE != self.SYNC_STATE
            if SYNC_STATE == "RUN":
                if stateChange:
                    print("Синхронизация запущена")
                try:
                    self._sync_variables()
                except:
                    pass
            else:
                if stateChange:
                    print("Синхронизация остановлена")
                time.sleep(0.1)

            self.SYNC_STATE = SYNC_STATE

            # Рассылаем системные комманды, если требуется
            self._send_commands()
class StackoverflowDumpToDBService:
    def __init__(self):
        self.db = DBConnector()

    def import_posts_from_file(self, from_date, until_date, file_path,
                               table_name):
        sql_query = "SELECT AcceptedAnswerId from android_posts where AcceptedAnswerId IS NOT NULL;"
        cursor = self.db.get_cursor()
        cursor.execute(sql_query)

        acceptedAnswers = set(
            [AcceptedAnswerId[0] for AcceptedAnswerId in cursor.fetchall()])
        print(type(list(acceptedAnswers)[0]))
        print("number of accepted answers:" + str(len(acceptedAnswers)))
        print("number of accepted answers:" + str(len(set(acceptedAnswers))))
        f = io.open(file_path, 'r', encoding="utf8")
        f.readline()
        f.readline()

        row_nums = 0
        scanned_row_nums = 0
        counter = 0
        while True:
            current_line = f.readline()
            scanned_row_nums += 1
            if scanned_row_nums % 1000 == 0:
                print("scanned_row_nums:" + str(scanned_row_nums))
            if scanned_row_nums <= 6786000:
                continue

            if not current_line:
                break
            try:
                root = ElementTree.fromstring(current_line.encode('utf-8'))
            except Exception as e:
                print(e)
                print(
                    "----------------------------------------------------------------------"
                )
                # print("this line contains error")
                # print(current_line)
                # print("----------------------------------------------------------------------")
                continue

            attributes = root.attrib
            post_id = long(attributes.get('Id'))

            attributes['CreationDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            creation_date = datetime.datetime.strptime(
                attributes['CreationDate'], '%Y-%m-%d  %H:%M:%S')
            if creation_date < from_date:
                continue
            if creation_date >= until_date:
                break

            if post_id not in acceptedAnswers:
                continue
            acceptedAnswers = acceptedAnswers - set([post_id])
            attributes['LastEditDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['LastActivityDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['CommunityOwnedDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['AcceptedAnswerId'] = attributes.get('AcceptedAnswerId')
            attributes['ViewCount'] = attributes.get('ViewCount', 0)
            attributes['LastEditorDisplayName'] = attributes.get(
                'LastEditorDisplayName')
            attributes['Title'] = attributes.get('Title')
            attributes['Tags'] = attributes.get('Tags')
            attributes['OwnerUserId'] = attributes.get('OwnerUserId')
            attributes['AnswerCount'] = attributes.get('AnswerCount', 0)
            attributes['FavoriteCount'] = attributes.get('FavoriteCount', 0)
            attributes['LastEditorUserId'] = attributes.get('LastEditorUserId')
            attributes['Score'] = int(attributes.get('Score'))
            attributes['ParentId'] = attributes.get('ParentId', None)

            try:
                query = '''
                INSERT INTO ''' + table_name + ''' (id,PostTypeId,AcceptedAnswerId,CreationDate,Score,ViewCount,Body,OwnerUserId,
                LastEditorUserId,LastEditorDisplayName,LastEditDate,LastActivityDate,Title,Tags,AnswerCount,CommentCount,FavoriteCount,CommunityOwnedDate,ParentId)
                VALUES (%(Id)s,%(PostTypeId)s,%(AcceptedAnswerId)s,%(CreationDate)s,%(Score)s,%(ViewCount)s,%(Body)s,
                    %(OwnerUserId)s,%(LastEditorUserId)s,%(LastEditorDisplayName)s,
                    %(LastEditDate)s,%(LastActivityDate)s,%(Title)s,%(Tags)s,%(AnswerCount)s,%(CommentCount)s,
                    %(FavoriteCount)s,%(CommunityOwnedDate)s,%(ParentId)s)'''
                self.db.get_cursor().execute(query, attributes)

            except Exception as e:
                print(attributes)
                raise e

            row_nums += 1
            counter += 1
            if row_nums == 1000:
                self.db.get_connection().commit()
                row_nums = 0
                print("%s records has been inserted! last date was %s" %
                      (counter, creation_date))

        self.db.get_connection().commit()
        self.db.get_cursor().close()
Beispiel #21
0
#!/usr/bin/python3.4
#-*- coding: utf-8 -*-

from db_connector import DBConnector
import datetime

db = DBConnector()

print(datetime.datetime.now())
n = (12 * 30 * 24 * 3600) / 1545
q = db.query(" select 1, MIN(VALUE), MAX(VALUE) "
             "   from core_variable_changes "
             "  where VARIABLE_ID = 59 "
             " group by ROUND(UNIX_TIMESTAMP(CHANGE_DATE) / %s) " % n, [])
row = q.fetchone()
c = 0
while row:
    row = q.fetchone()
    c += 1
q.close()
print(datetime.datetime.now())
print(c)
class PackageManagers(object):
    """Collect time stamped package manager data from various package managers
       and store in a DB"""
    def __init__(self):
        self.db = DBConnector()

    def update_package_manager_data(self, package_manager_urls):
        """Gets data given package manager urls and adds it to the DB

        :param package_manager_urls: URL(s) to the package you want to obtain
                                     download data from
        :type package_manager_urls:  Array of strings

        :returns: Returns the data object that was added to the DB
        :rtype:   Data object
        """
        num_total_csharp_downloads = None
        num_nodejs_monthly_downloads = None
        num_php_downloads = None
        num_python_downloads = None
        num_ruby_downloads = None
        num_python_http_client_downloads = None
        num_python_open_source_library_data_collector_downloads = None
        num_ruby_http_client_downloads = None
        num_csharp_http_client_downloads = None
        num_php_http_client_downloads = None
        num_node_http_client_downloads = None
        for url in package_manager_urls:
            if 'https://www.nuget.org/packages/SendGrid' == url:
                num_total_csharp_downloads = self.csharp_downloads(url)
            if 'https://www.nuget.org/packages/SendGrid.CSharp.HTTP.Client' == url:
                num_csharp_http_client_downloads = self.csharp_downloads(url)
            if 'https://www.npmjs.com/package/sendgrid' in url:
                if 'https://www.npmjs.com/package/sendgrid-rest' != url:
                    num_nodejs_monthly_downloads = self.nodejs_downloads(url)
            if 'https://www.npmjs.com/package/sendgrid-rest' in url:
                num_node_http_client_downloads = self.nodejs_downloads(url)
            if 'https://packagist.org/packages/sendgrid/sendgrid' == url:
                num_php_downloads = self.php_downloads(url)
            if 'https://packagist.org/packages/sendgrid/php-http-client' == url:
                num_php_http_client_downloads = self.php_downloads(url)
            if 'pypi' in url and 'sendgrid' in url:
                num_python_downloads = self.python_downloads(url)
            if 'pypi' in url and 'python_http_client' in url:
                num_python_http_client_downloads = self.python_downloads(url)
            if 'pypi' in url and 'open_source_library_data_collector' in url:
                num_python_open_source_library_data_collector_downloads = self.python_downloads(url)
            if 'rubygems' in url and 'sendgrid' in url:
                num_ruby_downloads = self.ruby_downloads(url)
            if 'rubygems' in url and 'http' in url:
                num_ruby_http_client_downloads = self.ruby_downloads(url)

        return self.update_db(num_total_csharp_downloads,
                              num_nodejs_monthly_downloads,
                              num_php_downloads,
                              num_python_downloads,
                              num_ruby_downloads,
                              num_python_http_client_downloads,
                              num_python_open_source_library_data_collector_downloads,
                              num_ruby_http_client_downloads,
                              num_csharp_http_client_downloads,
                              num_php_http_client_downloads,
                              num_node_http_client_downloads)

    def csharp_downloads(self, url):
        """Gets library download data from nuget.org

        :param url: the URL of the package
        :type url:  string

        :returns: The number of total library downloads
        :rtype:   Integer
        """
        r = requests.get(url)
        soup = BeautifulSoup(r.text, "html.parser")
        mydivs = soup.findAll("p", {"class": "stat-number"})
        nodes = []
        for node in mydivs:
            nodes.append(''.join(node.findAll(text=True)))
        num_total_csharp_downloads = nodes[0].replace(',', '')
        return num_total_csharp_downloads

    def nodejs_downloads(self, url):
        """Gets library download data from npmjs.org

        :param url: the URL of the package
        :type url:  string

        :returns: The number of library downloads in the last month
        :rtype:   Integer
        """
        r = requests.get(url)
        soup = BeautifulSoup(r.text, "html.parser")
        mydivs = soup.findAll("strong",
                              {"class": "pretty-number monthly-downloads"})
        nodes = []
        for node in mydivs:
            nodes.append(''.join(node.findAll(text=True)))
        num_nodejs_monthly_downloads = nodes[0].replace(',', '')
        return num_nodejs_monthly_downloads

    def php_downloads(self, url):
        """Gets library download data from packagist.org

        :param url: the URL of the package
        :type url:  string

        :returns: The number of total library downloads
        :rtype:   Integer
        """
        r = requests.get(url)
        soup = BeautifulSoup(r.text, "html.parser")
        mydivs = soup.findAll("div",
                              {"class": "facts col-xs-12 col-sm-6 col-md-12"})
        nodes = []
        for node in mydivs:
            nodes.append(''.join(node.findAll(text=True)))
        num_php_downloads = nodes[0][11:].replace(u('\u2009'), '').split('\n')
        num_php_downloads = str(num_php_downloads[0])
        return num_php_downloads

    def python_downloads(self, url):
        """Gets library download data from pypi.python.org

        :param url: the URL of the package
        :type url:  string

        :returns: The number of library downloads in the last month
        :rtype:   Integer
        """
        r = requests.get(url)
        soup = BeautifulSoup(r.text, "html.parser")
        mydivs = soup.findAll("ul", {"class": "nodot"})
        nodes = []
        for node in mydivs:
            nodes.append(''.join(node.findAll(text=True)))
        num_python_downloads = \
            nodes[0].replace(u('\n'), '') \
            .rpartition('week')[-1] \
            .rpartition('downloads')[0][2:] \
            .replace(u('\u2009'), '')
        return num_python_downloads

    def ruby_downloads(self, url):
        """Gets library download data from rubygems.org

        :param url: the URL of the package
        :type url:  string

        :returns: The number of total library downloads
        :rtype:   Integer
        """
        r = requests.get(url)
        soup = BeautifulSoup(r.text, "html.parser")
        mydivs = soup.findAll("span", {"class": "gem__downloads"})
        nodes = []
        for node in mydivs:
            nodes.append(''.join(node.findAll(text=True)))
        num_ruby_downloads = nodes[0].replace(',', '')
        return num_ruby_downloads

    def update_db(
            self,
            num_total_csharp_downloads,
            num_nodejs_monthly_downloads,
            num_php_downloads,
            num_python_downloads,
            num_ruby_downloads,
            num_python_http_client_downloads,
            num_python_open_source_library_data_collector_downloads,
            num_ruby_http_client_downloads,
            num_csharp_http_client_downloads,
            num_php_http_client_downloads,
            num_node_http_client_downloads
            ):
        """Update the DB with the package manager data

        :param num_total_csharp_downloads:   # of total downloads
        :param num_nodejs_monthly_downloads: # of downloads in the last month
        :param num_php_downloads:            # of total downloads
        :param num_python_downloads:         # of downloads in the last month
        :param num_ruby_downloads:           # of total downloads
        :type  num_total_csharp_downloads:   Integer
        :type  num_nodejs_monthly_downloads: Integer
        :type  num_php_downloads:            Integer
        :type  num_python_downloads:         Integer
        :type  num_ruby_downloads:           Integer

        :returns: Returns the data object that was added to the DB
        :rtype:   Data object
        """
        packagedata = PackageManagerData(
            date_updated=datetime.datetime.now(),
            csharp_downloads=num_total_csharp_downloads,
            nodejs_downloads=num_nodejs_monthly_downloads,
            php_downloads=num_php_downloads,
            python_downloads=num_python_downloads,
            ruby_downloads=num_ruby_downloads,
            python_http_client_downloads=num_python_http_client_downloads,
            csharp_http_client_downloads=num_csharp_http_client_downloads,
            ruby_http_client_downloads=num_ruby_http_client_downloads,
            php_http_client_downloads=num_php_http_client_downloads,
            open_source_library_data_collector_downloads=num_python_open_source_library_data_collector_downloads,
            node_http_client_downloads=num_node_http_client_downloads
            )
        return self.db.add_data(packagedata)
Beispiel #23
0
 def test_valid_credentials(self):
     connector = DBConnector(db_name=self.test_db_name)
     response = connector.get_connection()
     self.assertIsNotNone(response)
Beispiel #24
0
class StackoverflowDumpToDBService:
    def __init__(self):
        self.db = DBConnector()

    def import_posts_from_file(self, from_date: datetime, until_date: datetime,
                               file_path: str, table_name: str):
        f = open(file_path, 'r', encoding="utf8")
        f.readline()
        f.readline()

        row_nums = 0

        counter = 0
        while True:
            current_line = f.readline()
            if not current_line:
                break
            try:
                root = ElementTree.fromstring(current_line)
            except:
                print(
                    "----------------------------------------------------------------------"
                )
                print("this line contains error")
                print(current_line)
                print(
                    "----------------------------------------------------------------------"
                )
                continue
            attributes = root.attrib
            attributes['CreationDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['LastEditDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['LastActivityDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['CommunityOwnedDate'] = re.sub(
                r'\.\d+', '', attributes['CreationDate'].replace('T', ' '))
            attributes['AcceptedAnswerId'] = attributes.get('AcceptedAnswerId')
            attributes['ViewCount'] = attributes.get('ViewCount', 0)
            attributes['LastEditorDisplayName'] = attributes.get(
                'LastEditorDisplayName')
            attributes['Title'] = attributes.get('Title')
            attributes['Tags'] = attributes.get('Tags')
            attributes['OwnerUserId'] = attributes.get('OwnerUserId')
            attributes['AnswerCount'] = attributes.get('AnswerCount', 0)
            attributes['FavoriteCount'] = attributes.get('FavoriteCount', 0)
            attributes['LastEditorUserId'] = attributes.get('LastEditorUserId')
            attributes['Score'] = int(attributes.get('Score'))
            attributes['ParentId'] = attributes.get('ParentId', None)
            creation_date = datetime.datetime.strptime(
                attributes['CreationDate'], '%Y-%m-%d  %H:%M:%S')
            if creation_date < from_date:
                continue
            if creation_date >= until_date:
                break

            if should_be_skipped(attributes):
                continue
            try:
                query = '''
                INSERT INTO ''' + table_name + ''' (id,PostTypeId,AcceptedAnswerId,CreationDate,Score,ViewCount,Body,OwnerUserId,
                LastEditorUserId,LastEditorDisplayName,LastEditDate,LastActivityDate,Title,Tags,AnswerCount,CommentCount,FavoriteCount,CommunityOwnedDate,ParentId)
                VALUES (%(Id)s,%(PostTypeId)s,%(AcceptedAnswerId)s,%(CreationDate)s,%(Score)s,%(ViewCount)s,%(Body)s,
                    %(OwnerUserId)s,%(LastEditorUserId)s,%(LastEditorDisplayName)s,
                    %(LastEditDate)s,%(LastActivityDate)s,%(Title)s,%(Tags)s,%(AnswerCount)s,%(CommentCount)s,
                    %(FavoriteCount)s,%(CommunityOwnedDate)s,%(ParentId)s)'''
                self.db.get_cursor().execute(query, attributes)

            except Exception as e:
                print(attributes)
                raise e

            row_nums += 1
            counter += 1
            if row_nums == 1000:
                self.db.get_connection().commit()
                row_nums = 0
                print("%s records has been inserted! last date was %s" %
                      (counter, creation_date))

        self.db.get_connection().commit()
        self.db.get_cursor().close()
Beispiel #25
0
from pyspark.ml.evaluation import RegressionEvaluator
from pyspark.ml.recommendation import ALS

from pyspark.sql import SparkSession
from pyspark import SparkContext

sc = SparkContext("spark://vm1:7077", "StreamProcessing")
sc.addPyFile('/home/tom/Spark-Recommendation-System/db_connector.py')
sc.setLogLevel("ERROR")

from db_connector import DBConnector

TRIGGER_INTERVAL = 30  # in seconds
TOPIC_NAME = 'spark_streaming'
KAFKA_PORT = 'vm1:2181'
db = DBConnector('streaming_db')


def fit_model(df):
    als = ALS(maxIter=10,
              regParam=0.01,
              userCol="userId",
              itemCol="movieId",
              ratingCol="rating",
              coldStartStrategy="drop")
    model = als.fit(df)
    return model


def to_numbers(pair):
    # convert the input from kafka to a tuple of numbers
Beispiel #26
0
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

import json
from datetime import datetime

import flask
import flask_restful

from db_connector import DBConnector

app = flask.Flask(__name__)
api = flask_restful.Api(app)
db_connector = DBConnector()


class DatabasesResource(flask_restful.Resource):
    """API /databases endpoint."""

    def post(self):
        """Create new database. Expected request json: {"database_name": <database_name>}."""
        request_body = json.loads(flask.request.data.decode())
        database_name = request_body["database_name"]
        if not database_name:
            flask_restful.abort(400, message="Missing database name")
        db_connector.db_create(database_name)
        return flask.Response("OK")

Beispiel #27
0
def categories():

    con = DBConnector(abs_path('databases/offer_classification.db'))
    return con.fetch_categories()
Beispiel #28
0
#!/usr/bin/python3.4
#-*- coding: utf-8 -*-

from db_connector import DBConnector
import datetime

db = DBConnector()

vals = []
i = 1
min_y = 9999999
max_y = -9999999

for rec in db.select("select UNIX_TIMESTAMP(CHANGE_DATE) - 1461412404, VALUE * 50 "
                     "  from core_variable_changes "
                     " where VARIABLE_ID = 59 "
                     " order by 1 "):
    vals += [str(rec[0] / 10000), ",", str(round(rec[1])), " "]
    min_y = min(min_y, rec[1])
    max_y = max(max_y, rec[1])

size = "%s %s %s %s" % (vals[0], round(min_y), vals[-4], round(max_y))
print(size)

s = ('<svg width="100%" height="100%" viewBox="' + size + '"><polyline stroke="#979797" fill="none" stroke-width="1" '
     'points="' + "".join(vals[:-1]) + '"/>'
     '</svg>')

f = open("data.html", "w")
f.write(s)
f.close()
 def __init__(self):
     self.db = DBConnector()
Beispiel #30
0
class Main():
    def __init__(self):
        self.db = DBConnector()
        self.db.IUD("update core_scheduler set ACTION_DATETIME = NULL")
        self.db.commit()
        
        print("-- Предстоящие задачи --")
        for row in self.db.select("select ID, COMM, ACTION, ACTION_DATETIME, INTERVAL_TIME_OF_DAY, INTERVAL_DAY_OF_TYPE, INTERVAL_TYPE from core_scheduler"):
            next_time = self.parse_time(None, str(row[4], "utf-8"), str(row[5], "utf-8"), row[6])
            print("[%s] %s" % (datetime.datetime.fromtimestamp(next_time), str(row[1], "utf-8")))
        print("------------------------")
        self.check_time()
        self.run()

    def check_time(self):
        now = datetime.datetime.now().timestamp()
        for row in self.db.select("select ID, COMM, ACTION, ACTION_DATETIME, INTERVAL_TIME_OF_DAY, INTERVAL_DAY_OF_TYPE, INTERVAL_TYPE from core_scheduler"):
            next_time = None
            if row[3] == None: # Это обнуленная дата - будет перещитана в холостую относительно текущей
                next_time = self.parse_time(None, str(row[4], "utf-8"), str(row[5], "utf-8"), row[6])
            elif row[3].timestamp() <= now: # Это дата, что пришла для выполнения. Выполняем и перещитываем.
                next_time = self.parse_time(row[3].timestamp(), str(row[4], "utf-8"), str(row[5], "utf-8"), row[6])
                self.execute(str(row[1], "utf-8"), str(row[2], "utf-8"))            
            if next_time != None:
                #self.db.IUD("update core_scheduler set ACTION_DATETIME = FROM_UNIXTIME(%s) where ID = %s" % (next_time, row[0]))
                d_s = datetime.datetime.fromtimestamp(next_time).strftime("%Y-%m-%d %H:%M:%S")
                self.db.IUD("update core_scheduler set ACTION_DATETIME = '%s' where ID = %s" % (d_s, row[0]))
                self.db.commit()

    def calc_suntime(self, d, sun_type):
        st = GetSunTime(d // (24 * 3600), 49.697287, 34.354388, 90.8333333333333, (-time.altzone // 3600) - 1, sun_type)
        hour = math.trunc(st)
        minutes = round((st - hour) * 60)
        return (hour * 60 + minutes) * 60

    def parse_time(self, action_datetime, time_of_day, day_of_type, int_type):
        if action_datetime == None:
            action_datetime = datetime.datetime.now().timestamp();
        
        now = datetime.datetime.now()
        now = datetime.datetime(now.year, now.month, now.day)
        
        times = []
        dates = []

        time_type = ""
        try:
            time_of_day.upper().index("SUNRISE")
            time_type = "Sunrise"
        except:
            pass

        try:
            time_of_day.upper().index("SUNSET")
            time_type = "Sunset"
        except:
            pass

        if time_type == "Sunrise" or time_type == "Sunset":
            """
            Это особый случай блуждающего времени.
            Сборка даты/времени выполняется здесь отдельно и дальше код
            не пойдет.
            """
            
            d1 = now.timestamp()
            d2 = now.timestamp() + 24 * 3600
            dt = [d1 + self.calc_suntime(d1, time_type),
                  d2 + self.calc_suntime(d2, time_type)]

            dt.sort()

            # Проверяем какая дата из расписания готова к выполнению
            for d in dt:
                if d > action_datetime:
                    return d
            return None
        else:
            # Получаем список времени в секундах
            for t in time_of_day.split(","):
                m = t.split(":")
                hour = int(m[0].strip()) * 60
                minutes = 0
                try:
                    minutes = int(m[1].strip())
                except:
                    pass
                sec = 0
                try:
                    sec = int(m[2].strip())
                except:
                    pass
                s = hour + minutes
                times += [s * 60 + sec]
                
        if int_type == 0:
            # Сегодняшняя дата и завтрашняя
            dates += [now.timestamp(), now.timestamp() + 24 * 3600]
        elif int_type == 1:
            # Получаем дату понедельника этой недели в секундах
            dw = now.timestamp() - now.weekday() * 24 * 3600
            # Получаем дату понедельника следующей недели в секундах
            dw_next = dw + 7 * 24 * 3600
            w = ["пн", "вт", "ср", "чт", "пт", "сб", "вс"]
            for d in day_of_type.split(","):
                s = w.index(d.strip().lower())
                dates += [dw + (s * 24 * 3600)]
                dates += [dw_next + (s * 24 * 3600)]
        elif int_type == 2:
            # Получаем 1 число этого месяца в секундах
            m = datetime.datetime(now.year, now.month, 1).timestamp()
            # Получаем 1 число следующего месяца в секундах
            if now.month < 12:
                m_next = datetime.datetime(now.year, now.month, 1).timestamp()
            else:
                m_next = datetime.datetime(now.year + 1, 1, 1).timestamp()
            
            for d in day_of_type.split(","):
                s = int(d.strip())
                dates += [m + (s * 24 * 3600)]
                dates += [m_next + (s * 24 * 3600)]
                
        elif int_type == 3:            
            for d in day_of_type.split(","):
                m = d.split("-")
                s = datetime.datetime(now.year, int(m[1].strip()), int(m[0].strip())).timestamp()
                dates += [s]
                s_next = datetime.datetime(now.year + 1, int(m[1].strip()), int(m[0].strip())).timestamp()
                dates += [s_next]

        dt = []

        # Собираем дату и время расписания в одно
        for tim in times:
            if len(dates) > 0:
                for dat in dates:
                    dt += [dat + tim]
                
        dt.sort()

        # Проверяем какая дата из расписания готова к выполнению
        for d in dt:
            if d > action_datetime:
                return d
                
        return None

    def execute(self, comm, action):
        self.db.IUD("insert into core_execute (COMMAND) values ('%s')" % action)
        self.db.commit()

        print("[%s] Произошло событие \"%s\"" % (time.strftime("%d-%m-%Y %H:%M"), comm))
        print("                   и запрошена команда %s" % (action))

    def run(self):
        while True:
            self.check_time()
            time.sleep(1)
Beispiel #31
0
 def test_empty_db_name(self):
     connector = DBConnector(db_name=self.test_empty_db)
     self.assertIsNone(connector.connection)
     connection = connector.get_connection()
     self.assertIsNone(connection)
Beispiel #32
0
class Main():
    ALARM_FILES = []
    ALARM_LOOPS = 5
    
    def __init__(self):
        self.player = False
        self.db = DBConnector()
        self.timer_id = 101
        self.timer_on = 102
        self.timer_len = 0.5
        self.get_start_time()
        self.volume = 0
        self.run()

    def _curr_time(self, curr = True):
        if curr:
            return time.strftime("%d-%m-%Y %H:%M:%S", time.localtime())
        else:
            return time.strftime("%d-%m-%Y %H:%M:%S", time.localtime(self.time_start))

    def get_start_time(self):
        for row in self.db.select("select VALUE from core_variables where ID = %s" % (self.timer_id)):
            lt = time.localtime()
            h = math.floor(row[0])
            m = round((row[0] - h) * 60)
            self.time_start = time.mktime((lt.tm_year, lt.tm_mon, lt.tm_mday, h, m, 0, 0, 0, lt.tm_isdst))
            if time.time() > self.time_start:
                self.time_start += 24 * 3600
            print("Время будильника установлено на: %s" % self._curr_time(False))
            
    def check_time(self):
        if time.time() >= self.time_start:
            self.db.IUD("call CORE_SET_VARIABLE(%s, %s, null)" % (self.timer_on, 1))
            self.db.commit()
            self.get_start_time()
        
    def run(self):        
        while True:
            for row in self.db.variable_changes():
                if row[1] == self.timer_id:
                    try:
                        self.time_start = row[2]
                        self.get_start_time()                        
                    except:
                        pass
                elif row[1] == self.timer_on:
                    if row[2]:
                        print("%s   Начали будить" % self._curr_time())
                        self.start()
                    else:
                        self.user_stop()
                elif row[3] == 2: #Реакция на любой выключатель
                    self.user_stop()

            if self.player:
                self.volume += 1
                if self.volume > 60:
                    self.volume = 60
                self.send_cmd("volume %s 100" % round(40 + self.volume))

            self.check_time()

            time.sleep(1)

    def user_stop(self):
        if self.player:
            print("%s   Проснулись" % self._curr_time())
        self.stop()

    def start(self):
        if self.player:
            return
        self.volume = 0
        self.player = Popen(["mplayer", "-slave", "-quiet", "-loop", str(Main.ALARM_LOOPS), "-volume", "0"] + Main.ALARM_FILES,
                             stdin=PIPE, stdout=PIPE, stderr=PIPE)

    def stop(self):
        self.send_cmd("q")
        self.player = False

    def send_cmd(self, cmd):
        if self.player:
            try:
                self.player.stdin.write((cmd + "\n").encode("utf-8"))
                self.player.stdin.flush()
            except:
                self.player = False
                print("%s   Не разбудили" % self._curr_time())
 def setUp(self):
     if os.environ.get('TRAVIS') == None:
         self.db = DBConnector()
Beispiel #34
0
from db_connector import DBConnector, GitHubData, PackageManagerData
from config import Config
from github import GitHub
from package_managers import PackageManagers
from sendgrid_email import SendGrid

config = Config()
db = DBConnector()
github = GitHub()
pm = PackageManagers()
sg = SendGrid()


def update(send_email=True):
    # Update the DB with the GitHub repo data
    for repo in config.github_repos:
        github.update_library_data(config.github_user, repo)

    # Update the DB with Package Manager data
    pm.update_package_manager_data(config.package_manager_urls)

    # Export tables as CSV if config file indicates to do so
    if config.export_github:
        db.export_table_to_csv(GitHubData)
    if config['export_tables']['PackageManagers']:
        db.export_table_to_csv(PackageManagerData)

    if not send_email:
        return

    # Send an email update
 def setUp(self):
     if os.environ.get('TRAVIS') == None:
         self.pm = PackageManagers()
         self.db = DBConnector()
         self.config = Config()
 def setUp(self):
     if os.environ.get('TRAVIS') == None:
         self.pm = PackageManagers()
         self.db = DBConnector()
         self.config = Config()
Beispiel #37
0
class Main():
    SERIAL_PORT = "/dev/ttyUSB0"
    SERIAL_SPEED = 57600

    PACK_SYNC = 1
    PACK_COMMAND = 2
    PACK_ERROR = 3

    def __init__(self):
        self.fast_timeput = 0.05
        self.check_lan_error = False
        self.sync_error_counter = []
        
        # Connect to serial port
        try:
            self.serialPort = serial.Serial(self.SERIAL_PORT, self.SERIAL_SPEED, parity='O', timeout=self.fast_timeput)
        except:
            print("Ошибка подключения к '%s'" % self.SERIAL_PORT)

        self.db = DBConnector()
        self.db.load_controllers()
        self.queue = []

        # Run main loop
        self.run()

    def send_pack(self, dev_id, pack_type, pack_data, flush=True):
        buf = json.dumps([dev_id, pack_type, pack_data]).encode("utf-8")
        buf += bytearray([0x0])

        c = 5
        for err in range(c):
            self.serialPort.write(buf)
            if flush:
                self.serialPort.flush()
            #print(buf)
            res = self.check_lan()
            if self.check_lan_error == False:
                break
            if err < (c - 1):
                self.check_lan_error = False
        return res

    def _store_variable_to_db(self, dev_id, pack_data):
        for var in pack_data:
            if len(var) > 1:
                self.db.set_variable_value(var[0], var[1], dev_id)

    def check_lan(self):
        try:
            buf = self.serialPort.readline()
            if len(buf) > 0:
                #print(buf)
                resp = buf.decode("utf-8")
                data = []
                for pack in resp.split(chr(0x0)):
                    if len(pack) > 0:
                        d = json.loads(pack)
                        data += [d]
                        if d[1] == self.PACK_ERROR:
                            self.check_lan_error = True
                            for s in d[2]:
                                self._command_info("%s" % s)
                return data
            else:
                return False
        except Exception as e:
            self.check_lan_error = True
            self._command_info("EXCEPT {}".format(e.args))
            return False

    def _sync_variables(self):
        # Зачитываем изменения в БД
        var_data = self.db.variable_changes()

        # Рассылаем изменения в БД и паралельно читаем обновления
        for dev in self.db.controllers:
            se_ignore = False
            for i in range(len(self.sync_error_counter)):
                if self.sync_error_counter[i][0] == dev[0]:
                    self.sync_error_counter[i][1] -= 1
                    if self.sync_error_counter[i][1] == 0:
                        del self.sync_error_counter[i]
                    else:
                        se_ignore = True

            if se_ignore == False:
                pack_data = []
                lt = time.localtime()
                t = time.mktime((2000, 1, 1, 0, 0, 0, 0, 0, lt.tm_isdst))
                pack_data += [[-100, round(time.time() - t)]] #Передаем системное время в контроллеры
                for var in var_data:
                    if var[2] != dev[0]:
                        pack_data += [[var[0], var[1]]]

                date = datetime.datetime.now().strftime('%H:%M:%S')
                print("[%s] SYNC. '%s': " % (date, dev[1]), end="")
                cl = self.send_pack(dev[0], self.PACK_SYNC, pack_data)
                if cl:
                    for res_pack in cl:
                        if res_pack[2] == "RESET":
                            print("RESET ", end="")
                            is_ok = self.send_pack(dev[0], self.PACK_SYNC, self._reset_pack()) != False
                            for r in range(30):
                                if self.check_lan():
                                    is_ok = True
                                    break
                            if is_ok:
                                print("OK\n")
                            else:
                                print("ERROR\n")
                                self.sync_error_counter += [[dev[0], 30]]
                        else:
                            self._store_variable_to_db(res_pack[0], res_pack[2])
                            print("OK")
                            print("   >> ", pack_data)
                            print("   << ", res_pack[2], "\n")
                else:
                    print("ERROR\n")
                    self.sync_error_counter += [[dev[0], 30]]

    def _reset_pack(self):
        return self.db.all_variables();

    def _command_info(self, text, replace_text = None):
        text = text.replace("'", "`")
        text = text.replace('"', '\"')
        s = self.db.get_property('RS485_COMMAND_INFO')
        if replace_text == None:
            text = text.replace("<", "&lt;")
            text = text.replace(">", "&gt;")
            print(text)
            self.db.set_property('RS485_COMMAND_INFO', s + '<p>' + text + '</p>')
        else:
            self.db.set_property('RS485_COMMAND_INFO', s.replace(text, replace_text))

    def _send_commands(self):
        command = self.db.get_property('RS485_COMMAND')

        if command == "":
            return

        self.db.set_property('RS485_COMMAND_INFO', '')
        
        for dev in self.db.controllers:            
            error_text = "Контроллер '%s' не ответил." % dev[1]

            if command == "SCAN_OW":
                self._command_info("Запрос поиска OneWire устройств для контроллера '%s'..." % dev[1])
                if self.send_pack(dev[0], self.PACK_COMMAND, ["SCAN_ONE_WIRE", ""]):
                    self._command_info("Пауза 3с...")
                    time.sleep(3)
                    self._command_info("Запрос списка найденых на шине OneWire устройств для контроллера '%s'" % dev[1])
                    is_ok = False
                    for res_pack in self.send_pack(dev[0], self.PACK_COMMAND, ["LOAD_ONE_WIRE_ROMS", ""]):
                        count = 0
                        allCount = len(res_pack[2][1])
                        is_ok = True
                        for rom in res_pack[2][1]:
                            rom_s = []
                            for r in rom:
                                ss = hex(r).upper()
                                if len(ss) == 3:
                                    ss = ss.replace("0X", "0x0")
                                else:
                                    ss = ss.replace("0X", "0x")
                                rom_s += [ss]
                                rom_s += [", "]
                            self._command_info("".join(rom_s[:-1]))
                            if self.db.append_scan_rom(dev[0], rom):
                                count += 1
                        self._command_info("Всего найдено устройств: %s. Новых: %s" % (allCount, count))
                        
                    if is_ok == False:
                        self._command_info(error_text)
                else:
                    self._command_info(error_text)
            elif command == "CONFIG_UPDATE":
                self.serialPort.timeout = 2
                time.sleep(2)
                try:
                    self._command_info("CONFIG FILE UPLOAD '%s'..." % dev[1])
                    #pack_data = self._str_to_hex(generate_config_file(self.db))
                    pack_data = generate_config_file(self.db)
                    self._command_info(str(len(pack_data)) + ' bytes.')

                    #bts = 512
                    bts = 1024
                    cou = math.ceil(len(pack_data) / bts)
                    is_ok = False
                    c_pack = self.send_pack(dev[0], self.PACK_COMMAND, ["SET_CONFIG_FILE", cou, False], False)
                    if c_pack and self.check_lan_error == False:
                        prev_command = "Начало загрузки..."
                        self._command_info(prev_command)
                        for i in range(cou):
                            t = i * bts
                            s = pack_data[t:t + bts]
                            c_pack = self.send_pack(dev[0], self.PACK_COMMAND, ["SET_CONFIG_FILE", i + 1, s], i == cou - 1)
                            if c_pack != False and self.check_lan_error or (i == cou - 1):
                                is_ok = True
                                if i != cou - 1:
                                    #Значит не долили файл
                                    self._command_info("ВНИМАНИЕ: Загрузка прервана");
                                break
                            else:
                                new_command = self._gen_text_progress(i, cou)
                                self._command_info(prev_command, new_command)
                                prev_command = new_command                                
                        self._command_info(prev_command, self._gen_text_progress(cou, cou))
                        
                    if is_ok:
                        self._command_info("OK")
                    else:
                        self._command_info(error_text)
                except:
                    pass
                self.serialPort.timeout = self.fast_timeput
                self.check_lan_error = False
            elif command == "REBOOT_CONTROLLERS":
                self.serialPort.timeout = 1
                self._command_info("Запрос перезагрузки контроллера '%s'..." % dev[1])
                if self.send_pack(dev[0], self.PACK_COMMAND, ["REBOOT_CONTROLLER", ""]):
                    self._command_info("OK")
                else:
                    self._command_info(error_text)
                self.serialPort.timeout = self.fast_timeput
            elif command == "GET_OW_VALUES":
                pass
                
        self.db.set_property('RS485_COMMAND', '')
        self._command_info("Готово.")
        time.sleep(2)
        self._command_info("TERMINAL EXIT")

    def _gen_text_progress(self, pos, max_pos):
        i = round(pos * 100 / max_pos)
        s = "<center>["
        s += ("<span style=\"color:#ffffff;\">|</span>") * (i + 1)
        s += ("<span style=\"color:#000000;\">|</span>") * (100 - i - 1)
        s += "] " + str(i) + "% </center>"
        return s

    """
    def _str_to_hex(self, text):
        res = []
        for c in text:
            s = hex(ord(c)).replace('0x', '')
            if len(s) == 1:
                s = '0' + s
            res += [s]
        return "".join(res)
    """

    SYNC_STATE = ""
            
    def run(self):
        serialPort = self.serialPort        
        while True:
            # Синхронизируем переменные между сервером и контроллерами
            SYNC_STATE = self.db.get_property('SYNC_STATE')

            stateChange = SYNC_STATE != self.SYNC_STATE
            if SYNC_STATE == "RUN":
                if stateChange:
                    print("Синхронизация запущена")
                try:
                    self._sync_variables()
                except:
                    pass
            else:
                if stateChange:
                    print("Синхронизация остановлена")

            self.SYNC_STATE = SYNC_STATE

            # Рассылаем системные комманды, если требуется
            self._send_commands()
            
            time.sleep(0.1)
 def setUp(self):
     if os.environ.get('TRAVIS') == None:
         self.db = DBConnector()
Beispiel #39
0
class Main():
    def __init__(self):        
        self.prev_val = 0
        #self.play_file("samples/on.wav")
        self.db = DBConnector()
        self.run()

    def play_file(self, file):
        CHUNK = 2048
        FORMAT = pyaudio.paInt16
        CHANNELS = 2
        RATE = 16000

        p = pyaudio.PyAudio()      

        stream = p.open(format=FORMAT,
                        channels=CHANNELS,
                        rate=RATE,
                        output=True)

        f = wave.open(file,'rb')
        prev_filter_val = 0
        while True:            
            data = f.readframes(CHUNK)
            if len(data) > 0:
                samples = numpy.fromstring(data, numpy.int16)
                prev_filter_val = self.sound_processor(samples, prev_filter_val)
                stream.write(numpy.fromstring(samples, numpy.int8))
            else:
                break;
            
        stream.stop_stream()
        stream.close()

        f.close()
        p.terminate()

    def sound_processor(self, data, pv):
        res = pv
        for i in range(len(data)):            
            val = data[i]
            """
            # Фильтруем высокие частоты
            c = pv + (val - pv) // 2
            val = c
            """
            # Корректируем громкость
            val = val * 2
            if val > 32000:
                val = 32000
            elif val < -32000:
                val = -32000
                
            data[i] = val
            res = pv
        return res

    def run(self):
        while True:
            for row in self.db.variable_changes():
                if row[3] == 1:
                    try:
                        self.play_file("samples/part_%s.wav" % (row[4]))
                    except:
                        pass
                    if row[2]:
                        self.play_file("samples/on.wav")
                    else:
                        self.play_file("samples/off.wav")
            time.sleep(0.1)
 def setUp(self):
     if os.environ.get('TRAVIS') == None:
         self.github = GitHub()
         self.db = DBConnector()
         self.config = Config()
Beispiel #41
0
from db_connector import DBConnector
from datetime import datetime

db = DBConnector()

date_from = datetime.now().timestamp() // 1 - 3600 * 24 * 15

all_count = 0
for rec in db.select("select COUNT(*) "
                     "  from core_variable_changes c, core_variables v "
                     " where c.VARIABLE_ID = v.ID "
                     "   and v.APP_CONTROL in (4, 13, 14, 11)"
                     "   and UNIX_TIMESTAMP(c.CHANGE_DATE) > %s" %
                     (date_from)):
    all_count = rec[0]

print("ВСЕГО ЗАПИСЕЙ: %s" % (all_count))

prev_var_id = -1
prev_var_time = None
prev_var_value = None

exit_check = False
values = []


def check_values(values, new_value):
    if len(values) > 1:
        row = values[-2]
        if row[1] == new_value[1]:
            return True
Beispiel #42
0
from db_connector import DBConnector

db = DBConnector()

all_count = 0
for rec in db.select("select COUNT(*) from core_variable_changes"):
    all_count = rec[0]

print("ВСЕГО ЗАПИСЕЙ: %s" % (all_count))

db.query("update core_variable_changes"
         "   set value = ROUND(value * 10) / 10"
         " where VARIABLE_ID = 153 ")
db.commit()

prev_var_id = -1
prev_var_value = None

i = 0
curr_count = 0
for row in db.select("select ID, VALUE, VARIABLE_ID "
                     "  from core_variable_changes "
                     " where VARIABLE_ID = 153 "
                     " order by VARIABLE_ID, CHANGE_DATE "):
    if row[2] == prev_var_id:
        if row[1] == prev_var_value:
            db.query("delete from core_variable_changes where ID = %s" %
                     (row[0]))
            db.commit()
        else:
            prev_var_value = row[1]
Beispiel #43
0
#!/usr/bin/python3
#-*- coding: utf-8 -*-

import mysql.connector
from db_connector import DBConnector
import time

db = DBConnector()

for rec in db.select("select ID, VALUE from core_variable_changes "
                     " where VARIABLE_ID = 124 "
                     "   and VALUE > 100"):
    b = int(rec[1] * 16)
    if (b & (1<<15)):        
        m = b
        b = 0
        for i in range(16):
            if m & (1<<i) == 0:
                b |= (1<<i)
        b = -b
        b += 1
    print(b / 16)

    db.IUD("update core_variable_changes set VALUE = %s where ID = %s" % ((b / 16), rec[0]))
    db.commit()
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(
        os.getenv("HOST"),
        username=os.getenv("HOST_USER"),
        password=os.getenv("HOST_PASSWORD")
    )

    cmd = "python /opt/stats_collector.py"
    stdin, stdout, stderr = ssh.exec_command(cmd)
    stats = json.loads(stdout.read())

    ssh.close()

    if resource is not None \
            and resource in stats.keys():
        stats = stats[resource]

    return stats


if __name__ == "__main__":
    conn = DBConnector()

    stats = collect_stats()

    for resource in stats.keys():
        conn.submit_stats(resource, stats[resource])

    conn.close()