Пример #1
0
def main():
    with app.app_context():
        if daconfig.get('use alembic', True):
            packagedir = pkg_resources.resource_filename(
                pkg_resources.Requirement.parse('docassemble.webapp'),
                'docassemble/webapp')
            if not os.path.isdir(packagedir):
                sys.exit("path for running alembic could not be found")
            from alembic.config import Config
            from alembic import command
            alembic_cfg = Config(os.path.join(packagedir, 'alembic.ini'))
            alembic_cfg.set_main_option("sqlalchemy.url",
                                        alchemy_connection_string())
            alembic_cfg.set_main_option("script_location",
                                        os.path.join(packagedir, 'alembic'))
            if not db.engine.has_table(dbtableprefix + 'alembic_version'):
                command.stamp(alembic_cfg, "head")
            if db.engine.has_table(dbtableprefix + 'user'):
                command.upgrade(alembic_cfg, "head")
        #db.drop_all()
        try:
            sys.stderr.write("Trying to create tables\n")
            db.create_all()
        except:
            sys.stderr.write(
                "Error trying to create tables; trying a second time.\n")
            try:
                db.create_all()
            except:
                sys.stderr.write(
                    "Error trying to create tables; trying a third time.\n")
                db.create_all()
        populate_tables()
        db.engine.dispose()
Пример #2
0
def main():
    #import docassemble.webapp.database
    start_time = time.time()
    from docassemble.webapp.app_object import app
    with app.app_context():
        from docassemble.webapp.db_object import db
        from docassemble.webapp.packages.models import Package
        from sqlalchemy import select
        #app.config['SQLALCHEMY_DATABASE_URI'] = docassemble.webapp.database.alchemy_connection_string()
        if mode == 'initialize':
            sys.stderr.write("update: updating with mode initialize after " +
                             str(time.time() - start_time) + " seconds\n")
            update_versions(start_time=start_time)
            any_package = db.session.execute(
                select(Package).filter_by(active=True)).first()
            if any_package is None:
                add_dependencies(1, start_time=start_time)
                update_versions(start_time=start_time)
            check_for_updates(start_time=start_time, invalidate_cache=False)
            remove_inactive_hosts(start_time=start_time)
        else:
            sys.stderr.write(
                "update: updating with mode check_for_updates after " +
                str(time.time() - start_time) + " seconds\n")
            check_for_updates(start_time=start_time)
            if USING_SUPERVISOR:
                SUPERVISORCTL = daconfig.get('supervisorctl', 'supervisorctl')
                container_role = ':' + os.environ.get('CONTAINERROLE',
                                                      '') + ':'
                if re.search(r':(web|celery|all):', container_role):
                    sys.stderr.write("update: sending reset signal after " +
                                     str(time.time() - start_time) +
                                     " seconds\n")
                    args = [
                        SUPERVISORCTL, '-s', 'http://localhost:9001', 'start',
                        'reset'
                    ]
                    subprocess.run(args, check=False)
                else:
                    sys.stderr.write(
                        "update: not sending reset signal because not web or celery after "
                        + str(time.time() - start_time) + " seconds\n")
            else:
                sys.stderr.write("update: touched wsgi file after " +
                                 str(time.time() - start_time) + " seconds\n")
                wsgi_file = daconfig.get(
                    'webapp', '/usr/share/docassemble/webapp/docassemble.wsgi')
                if os.path.isfile(wsgi_file):
                    with open(wsgi_file, 'a', encoding='utf-8'):
                        os.utime(wsgi_file, None)
        db.engine.dispose()
    sys.exit(0)
Пример #3
0
def main():
    with app.app_context():
        if daconfig.get('use alembic', True):
            packagedir = pkg_resources.resource_filename(pkg_resources.Requirement.parse('docassemble.webapp'), 'docassemble/webapp')
            if not os.path.isdir(packagedir):
                sys.exit("path for running alembic could not be found")
            from alembic.config import Config
            from alembic import command
            alembic_cfg = Config(os.path.join(packagedir, 'alembic.ini'))
            alembic_cfg.set_main_option("sqlalchemy.url", alchemy_connection_string())
            alembic_cfg.set_main_option("script_location", os.path.join(packagedir, 'alembic'))
            if not db.engine.has_table(dbtableprefix + 'alembic_version'):
                command.stamp(alembic_cfg, "head")
            if db.engine.has_table(dbtableprefix + 'user'):
                command.upgrade(alembic_cfg, "head")
        #db.drop_all()
        db.create_all()
        populate_tables()
        db.engine.dispose()
Пример #4
0
        if len(a) == 2:
            #sys.stderr.write("Found " + a[0] + " which was " + a[1] + "\n")
            results[a[0]] = a[1]
    for key in ['Name', 'Home-page', 'Version']:
        if key not in results:
            results[key] = None
    sys.stderr.write("get_pip_info: returning after " +
                     str(time.time() - start_time) + " seconds")
    return results


if __name__ == "__main__":
    #import docassemble.webapp.database
    start_time = time.time()
    from docassemble.webapp.app_object import app
    with app.app_context():
        from docassemble.webapp.db_object import db
        from docassemble.webapp.packages.models import Package, Install, PackageAuth
        from docassemble.webapp.daredis import r
        #app.config['SQLALCHEMY_DATABASE_URI'] = docassemble.webapp.database.alchemy_connection_string()
        if mode == 'initialize':
            sys.stderr.write("updating with mode initialize after " +
                             str(time.time() - start_time) + " seconds\n")
            update_versions(start_time=start_time)
            any_package = Package.query.filter_by(active=True).first()
            if any_package is None:
                add_dependencies(1, start_time=start_time)
                update_versions(start_time=start_time)
            check_for_updates(doing_startup=True,
                              start_time=start_time,
                              invalidate_cache=False)
Пример #5
0
def main():
    from docassemble.webapp.database import dbprefix
    if dbprefix.startswith('postgresql') and not daconfig.get(
            'force text to varchar upgrade', False):
        do_varchar_upgrade = False
    else:
        do_varchar_upgrade = True
    with app.app_context():
        if daconfig.get('use alembic', True):
            if do_varchar_upgrade:
                changed = False
                if db.engine.has_table(dbtableprefix + 'userdict'):
                    db.session.query(UserDict).filter(
                        db.func.length(UserDict.filename) > 255).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'userdictkeys'):
                    db.session.query(UserDictKeys).filter(
                        db.func.length(UserDictKeys.filename) > 255).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'chatlog'):
                    db.session.query(ChatLog).filter(
                        db.func.length(ChatLog.filename) > 255).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'uploads'):
                    db.session.query(Uploads).filter(
                        db.func.length(Uploads.filename) > 255).delete(
                            synchronize_session=False)
                    db.session.query(Uploads).filter(
                        db.func.length(Uploads.yamlfile) > 255).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'objectstorage'):
                    db.session.query(ObjectStorage).filter(
                        db.func.length(ObjectStorage.key) > 1024).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'speaklist'):
                    db.session.query(SpeakList).filter(
                        db.func.length(SpeakList.filename) > 255).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'shortener'):
                    db.session.query(Shortener).filter(
                        db.func.length(Shortener.filename) > 255).delete(
                            synchronize_session=False)
                    db.session.query(Shortener).filter(
                        db.func.length(Shortener.key) > 255).delete(
                            synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'machinelearning'):
                    db.session.query(MachineLearning).filter(
                        db.func.length(MachineLearning.key) > 1024).delete(
                            synchronize_session=False)
                    db.session.query(MachineLearning).filter(
                        db.func.length(MachineLearning.group_id) > 1024
                    ).delete(synchronize_session=False)
                    changed = True
                if db.engine.has_table(dbtableprefix + 'globalobjectstorage'):
                    db.session.query(GlobalObjectStorage).filter(
                        db.func.length(GlobalObjectStorage.key) > 1024).delete(
                            synchronize_session=False)
                    changed = True
                if changed:
                    db.session.commit()
            packagedir = pkg_resources.resource_filename(
                pkg_resources.Requirement.parse('docassemble.webapp'),
                'docassemble/webapp')
            if not os.path.isdir(packagedir):
                sys.exit("path for running alembic could not be found")
            from alembic.config import Config
            from alembic import command
            alembic_cfg = Config(os.path.join(packagedir, 'alembic.ini'))
            alembic_cfg.set_main_option("sqlalchemy.url",
                                        alchemy_connection_string())
            alembic_cfg.set_main_option("script_location",
                                        os.path.join(packagedir, 'alembic'))
            if not db.engine.has_table(dbtableprefix + 'alembic_version'):
                start_time = time.time()
                sys.stderr.write("Creating alembic stamp\n")
                command.stamp(alembic_cfg, "head")
                sys.stderr.write("Done creating alembic stamp after " +
                                 str(time.time() - start_time) + " seconds\n")
            if db.engine.has_table(dbtableprefix + 'user'):
                start_time = time.time()
                sys.stderr.write("Creating alembic stamp\n")
                sys.stderr.write("Running alembic upgrade\n")
                command.upgrade(alembic_cfg, "head")
                sys.stderr.write("Done running alembic upgrade after " +
                                 str(time.time() - start_time) + " seconds\n")
        #db.drop_all()
        start_time = time.time()
        try:
            sys.stderr.write("Trying to create tables\n")
            db.create_all()
        except:
            sys.stderr.write(
                "Error trying to create tables; trying a second time.\n")
            try:
                db.create_all()
            except:
                sys.stderr.write(
                    "Error trying to create tables; trying a third time.\n")
                db.create_all()
        sys.stderr.write("Finished creating tables after " +
                         str(time.time() - start_time) + " seconds.\n")
        populate_tables()
        db.engine.dispose()
Пример #6
0
import os
import sys
import re
if __name__ == "__main__":
    import docassemble.base.config
    docassemble.base.config.load(arguments=sys.argv)
from docassemble.webapp.app_object import app
from docassemble.webapp.db_object import db
from docassemble.webapp.core.models import Supervisors

def main():
    from docassemble.base.config import hostname
    supervisor_url = os.environ.get('SUPERVISOR_SERVER_URL', None)
    if supervisor_url:
        Supervisors.query.filter_by(hostname=hostname).delete()
        db.session.commit()
        new_entry = Supervisors(hostname=hostname, url="http://" + hostname + ":9001", role=os.environ.get('CONTAINERROLE', None))
        db.session.add(new_entry)
        db.session.commit()

if __name__ == "__main__":
    #import docassemble.webapp.database
    with app.app_context():
        #app.config['SQLALCHEMY_DATABASE_URI'] = docassemble.webapp.database.alchemy_connection_string()
        main()
        db.engine.dispose()

Пример #7
0
def main():
    logmessage("create_tables.main: starting")
    start_time = time.time()
    if dbprefix.startswith('postgresql') and not daconfig.get(
            'force text to varchar upgrade', False):
        do_varchar_upgrade = False
    else:
        do_varchar_upgrade = True
    with app.app_context():
        logmessage("create_tables.main: inside app context after " +
                   str(time.time() - start_time) + " seconds.")
        if daconfig.get('use alembic', True):
            logmessage("create_tables.main: running alembic after " +
                       str(time.time() - start_time) + " seconds.")
            insp = inspect(db.engine)
            if do_varchar_upgrade:
                changed = False
                if insp.has_table(dbtableprefix + 'userdict'):
                    db.session.execute(
                        delete(UserDict).where(
                            db.func.length(UserDict.filename) > 255).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'userdictkeys'):
                    db.session.execute(
                        delete(UserDictKeys).where(
                            db.func.length(UserDictKeys.filename) > 255).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'chatlog'):
                    db.session.execute(
                        delete(ChatLog).where(
                            db.func.length(ChatLog.filename) > 255).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'uploads'):
                    db.session.execute(
                        delete(Uploads).where(
                            db.func.length(Uploads.filename) > 255).
                        execution_options(synchronize_session=False))
                    db.session.execute(
                        delete(Uploads).where(
                            db.func.length(Uploads.yamlfile) > 255).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'objectstorage'):
                    db.session.execute(
                        delete(ObjectStorage).where(
                            db.func.length(ObjectStorage.key) > 1024).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'speaklist'):
                    db.session.execute(
                        delete(SpeakList).where(
                            db.func.length(SpeakList.filename) > 255).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'shortener'):
                    db.session.execute(
                        delete(Shortener).where(
                            db.func.length(Shortener.filename) > 255).
                        execution_options(synchronize_session=False))
                    db.session.execute(
                        delete(Shortener).where(
                            db.func.length(Shortener.key) > 255).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'machinelearning'):
                    db.session.execute(
                        delete(MachineLearning).where(
                            db.func.length(MachineLearning.key) > 1024).
                        execution_options(synchronize_session=False))
                    db.session.execute(
                        delete(MachineLearning).where(
                            db.func.length(MachineLearning.group_id) > 1024).
                        execution_options(synchronize_session=False))
                    changed = True
                if insp.has_table(dbtableprefix + 'globalobjectstorage'):
                    db.session.execute(
                        delete(GlobalObjectStorage).where(
                            db.func.length(GlobalObjectStorage.key) > 1024).
                        execution_options(synchronize_session=False))
                    changed = True
                if changed:
                    db.session.commit()
            packagedir = pkg_resources.resource_filename(
                pkg_resources.Requirement.parse('docassemble.webapp'),
                'docassemble/webapp')
            if not os.path.isdir(packagedir):
                sys.exit("path for running alembic could not be found")
            alembic_cfg = Config(os.path.join(packagedir, 'alembic.ini'))
            alembic_cfg.set_main_option("sqlalchemy.url",
                                        alchemy_connection_string())
            alembic_cfg.set_main_option("script_location",
                                        os.path.join(packagedir, 'alembic'))
            if not insp.has_table(dbtableprefix + 'alembic_version'):
                logmessage("create_tables.main: creating alembic stamp")
                command.stamp(alembic_cfg, "head")
                logmessage(
                    "create_tables.main: done creating alembic stamp after " +
                    str(time.time() - start_time) + " seconds")
            if insp.has_table(dbtableprefix + 'user'):
                logmessage("create_tables.main: creating alembic stamp")
                logmessage("create_tables.main: running alembic upgrade")
                command.upgrade(alembic_cfg, "head")
                logmessage(
                    "create_tables.main: done running alembic upgrade after " +
                    str(time.time() - start_time) + " seconds")
        #db.drop_all()
        try:
            logmessage("create_tables.main: trying to create tables")
            db.create_all()
        except:
            logmessage(
                "create_tables.main: error trying to create tables; trying a second time."
            )
            try:
                db.create_all()
            except:
                logmessage(
                    "create_tables.main: error trying to create tables; trying a third time."
                )
                db.create_all()
        logmessage("create_tables.main: finished creating tables after " +
                   str(time.time() - start_time) + " seconds.")
        if dbprefix.startswith('postgresql'):
            try:
                test_for_errors(start_time=start_time)
            except:
                logmessage(
                    "create_tables.main: unable to test for errors after " +
                    str(time.time() - start_time) + " seconds.")
        logmessage("create_tables.main: populating tables after " +
                   str(time.time() - start_time) + " seconds.")
        populate_tables(start_time=start_time)
        logmessage("create_tables.main: disposing engine after " +
                   str(time.time() - start_time) + " seconds.")
        db.engine.dispose()
    logmessage("create_tables.main: finishing after " +
               str(time.time() - start_time) + " seconds.")