def main():
    while True:
        try:
    	    movie = Movie( server.get_server(u'localhost', server_connection, False))
    	    movie.rnd_queries()
	    time.sleep(0.5)
            movie.rnd_user()
	    time.sleep(1)
	except:
	    time.sleep(10)
def main():
    while True:
        try:
    	    movie = Movie( server.get_server(u'localhost', server_connection, False))
    	    movie.rnd_queries()
	    time.sleep(0.5)
            movie.rnd_user()
	    time.sleep(10)
	except:
	    time.sleep(30)
def main():

    # let's add cfg file to deal with the connections
    # file will be /etc/online-migration.cfg
    #
    # content will be like:
    #
    # [world]
    # user=root
    # password=fred
    # host=127.0.0.1
    # port=3340
    #
    # [sysbench]
    # user=test
    # password=test
    # host=127.0.0.1
    # port=3306

    if len(sys.argv) < 2:
        logging.error(
            "A command is needed\ncommands are: init, create, status, checksum, down, up, diff, version"
        )
        sys.exit(1)
    else:
        with capture() as nowhere:
            try:
                migration = OnlineMigration(
                    server.get_server(u'localhost', server_connection, False))
            except Exception, e:
                logging.error("%s" % e[0])
                sys.exit(1)

        if sys.argv[1] == 'init_sysdb':
            migration.init_sysdb()
        elif sys.argv[1] == 'init':
            migration.check_arg()
            migration.check_sys_init()
            migration.init_migration(sys.argv[2])
        elif sys.argv[1] == 'create':
            migration.check_arg(2)
            migration.check_sys_init()
            if len(sys.argv) > 4:
                comment = sys.argv[4]
            else:
                comment = "none"
            migration.create_migration(sys.argv[2], sys.argv[3], comment)
        elif sys.argv[1] == 'status':
            migration.check_arg(0)
            migration.check_sys_init()
            if len(sys.argv) == 3:
                db_name = (sys.argv[2])
            else:
                db_name = None
            migration.status(db_name)
        elif sys.argv[1] == 'checksum':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            checksum = migration.create_checksum(db_name, "0")
            print "%s's current schema checksum = %s" % (db_name, checksum)
        elif sys.argv[1] == 'down':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            last_version = migration.last_migration_version(db_name)
            if len(sys.argv) == 4 and re.search("\d", sys.argv[3]):
                logging.info(u"You want to migrate down %d version(s)" %
                             int(sys.argv[3]))
                tot = 0
                tot_app = migration.applied_migration(db_name)
                if tot_app >= int(sys.argv[3]):
                    while tot < int(sys.argv[3]):
                        last_version = migration.last_migration_version(
                            db_name)
                        migration.migrate_down(db_name, last_version)
                        tot += 1
                else:
                    logging.error(u"Only %d applied migration(s) available !" %
                                  tot_app)
                    sys.exit(1)
            elif len(sys.argv) == 5:
                if sys.argv[3] == 'to' and re.search("\d", sys.argv[4]):
                    logging.info(u"You want to migrate down to version %04d" %
                                 int(sys.argv[4]))
                    if migration.check_version_applied(db_name,
                                                       int(sys.argv[4])):
                        logging.info("Ok this version was applied")
                        while int(last_version) > int(sys.argv[4]):
                            migration.migrate_down(db_name, last_version)
                            last_version = migration.last_migration_version(
                                db_name)
            else:
                if last_version is not None and int(last_version) > 0:
                    migration.migrate_down(db_name, last_version)
                else:
                    logging.error(
                        "Impossible to rollback as nothing was migrated yet !")
                    sys.exit(1)
        elif sys.argv[1] == 'up':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            last_version = migration.last_migration_version(db_name)
            if last_version is None and len(sys.argv) > 3:
                logging.error(
                    "You can only migrate multiple versions when at least one has been already performed"
                )
                sys.exit(1)

            if len(sys.argv) == 4 and re.search("\d", sys.argv[3]):
                logging.info(u"You want to migrate up %d version(s)" %
                             int(sys.argv[3]))
                tot = 0
                tot_pend = migration.pending_migration(db_name, last_version)
                if tot_pend >= int(sys.argv[3]):
                    while tot < int(sys.argv[3]):
                        last_version = migration.last_migration_version(
                            db_name)
                        migration.migrate_up(db_name, last_version)
                        tot += 1
                else:
                    logging.error(u"Only %d pending migration(s) available !" %
                                  tot_pend)
                    sys.exit(1)
            elif len(sys.argv) == 5:
                if sys.argv[3] == 'to' and re.search("\d", sys.argv[4]):
                    logging.info(u"You want to migrate up to version %04d" %
                                 int(sys.argv[4]))
                    if migration.check_version_pending(db_name,
                                                       int(sys.argv[4])):
                        logging.info("Ok this version is pending")
                        while int(last_version) < int(sys.argv[4]):
                            migration.migrate_up(db_name, last_version)
                            last_version = migration.last_migration_version(
                                db_name)
                    else:
                        logging.error(
                            u"This version (%04d) is not available as a pending migration !"
                            % int(sys.argv[4]))
                        sys.exit(1)
            else:
                if last_version is not None:
                    migration.migrate_up(db_name, last_version)
                else:
                    migration.mysql_create_schema(db_name,
                                                  "%s/0000-up.mig" % db_name)
        elif sys.argv[1] == 'diff':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            migration.print_diff(db_name)
        elif sys.argv[1] == 'version':
            print "online-migration.py %s" % version
        elif sys.argv[1] == 'last_version':
            migration.check_arg(1)
            if migration.check_sys_init(0) == 1:
                print -1
            else:
                db_name = (sys.argv[2])
                last_version = migration.last_migration_version(db_name)
                print last_version
def main():
    
    # let's add cfg file to deal with the connections
    # file will be /etc/online-migration.cfg
    #
    # content will be like:
    #
    # [world]
    # user=root
    # password=fred
    # host=127.0.0.1
    # port=3340
    #
    # [sysbench]
    # user=test
    # password=test
    # host=127.0.0.1
    # port=3306 
    
    
    if len(sys.argv) < 2:
        logging.error("A command is needed\ncommands are: init, create, status, checksum, down, up, diff, version")
        sys.exit(1)
    else:
        with capture() as nowhere:
            try:
            	migration = OnlineMigration(
                	server.get_server(u'localhost', server_connection, False))
            except Exception, e:
                logging.error("%s" % e[0])
                sys.exit(1)
	
        if sys.argv[1] == 'init_sysdb':
            migration.init_sysdb()
        elif sys.argv[1] == 'init':
            migration.check_arg()
            migration.check_sys_init()
            migration.init_migration(sys.argv[2])
        elif sys.argv[1] == 'create':
            migration.check_arg(2)
            migration.check_sys_init()
            if len(sys.argv) > 4:
                comment = sys.argv[4]
            else:
                comment = "none"
            migration.create_migration(sys.argv[2], sys.argv[3], comment)
        elif sys.argv[1] == 'status':
            migration.check_arg(0)
            migration.check_sys_init()
            if len(sys.argv) == 3:
                db_name = (sys.argv[2])
            else:
                db_name = None
            migration.status(db_name)
        elif sys.argv[1] == 'checksum':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            checksum = migration.create_checksum(db_name, "0")
            print "%s's current schema checksum = %s" % (db_name, checksum)
        elif sys.argv[1] == 'down':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            last_version = migration.last_migration_version(db_name)
            if len(sys.argv) == 4 and re.search("\d", sys.argv[3]):
                logging.info(u"You want to migrate down %d version(s)" % int(sys.argv[3]))
                tot = 0
                tot_app = migration.applied_migration(db_name)
                if tot_app >= int(sys.argv[3]):
                    while tot < int(sys.argv[3]):
                        last_version = migration.last_migration_version(db_name)
                        migration.migrate_down(db_name, last_version)
                        tot += 1
                else:
                    logging.error(u"Only %d applied migration(s) available !" % tot_app)
                    sys.exit(1)
            elif len(sys.argv) == 5:
                if sys.argv[3] == 'to' and re.search("\d", sys.argv[4]):
                    logging.info(u"You want to migrate down to version %04d" % int(sys.argv[4]))
                    if migration.check_version_applied(db_name, int(sys.argv[4])):
                        logging.info("Ok this version was applied")
                        while int(last_version) > int(sys.argv[4]):
                            migration.migrate_down(db_name, last_version)
                            last_version = migration.last_migration_version(db_name)
            else:
                if last_version is not None and int(last_version) > 0:
                    migration.migrate_down(db_name, last_version)
                else:
                    logging.error("Impossible to rollback as nothing was migrated yet !")
                    sys.exit(1)
        elif sys.argv[1] == 'up':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            last_version = migration.last_migration_version(db_name)
            if last_version is None and len(sys.argv) > 3:
                logging.error("You can only migrate multiple versions when at least one has been already performed")
                sys.exit(1)
             
            if len(sys.argv) == 4 and re.search("\d", sys.argv[3]):
                logging.info(u"You want to migrate up %d version(s)" % int(sys.argv[3]))
                tot = 0
                tot_pend = migration.pending_migration(db_name, last_version)
                if tot_pend >= int(sys.argv[3]):
                    while tot < int(sys.argv[3]):
                        last_version = migration.last_migration_version(db_name)
                        migration.migrate_up(db_name, last_version)
                        tot += 1
                else:
                    logging.error(u"Only %d pending migration(s) available !" % tot_pend)
                    sys.exit(1)
            elif len(sys.argv) == 5:
                if sys.argv[3] == 'to' and re.search("\d", sys.argv[4]):
                    logging.info(u"You want to migrate up to version %04d" % int(sys.argv[4]))
                    if migration.check_version_pending(db_name, int(sys.argv[4])):
                        logging.info("Ok this version is pending")
                        while int(last_version) < int(sys.argv[4]):
                            migration.migrate_up(db_name, last_version)
                            last_version = migration.last_migration_version(db_name)
		    else:
                        logging.error(u"This version (%04d) is not available as a pending migration !" % int(sys.argv[4]))
                        sys.exit(1)
            else:
                if last_version is not None:
                    migration.migrate_up(db_name, last_version)
                else:
                    migration.mysql_create_schema(db_name, "%s/0000-up.mig" % db_name)
        elif sys.argv[1] == 'diff':
            migration.check_arg(1)
            migration.check_sys_init()
            db_name = (sys.argv[2])
            migration.print_diff(db_name)
        elif sys.argv[1] == 'version':
	    print "online-migration.py %s" % version
	elif sys.argv[1] == 'last_version':
            migration.check_arg(1)
            if migration.check_sys_init(0) == 1:
	       	print -1
            else:
            	db_name = (sys.argv[2])
            	last_version = migration.last_migration_version(db_name)
	    	print last_version
Example #5
0
def main():
    for x in range(1, random.randint(5,10)):
    	movie = Movie( server.get_server(u'localhost', server_connection, False))
    	movie.rnd_queries()
	time.sleep(0.5)
Example #6
0
def main():
    for x in range(1, random.randint(5, 10)):
        movie = Movie(server.get_server(u'localhost', server_connection,
                                        False))
        movie.rnd_queries()
        time.sleep(0.5)
def main():
    
    global server_connection
    
    parser = argparse.ArgumentParser(description='Handles the versioning of database schemas')
    parser.add_argument('-i', '--ini', type=argparse.FileType('r'), help='the ini file for the database connection')
    parser.add_argument('-d','--dsn', help='the DSN for the database connection. Format user:passwd@host:port')

    cmdparsers = parser.add_subparsers(title='Valid commands',dest='command',help='Valid commands')
    
    parser_init_sysdb = cmdparsers.add_parser('init_sysdb', help='Creates the online_migration sys schema in the database.')

    parser_init = cmdparsers.add_parser('init', help='Initiate the first migration')
    parser_init.add_argument('databasename', help='The database name.')
    
    parser_create = cmdparsers.add_parser('create', help='Creates a migration')
    parser_create.add_argument('databasename', help='The database name.')
    parser_create.add_argument('filename', type=argparse.FileType('r'), help='The file containing the migration statements.')
    parser_create.add_argument('comment', nargs='?', default="none", help='The comment for this migration.')
    
    parser_status = cmdparsers.add_parser('status', help='Display the status of the migration for all or one schema')
    parser_status.add_argument('databasename', nargs='?', help='The database name.')
    
    parser_checksum = cmdparsers.add_parser('checksum', help='Display checksum for a schema')
    parser_checksum.add_argument('databasename', help='The database name.')
    
    parser_up = cmdparsers.add_parser('up', help='Upgrades a schema schema')
    parser_up.add_argument('databasename', help='The database name.')
    parser_up.add_argument('versionsup', type=int, nargs="?",help='Number of versions to upgrade. Defaults to 1', default='1')
    parser_up.add_argument('-t','--to', type=int, help='The end version of the upgrades')
    
    parser_down = cmdparsers.add_parser('down', help='Downgrades a schema')
    
    parser_down.add_argument('databasename', help='The database name.')
    parser_down.add_argument('versionsdown', nargs="?", type=int, help='Number of versions to downgrade. Defaults to 1', default='1')
    parser_down.add_argument('-t','--to', type=int,help='The end version of the downgrade')
    
    parser_last_version = cmdparsers.add_parser('last_version', help='Prints the last migration version for this database.')
    parser_last_version.add_argument('databasename', help='The database name.')
      
    parser_diff = cmdparsers.add_parser('diff', help='Prints the diff')
    parser_diff.add_argument('databasename', help='The database name.')
        
    parser_version= cmdparsers.add_parser('version', help='Shows this program\'s version number')
    
    args = parser.parse_args(sys.argv[1:])
    # print args
    with capture() as nowhere:
        
        if args.ini is None and args.dsn is None:
            logging.error(u"An ini file or a dsn is required to connect to the database correctly.")
            sys.exit(1)
            
        if args.ini is not None:
            config = ConfigParser.ConfigParser()
            config.read(args.ini.name)
            server_connection = "%s:%s@%s:%s" % (config.get('MySQLServer','user'), config.get('MySQLServer','password'), config.get('MySQLServer','server'), config.get('MySQLServer','port'))

        if args.dsn is not None:
            server_connection = args.dsn
        
        try:
            migration = OnlineMigration(server.get_server(u'online-migration', server_connection, False))
        except Exception, e:
            logging.error("%s" % e[0])
            sys.exit(1)