def __init__( self, database, host, settings, desktop, nuke = False ): self.database = database self.settings = settings self.desktop = desktop self.main_notebook = None self.anonymous = None if nuke is True: self.database.execute( file( "model/drop.sql" ).read(), commit = False ) if host: self.database.execute( file( "model/schema.sql" ).read(), commit = False ) else: self.database.execute_script( file( "model/schema.sqlite" ).read(), commit = False ) self.create_main_notebook() self.create_anonymous_user() if desktop is True: self.create_desktop_user() self.database.commit() version = Schema_upgrader.version_string_to_tuple( VERSION ) Schema_upgrader.schema_version( database, default_version = version ) self.database.commit()
def __init__(self, database, host, settings, desktop, nuke=False): self.database = database self.settings = settings self.desktop = desktop self.main_notebook = None self.anonymous = None if nuke is True: self.database.execute(file("model/drop.sql").read(), commit=False) if host: self.database.execute(file("model/schema.sql").read(), commit=False) else: self.database.execute_script(file("model/schema.sqlite").read(), commit=False) self.create_main_notebook() self.create_anonymous_user() if desktop is True: self.create_desktop_user() self.database.commit() version = Schema_upgrader.version_string_to_tuple(VERSION) Schema_upgrader.schema_version(database, default_version=version) self.database.commit()
def setUp(self): # make an in-memory sqlite database to use during testing self.connection = Connection_wrapper( sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES, check_same_thread=False)) self.cache = Stub_cache() cursor = self.connection.cursor() cursor.execute(Stub_object.sql_create_table()) self.fake_files = { } # map of fake filename (full path) to fake file contents self.database = Database(self.connection, self.cache) self.upgrader = Schema_upgrader(self.database, glob=self.glob, read_file=self.read_file)
class Test_schema_upgrader(object): def setUp(self): # make an in-memory sqlite database to use during testing self.connection = Connection_wrapper( sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES, check_same_thread=False)) self.cache = Stub_cache() cursor = self.connection.cursor() cursor.execute(Stub_object.sql_create_table()) self.fake_files = { } # map of fake filename (full path) to fake file contents self.database = Database(self.connection, self.cache) self.upgrader = Schema_upgrader(self.database, glob=self.glob, read_file=self.read_file) def tearDown(self): self.database.close() def glob(self, glob_pattern): """ A fake glob function that doesn't use the filesystem. """ re_pattern = re.compile(glob_pattern.replace("*", "[^/]*")) return [ filename for filename in self.fake_files.keys() if re_pattern.search(filename) ] def read_file(self, filename): """ A fake read file function that doesn't use the filesystem. """ contents = self.fake_files.get(filename) if not contents: raise IOError() return contents def test_upgrade_schema(self, to_version=None): if not to_version: to_version = u"5.7.11" self.fake_files = { u"model/delta/5.6.7.sqlite": u"create table new_table ( foo text ); insert into new_table values ( 'hi' );", u"model/delta/5.6.8.sqlite": u"insert into new_table values ( 'bye' );", u"model/delta/5.6.10.sqlite": u"alter table new_table add column bar text;", u"model/delta/5.7.11.sqlite": u"insert into new_table values ( 'whee', 'stuff' );", u"model/delta/5.7.18.sqlite": u"insert into new_table values ( 'more', 'things' );", } self.upgrader.upgrade_schema(to_version) result = self.database.select_many(tuple, u"select * from new_table;") if to_version == u"5.7.11": assert result == [(u"hi", None), (u"bye", None), ("whee", "stuff")] else: assert result == [(u"hi", None), (u"bye", None), ("whee", "stuff"), ("more", "things")] result = self.database.select_many(tuple, u"select * from schema_version;") if to_version == u"5.7.11": assert result == [(5, 7, 11)] else: assert result == [(5, 7, 18)] def test_upgrade_schema_with_schema_version_table(self): self.database.execute( u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );" ) self.database.execute( u"insert into schema_version values ( 0, 0, 0 );") self.test_upgrade_schema() def test_upgrade_schema_with_schema_version_table_and_starting_version( self): self.database.execute( u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );" ) self.database.execute( u"insert into schema_version values ( 5, 6, 6 );") self.fake_files[ u"model/delta/5.6.1.sqlite"] = u"this is not valid sql and should not be executed anyway;" self.fake_files[u"model/delta/5.6.6.sqlite"] = u"also invalid;" self.test_upgrade_schema() def test_upgrade_schema_with_schema_version_table_and_target_version_without_schema( self): self.database.execute( u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );" ) self.database.execute( u"insert into schema_version values ( 0, 0, 0 );") self.test_upgrade_schema(to_version=u"5.7.20") def test_upgrade_schema_with_schema_version_table_and_starting_version_and_target_version_without_schema( self): self.database.execute( u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );" ) self.database.execute( u"insert into schema_version values ( 5, 6, 6 );") self.test_upgrade_schema(to_version=u"5.7.20") def test_upgrade_schema_with_future_ending_version(self): self.fake_files = { u"model/delta/5.6.7.sqlite": u"create table new_table ( foo text ); insert into new_table values ( 'hi' );", u"model/delta/5.6.8.sqlite": u"insert into new_table values ( 'bye' );", u"model/delta/5.6.10.sqlite": u"alter table new_table add column bar text;", u"model/delta/5.7.11.sqlite": u"insert into new_table values ( 'whee', 'stuff' );", u"model/delta/5.7.18.sqlite": u"insert into new_table values ( 'more', 'and more' );", } self.upgrader.upgrade_schema(u"5.8.55") result = self.database.select_many(tuple, u"select * from new_table;") assert result == [(u"hi", None), (u"bye", None), ("whee", "stuff"), ("more", "and more")] result = self.database.select_many(tuple, u"select * from schema_version;") assert result == [(5, 7, 18)] def test_upgrade_schema_twice(self): self.test_upgrade_schema() # the second upgrade should have no effect, because at this point it's already upgraded self.test_upgrade_schema() def test_upgrade_schema_with_filename_with_invalid_version(self): # the filename, not composed of all-integer parts, should be skipped self.fake_files[ u"model/delta/5.6.9b.sqlite"] = u"this is not valid sql and should not be executed anyway;" self.test_upgrade_schema() def test_upgrade_schema_default_to_start_version_of_1_5_4(self): # test that if no schema_version table exists, then the starting version is assumed to be 1.5.4 self.fake_files = { u"model/delta/1.5.3.sqlite": u"invalid sql;", u"model/delta/1.5.4.sqlite": u"should not be invoked;", u"model/delta/1.5.5.sqlite": u"create table new_table ( foo text ); insert into new_table values ( 'hi' );", u"model/delta/1.5.6.sqlite": u"insert into new_table values ( 'bye' );", } self.upgrader.upgrade_schema(u"1.5.6") result = self.database.select_many(tuple, u"select * from new_table;") assert result == [ (u"hi", ), (u"bye", ), ] result = self.database.select_many(tuple, u"select * from schema_version;") assert result == [(1, 5, 6)] def test_apply_schema_delta(self): self.database.execute( u"create table schema_version ( major numeric, minor numeric, \"release\" numeric );" ) self.database.execute( u"insert into schema_version values ( 0, 0, 0 );") self.fake_files = { u"model/delta/5.6.5.sqlite": u"insert into new_table values ( 'should not show up' );", u"model/delta/5.6.7.sqlite": u"create table new_table ( foo text ); insert into new_table values ( 'hi' );", u"model/delta/5.7.18.sqlite": u"insert into new_table values ( 'should not be present' );", } self.upgrader.apply_schema_delta((5, 6, 7), u"model/delta/5.6.7.sqlite") result = self.database.select_many(unicode, u"select * from new_table;") assert result == [u"hi"] result = self.database.select_many(tuple, u"select * from schema_version;") assert result == [(5, 6, 7)] @raises(IOError) def test_apply_schema_delta_with_unknown_file(self): self.upgrader.apply_schema_delta((5, 6, 7), u"model/delta/5.6.7.sqlite") def test_version_string_to_tuple(self): version = self.upgrader.version_string_to_tuple("2.5.13") assert len(version) == 3 assert version[0] == 2 assert version[1] == 5 assert version[2] == 13 def test_version_string_to_tuple_with_extension(self): version = self.upgrader.version_string_to_tuple("2.5.13.sqlite") assert len(version) == 3 assert version[0] == 2 assert version[1] == 5 assert version[2] == 13 @raises(ValueError) def test_version_string_to_tuple_with_too_many_parts(self): version = self.upgrader.version_string_to_tuple("3.14.159.26.5") @raises(ValueError) def test_version_string_to_tuple_with_too_few_parts(self): version = self.upgrader.version_string_to_tuple("3.14") @raises(ValueError) def test_version_string_to_tuple_with_non_integer_part(self): version = self.upgrader.version_string_to_tuple("2.5b.13") @raises(ValueError) def test_version_string_to_tuple_with_empty_part(self): version = self.upgrader.version_string_to_tuple("2..13")
def main(options): change_to_main_dir() cherrypy.config.update(Common.settings) if options.development: from config import Development settings = Development.settings elif options.desktop: from config import Desktop settings = Desktop.settings else: from config import Production settings = Production.settings cherrypy.config.update(settings) # Don't launch web browser if -w flag is set if options.no_webbrowser: launch_browser = False else: launch_browser = cherrypy.config[u"luminotes.launch_browser"] socket.setdefaulttimeout(INITIAL_SOCKET_TIMEOUT_SECONDS) port_filename = cherrypy.config[u"luminotes.port_file"] socket_port = cherrypy.config[u"server.socket_port"] existing_socket_port = port_filename and os.path.exists( port_filename) and file(port_filename).read() or socket_port server_url = u"http://localhost:%s/" % existing_socket_port server_present = True # if requested, attempt to shutdown an existing server and exit if options.kill: try: urllib.urlopen("%sshutdown" % server_url) except urllib.URLError: pass sys.exit(0) # check to see if the server is already running try: urllib.urlopen("%sping" % server_url) except urllib.URLError: server_present = False if server_present is True: print "Luminotes server is already running. aborting" if launch_browser is True: webbrowser.open_new(server_url) sys.exit(0) server_url = u"http://127.0.0.1:%s/" % socket_port # remove the existing log files, if any try: log_access_file = cherrypy.config[u"server.log_access_file"] if log_access_file: os.remove(log_access_file) except OSError: pass try: log_file = cherrypy.config[u"server.log_file"] if log_file: os.remove(log_file) except OSError: pass socket.setdefaulttimeout(SOCKET_TIMEOUT_SECONDS) database = Database( host=cherrypy.config[u"luminotes.db_host"], ssl_mode=cherrypy.config[u"luminotes.db_ssl_mode"], ) # if necessary, upgrade the database schema to match this current version of the code schema_upgrader = Schema_upgrader(database) schema_upgrader.upgrade_schema(to_version=VERSION) cherrypy.lowercase_api = True root = Root(database, cherrypy.config) cherrypy.tree.mount(root, '/', config=settings) cherrypy.engine.start_with_callback( callback, (log_access_file, log_file, server_url, port_filename, socket_port, launch_browser)) cherrypy.engine.block()
def main( options ): change_to_main_dir() cherrypy.config.update( Common.settings ) if options.development: from config import Development settings = Development.settings elif options.desktop: from config import Desktop settings = Desktop.settings else: from config import Production settings = Production.settings cherrypy.config.update( settings ) # Don't launch web browser if -w flag is set if options.no_webbrowser: launch_browser = False else: launch_browser = cherrypy.config[ u"luminotes.launch_browser"] socket.setdefaulttimeout( INITIAL_SOCKET_TIMEOUT_SECONDS ) port_filename = cherrypy.config[ u"luminotes.port_file" ] socket_port = cherrypy.config[ u"server.socket_port" ] existing_socket_port = port_filename and os.path.exists( port_filename ) and file( port_filename ).read() or socket_port server_url = u"http://localhost:%s/" % existing_socket_port server_present = True # if requested, attempt to shutdown an existing server and exit if options.kill: try: urllib.urlopen( "%sshutdown" % server_url ) except urllib.URLError: pass sys.exit( 0 ) # check to see if the server is already running try: urllib.urlopen( "%sping" % server_url ) except urllib.URLError: server_present = False if server_present is True: print "Luminotes server is already running. aborting" if launch_browser is True: webbrowser.open_new( server_url ) sys.exit( 0 ) server_url = u"http://127.0.0.1:%s/" % socket_port # remove the existing log files, if any try: log_access_file = cherrypy.config[ u"server.log_access_file" ] if log_access_file: os.remove( log_access_file ) except OSError: pass try: log_file = cherrypy.config[ u"server.log_file" ] if log_file: os.remove( log_file ) except OSError: pass socket.setdefaulttimeout( SOCKET_TIMEOUT_SECONDS ) database = Database( host = cherrypy.config[ u"luminotes.db_host" ], ssl_mode = cherrypy.config[ u"luminotes.db_ssl_mode" ], ) # if necessary, upgrade the database schema to match this current version of the code schema_upgrader = Schema_upgrader( database ) schema_upgrader.upgrade_schema( to_version = VERSION ) cherrypy.lowercase_api = True root = Root( database, cherrypy.config ) cherrypy.tree.mount(root, '/', config=settings ) cherrypy.engine.start_with_callback( callback, ( log_access_file, log_file, server_url, port_filename, socket_port, launch_browser ) ) cherrypy.engine.block()