def main(): args = sys.argv[1:] if 'ARGS' in os.environ: args = os.environ['ARGS'].split(' ') logger.info(datetime.now().strftime('%B %d, %Y - %H:%M:%S %Z')) logger.info('Jet Bridge version {}'.format(VERSION)) if (len(args) >= 1 and args[0] == 'config' ) or missing_options == required_options_without_default: from jet_bridge.utils.create_config import create_config create_config(missing_options == required_options_without_default) return elif len(missing_options) and len(missing_options) < len( required_options_without_default): logger.info('Required options are not specified: {}'.format( ', '.join(missing_options))) return address = 'localhost' if settings.ADDRESS == '0.0.0.0' else settings.ADDRESS url = 'http://{}:{}/'.format(address, settings.PORT) api_url = '{}api/'.format(url) if len(args) >= 1: if args[0] == 'check_token': check_token_command(api_url) return database_connect() from jet_bridge.app import make_app app = make_app() server = HTTPServer(app) server.bind(settings.PORT, settings.ADDRESS) server.start(settings.WORKERS if not settings.DEBUG else 1) if settings.WORKERS > 1 and settings.DEBUG: logger.warning('Multiple workers are not supported in DEBUG mode') logger.info('Starting server at {}'.format(url)) if settings.DEBUG: logger.warning('Server is running in DEBUG mode') logger.info('Quit the server with CONTROL-C') check_token_command(api_url) IOLoop.current().start()
def main(): args = sys.argv[1:] if 'ARGS' in os.environ: args = os.environ['ARGS'].split(' ') logger.info(datetime.now().strftime('%B %d, %Y - %H:%M:%S %Z')) logger.info('Jet Bridge version {}'.format(VERSION)) if (len(args) >= 1 and args[0] == 'config') or missing_options == required_options_without_default: create_config(missing_options == required_options_without_default) return elif len(missing_options) and len(missing_options) < len(required_options_without_default): logger.info('Required options are not specified: {}'.format(', '.join(missing_options))) return if not engine_url: raise Exception('Database configuration is not set') address = 'localhost' if settings.ADDRESS == '0.0.0.0' else settings.ADDRESS url = 'http://{}:{}/'.format(address, settings.PORT) api_url = '{}api/'.format(url) if len(args) >= 1: if args[0] == 'check_token': check_token_command(api_url) return from jet_bridge.app import make_app app = make_app() app.listen(settings.PORT, settings.ADDRESS) logger.info('Starting server at {}'.format(url)) if settings.DEBUG: logger.warning('Server is running in DEBUG mode') logger.info('Quit the server with CONTROL-C') check_token_command(api_url) tornado.ioloop.IOLoop.current().start()
def check_token_command(api_url): try: if not is_token_activated(): logger.warning('[!] Your server token is not activated') logger.warning('[!] Token: {}'.format(settings.TOKEN)) if settings.AUTO_OPEN_REGISTER and api_url.startswith('http'): register_url = '{}register/?token={}'.format( api_url, settings.TOKEN) if webbrowser.open(register_url): logger.warning( '[!] Activation page was opened in your browser - {}'. format(register_url)) else: register_url = '{}register/'.format(api_url) logger.warning( '[!] Go to {} to activate it'.format(register_url)) except RequestException: logger.error('[!] Can\'t connect to Jet Admin API') logger.error('[!] Token verification failed')
# 'project', # 'token', 'database_engine', 'database_name', ] # Parse options.parse_command_line(final=False) if options.config: try: parse_config_file(options, options.config, 'JET', final=False) except IOError as e: if options.config != DEFAULT_CONFIG_PATH: logger.warning(e) parse_environment(options, final=True) missing_options = list( filter(lambda x: x not in options or options[x] is None, required_options)) # Settings ADDRESS = options.address PORT = options.port WORKERS = options.workers DEBUG = options.debug READ_ONLY = options.read_only CONNECTIONS = options.connections AUTO_OPEN_REGISTER = options.auto_open_register
def connect_database(conf): global connections engine_url = build_engine_url(conf) if not engine_url: raise Exception('Database configuration is not set') connection_id = get_connection_id(conf) connection_params_id = get_connection_params_id(conf) if connection_id in connections: if connections[connection_id]['params_id'] == connection_params_id: return connections[connection_id] else: disconnect_database(conf) if conf.get('engine') == 'sqlite': engine = create_engine(engine_url) else: engine = create_engine(engine_url, pool_size=conf.get('connections'), max_overflow=10, pool_recycle=300) Session = scoped_session(sessionmaker(bind=engine)) logger.info('Connected to database engine "{}"'.format(engine_url)) Base.metadata.create_all(engine) def only(table, meta): if conf.get('only') is not None and table not in conf.get('only'): return False if conf.get('except') is not None and table in conf.get('except'): return False return True metadata = MetaData(schema=conf.get('schema') if conf.get('schema') and conf.get('schema') != '' else None) metadata.reflect(engine, only=only) MappedBase = automap_base(metadata=metadata) def name_for_scalar_relationship(base, local_cls, referred_cls, constraint): rnd = get_random_string(4) return referred_cls.__name__.lower() + '_jet_relation' + rnd def name_for_collection_relationship(base, local_cls, referred_cls, constraint): rnd = get_random_string(4) return referred_cls.__name__.lower() + '_jet_collection' + rnd def custom_generate_relationship(base, direction, return_fn, attrname, local_cls, referred_cls, **kw): rnd = get_random_string(4) attrname = attrname + '_jet_ref' + rnd return generate_relationship(base, direction, return_fn, attrname, local_cls, referred_cls, **kw) MappedBase.prepare( name_for_scalar_relationship=name_for_scalar_relationship, name_for_collection_relationship=name_for_collection_relationship, generate_relationship=custom_generate_relationship ) for table_name, table in MappedBase.metadata.tables.items(): if len(table.primary_key.columns) == 0 and table_name not in MappedBase.classes: logger.warning('Table "{}" does not have primary key and will be ignored'.format(table_name)) connections[connection_id] = { 'engine': engine, 'Session': Session, 'MappedBase': MappedBase, 'params_id': connection_params_id } return connections[connection_id]
def database_connect(): global engine_url, engine, Session, MappedBase engine_url = build_engine_url_from_settings() if not engine_url: raise Exception('Database configuration is not set') if settings.DATABASE_ENGINE == 'sqlite': engine = create_engine(engine_url) else: engine = create_engine(engine_url, pool_size=settings.DATABASE_CONNECTIONS, max_overflow=10, pool_recycle=1) Session = scoped_session(sessionmaker(bind=engine)) logger.info('Connected to database engine "{}" with name "{}"'.format( settings.DATABASE_ENGINE, settings.DATABASE_NAME)) Base.metadata.create_all(engine) def only(table, meta): if settings.DATABASE_ONLY is not None and table not in settings.DATABASE_ONLY: return False if settings.DATABASE_EXCEPT is not None and table in settings.DATABASE_EXCEPT: return False return True metadata = MetaData(schema=settings.DATABASE_SCHEMA) metadata.reflect(engine, only=only) MappedBase = automap_base(metadata=metadata) def name_for_scalar_relationship(base, local_cls, referred_cls, constraint): rnd = get_random_string(4) return referred_cls.__name__.lower() + '_jet_relation' + rnd def name_for_collection_relationship(base, local_cls, referred_cls, constraint): rnd = get_random_string(4) return referred_cls.__name__.lower() + '_jet_collection' + rnd def custom_generate_relationship(base, direction, return_fn, attrname, local_cls, referred_cls, **kw): rnd = get_random_string(4) attrname = attrname + '_jet_ref' + rnd return generate_relationship(base, direction, return_fn, attrname, local_cls, referred_cls, **kw) MappedBase.prepare( name_for_scalar_relationship=name_for_scalar_relationship, name_for_collection_relationship=name_for_collection_relationship, generate_relationship=custom_generate_relationship) for table_name, table in MappedBase.metadata.tables.items(): if len(table.primary_key.columns ) == 0 and table_name not in MappedBase.classes: logger.warning( 'Table "{}" does not have primary key and will be ignored'. format(table_name))
def map_data_type(value): for rule in reversed(map_data_types): if isinstance(value, rule['query']): return rule['date_type'] logger.warning('Unknown database type: {}'.format(str(value))) return default_data_type
def on_model_pre_create(self, model, instance): try: model_cls, django_instance = self.get_django_instance(model, instance) pre_save.send(model_cls, raw=True, using=self, instance=django_instance, update_fields=[]) except Exception as e: logger.warning('[!] on_model_pre_create signal failed: {}'.format(str(e)))
def on_model_post_delete(self, model, instance): try: model_cls = self.model_classes.get(model) post_delete.send(model_cls, using=self, instance=self.pre_delete_django_instance) except Exception as e: logger.warning('[!] on_model_post_delete signal failed: {}'.format(str(e)))