def start_server(args=None): if args is None: args = sys.argv[1:] if args: mode = args.pop(0) else: mode = "dev" print("Bespin mobwrite worker (mode=" + mode + ")") config.set_profile(mode) if args: config.load_pyconfig(args.pop(0)) if mode == "dev": config.load_pyconfig("devconfig.py") config.activate_profile() app = WSGIMobWrite() app = db_middleware(app) serve(app, config.c.mobwrite_server_address, config.c.mobwrite_server_port, use_threadpool=True)
def _init_data(): global macgyver, someone_else, murdoc config.activate_profile() fsroot = config.c.fsroot if fsroot.exists() and fsroot.basename() == "testfiles": fsroot.rmtree() fsroot.makedirs() app.reset() Base.metadata.drop_all(bind=config.c.dbengine) Base.metadata.create_all(bind=config.c.dbengine) s = config.c.session_factory() someone_else = User.create_user("SomeoneElse", "", "*****@*****.**") murdoc = User.create_user("Murdoc", "", "*****@*****.**") otherproject = get_project(someone_else, someone_else, "otherproject", create=True) otherproject.save_file('foo', 'Just a file to reserve a project') app.post("/register/new/MacGyver", dict(password="******", email="*****@*****.**")) macgyver = User.find_user("MacGyver")
def create_db(): """Creates the development database""" from bespin import config, database, db_versions from migrate.versioning.shell import main config.set_profile('dev') base_url = config.c.dburl config_file = options.server.config_file if config_file.exists(): info("Loading config: %s", config_file) code = compile(config_file.bytes(), config_file, "exec") exec code in {} if config.c.dburl == base_url and path("devdata.db").exists(): raise BuildFailure("Development database already exists") config.activate_profile() dry("Create database tables", database.Base.metadata.create_all, bind=config.c.dbengine) repository = str(path(db_versions.__file__).dirname()) dburl = config.c.dburl result = sh("python bespin/db_versions/manage.py version", capture=True) dry("Turn on migrate versioning", main, ["version_control", "--version", result.rstrip(), dburl, repository])
def editbespin(options): """Use Bespin to edit Bespin. This will change the given user's file location to the directory above Bespin, allowing you to edit Bespin (and any other projects you have in that directory).""" if not 'editbespin' in options or not options.editbespin.user: raise BuildFailure("You must specify a user with -u for this task.") user = options.editbespin.user from bespin import config from bespin import database, filesystem from sqlalchemy.orm.exc import NoResultFound config.set_profile("dev") config.activate_profile() session = config.c.session_factory() try: user = session.query(database.User).filter_by(username=user).one() except NoResultFound: raise BuildFailure("I couldn't find %s in the database. Sorry!" % (user)) location = path.getcwd().parent.abspath() user.file_location = location user.recompute_files() session.commit() bespinsettings_loc = location / "BespinSettings" if not bespinsettings_loc.exists(): project = filesystem.get_project(user, user, "BespinSettings", create=True) project.install_template('usertemplate') info("User %s set up to access directory %s" % (user, location))
def test_register_and_verify_user(): config.activate_profile() _clear_db() s = _get_session() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) assert resp.content_type == "application/json" data = simplejson.loads(resp.body) assert data == {} assert resp.cookies_set['auth_tkt'] assert app.cookies billbixby = User.find_user("BillBixby") sample_project = get_project(billbixby, billbixby, "SampleProject") files = [file.name for file in sample_project.list_files()] assert "readme.txt" in files # should be able to run again without an exception appearing resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******"), status=409) # with the cookie set, we should be able to retrieve the # logged in name resp = app.get('/register/userinfo/') assert resp.content_type == 'application/json' data = simplejson.loads(resp.body) assert data['username'] == 'BillBixby' assert 'quota' in data assert data['quota'] == 15728640 assert 'amountUsed' in data resp = app.get("/file/at/BespinSettings/config") app.post("/file/close/BespinSettings/config")
def start(): """Starts the BespinServer on localhost port 8080 for development. You can change the port and allow remote connections by setting server.port or server.address on the command line. paver server.address=your.ip.address server.port=8000 start will allow remote connections (assuming you don't have a firewall blocking the connection) and start the server on port 8000. """ # automatically install Dojo if it's not there already if not (options.dojo.destination / "dojo").exists(): dojo() from bespin import config, controllers from paste.httpserver import serve options.order('server') config.set_profile('dev') if options.server.try_build: config.c.static_dir = (options.build_dir / "frontend").abspath() if options.server.dburl: config.c.dburl = options.server.dburl if options.server.async: config.c.async_jobs = True config.c.queue_path = path.getcwd() / "queue.db" config.activate_profile() port = int(options.port) serve(controllers.make_app(), options.address, port, use_threadpool=True)
def setup_module(module): if queue_db.exists(): print "Deleting old queue DB" queue_db.unlink() config.set_profile("test") config.c.async_jobs = True config.c.queue_path = queue_db config.activate_profile()
def try_upgrade(): """Run SQLAlchemy-migrate test on your database.""" from bespin import config, model, db_versions from migrate.versioning.shell import main config.set_profile('dev') config.activate_profile() repository = str(path(db_versions.__file__).dirname()) dburl = config.c.dburl dry("Test the database upgrade", main, ["test", repository, dburl])
def upgrade(): """Upgrade your database.""" from bespin import config, model, db_versions from migrate.versioning.shell import main config.set_profile('dev') config.activate_profile() repository = str(path(db_versions.__file__).dirname()) dburl = config.c.dburl dry("Run the database upgrade", main, ["upgrade", dburl, repository])
def setup_module(): global app, app_murdoc config.set_profile('test') app = controllers.make_app() app = BespinTestApp(app) app_murdoc = controllers.make_app() app_murdoc = BespinTestApp(app_murdoc) _install_test_plugin_path() config.activate_profile()
def setup_module(module): global app, session config.set_profile('test') config.activate_profile() Base.metadata.drop_all(bind=config.c.dbengine) Base.metadata.create_all(bind=config.c.dbengine) session = config.c.session_factory() User.create_user("BillBixby", "", "*****@*****.**") app = controllers.make_app() app = BespinTestApp(app) app.post("/register/login/BillBixby", dict(password=""))
def setup_module(module): global user_manager, app, session config.set_profile('test') config.activate_profile() model.Base.metadata.drop_all(bind=config.c.dbengine) model.Base.metadata.create_all(bind=config.c.dbengine) session = config.c.sessionmaker(bind=config.c.dbengine) user_manager = model.UserManager(session) user_manager.create_user("BillBixby", "", "*****@*****.**") app = controllers.make_app() app = TestApp(app) app.post("/register/login/BillBixby", dict(password=""))
def test_password_change_bad_code(): config.set_profile("test") config.activate_profile() _clear_db() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) app.reset() resp = app.post('/register/password/BillBixby', dict(code="42", newPassword="******"), status=400)
def create_db(): """Creates the development database""" from bespin import config, database, db_versions from migrate.versioning.shell import main if path("devdata.db").exists(): raise BuildFailure("Development database already exists") config.set_profile('dev') config.activate_profile() dry("Create database tables", database.Base.metadata.create_all, bind=config.c.dbengine) repository = str(path(db_versions.__file__).dirname()) dburl = config.c.dburl dry("Turn on migrate versioning", main, ["version_control", dburl, repository])
def seeddb(): from bespin import config, filesystem from bespin.database import User, Connection config.set_profile("dev") config.activate_profile() def get_user(name): user = User.find_user(name) if user == None: user = User.create_user(name, name, name + "@foo.com") session.commit() info("Created user called '" + name + "'") try: filesystem.get_project(user, user, "BespinSettings") except: settings = filesystem.get_project(user, user, "BespinSettings", create=True) settings.install_template('usertemplate') info("Created BespinSettings project for '" + name + "'") return user # Seriously there is something wrong with my ego today ;-) bgalbraith = get_user("bgalbraith") kdangoor = get_user("kdangoor") dalmaer = get_user("d") mattb = get_user("mattb") zuck = get_user("zuck") tom = get_user("tom") ev = get_user("ev") j = get_user("j") bgalbraith.follow(j) kdangoor.follow(j) dalmaer.follow(j) mattb.follow(j) zuck.follow(j) tom.follow(j) ev.follow(j) jproject = filesystem.get_project(j, j, "SampleProject", create=True) j.add_sharing(jproject, bgalbraith, edit=True) j.add_sharing(jproject, kdangoor, edit=True) j.add_sharing(jproject, dalmaer, edit=True) j.add_sharing(jproject, mattb, edit=False) j.add_sharing(jproject, zuck, edit=False) j.add_sharing(jproject, tom, edit=False) j.add_sharing(jproject, ev, edit=False)
def test_password_change_bad_code(): config.set_profile("test") config.activate_profile() _clear_db() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) app.reset() resp = app.post('/register/password/BillBixby', dict( code="42", newPassword="******"), status=400)
def main(): # Start up a thread that does timeouts and cleanup thread.start_new_thread(cleanup_thread, ()) from bespin import config, controllers from bespin.mobwrite.mobwrite_daemon import MobwriteWorker config.set_profile('dev') config.activate_profile() logging.info("Listening on port %d..." % LOCAL_PORT) s = SocketServer.ThreadingTCPServer(("", LOCAL_PORT), AutoPersisterEchoRequestHandler) try: s.serve_forever() except KeyboardInterrupt: logging.info("Shutting down.") logging.shutdown() s.socket.close()
def test_lost_username(send_text_email): config.set_profile("test") config.activate_profile() _clear_db() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) resp = app.post('/register/lost/', dict(email='*****@*****.**')) assert send_text_email.called args = send_text_email.call_args[0] assert args[0] == '*****@*****.**' assert args[1].startswith("Your username for ") assert "Your username is:" in args[2] assert "BillBixby" in args[2]
def test_users_can_be_locked_out(): config.set_profile("test") config.c.login_failure_tracking = "memory" config.c.login_attempts = "1" config.c.lockout_period = "1" config.activate_profile() app = controllers.make_app() app = BespinTestApp(app) _clear_db() resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) resp = app.post("/register/login/BillBixby", dict(password="******"), status=401) # fail with good password now, because we're locked out resp = app.post("/register/login/BillBixby", dict(password="******"), status=401)
def test_password_change_with_confirmation_code(): config.set_profile("test") config.activate_profile() _clear_db() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) app.reset() user = User.find_user("BillBixby") verify_code = controllers._get_password_verify_code(user) resp = app.post('/register/password/BillBixby', dict(code=verify_code, newPassword="******")) user = User.find_user('BillBixby', 'hatetraffic') assert user
def test_password_change_with_confirmation_code(): config.set_profile("test") config.activate_profile() _clear_db() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) app.reset() user = User.find_user("BillBixby") verify_code = controllers._get_password_verify_code(user) resp = app.post('/register/password/BillBixby', dict( code=verify_code, newPassword="******")) user = User.find_user('BillBixby', 'hatetraffic') assert user
def test_lost_password_request(send_text_email): config.set_profile("test") config.activate_profile() _clear_db() app = controllers.make_app() app = BespinTestApp(app) resp = app.post('/register/new/BillBixby', dict(email="*****@*****.**", password="******")) app.reset() resp = app.post('/register/lost/', dict(username='******')) assert send_text_email.called args = send_text_email.call_args[0] assert args[0] == '*****@*****.**' assert args[1].startswith("Requested password change for ") user = User.find_user("BillBixby") verify_code = controllers._get_password_verify_code(user) assert verify_code in args[2]
def installkey(options): """Install an SSH key into your Bespin keychain. This will prompt you for your Bespin keychain password. You must give a Bespin username with -u. You must also specify a passwordless SSH private key file with -f.""" if not 'installkey' in options or not options.installkey.user: raise BuildFailure("You must specify a user with -u for this task.") if not options.installkey.file: raise BuildFailure("You must specify a private key with with -f") private_key = path(options.installkey.file) public_key = private_key + ".pub" if not private_key.exists() or not public_key.exists(): raise BuildFailure( "Either your private key file or public key file does not exist") user = options.installkey.user import getpass password = getpass.getpass("Enter your keychain password: "******"dev") config.activate_profile() session = config.c.session_factory() try: user = session.query(database.User).filter_by(username=user).one() except NoResultFound: raise BuildFailure("I couldn't find %s in the database. Sorry!" % (user)) keychain = vcs.KeyChain(user, password) public_key = public_key.bytes() private_key = private_key.bytes() keychain.set_ssh_key(private_key, public_key)
def installkey(options): """Install an SSH key into your Bespin keychain. This will prompt you for your Bespin keychain password. You must give a Bespin username with -u. You must also specify a passwordless SSH private key file with -f.""" if not 'installkey' in options or not options.installkey.user: raise BuildFailure("You must specify a user with -u for this task.") if not options.installkey.file: raise BuildFailure("You must specify a private key with with -f") private_key = path(options.installkey.file) public_key = private_key + ".pub" if not private_key.exists() or not public_key.exists(): raise BuildFailure("Either your private key file or public key file does not exist") user = options.installkey.user import getpass password = getpass.getpass("Enter your keychain password: "******"dev") config.activate_profile() session = config.c.session_factory() try: user = session.query(database.User).filter_by(username=user).one() except NoResultFound: raise BuildFailure("I couldn't find %s in the database. Sorry!" % (user)) keychain = vcs.KeyChain(user, password) public_key = public_key.bytes() private_key = private_key.bytes() keychain.set_ssh_key(private_key, public_key)
def _init_data(): global macgyver config.activate_profile() fsroot = config.c.fsroot if fsroot.exists() and fsroot.basename() == "testfiles": fsroot.rmtree() fsroot.makedirs() app.reset() Base.metadata.drop_all(bind=config.c.dbengine) Base.metadata.create_all(bind=config.c.dbengine) s = config.c.session_factory() app.post("/register/new/MacGyver", dict(password="******", email="*****@*****.**")) macgyver = User.find_user("MacGyver") s.flush()
def process_mobwrite(args=None): if args is None: args = sys.argv[1:] if args: mode = args.pop(0) else: mode = "dev" print("Bespin mobwrite worker (mode=" + mode + ")") config.set_profile(mode) if args: config.load_pyconfig(args.pop(0)) config.activate_profile() mobwrite_core.logging.basicConfig() main() mobwrite_core.logging.shutdown()
def _init_data(): global macgyver config.activate_profile() fsroot = config.c.fsroot if fsroot.exists() and fsroot.basename() == "testfiles": fsroot.rmtree() fsroot.makedirs() app.reset() model.Base.metadata.drop_all(bind=config.c.dbengine) model.Base.metadata.create_all(bind=config.c.dbengine) s = config.c.sessionmaker(bind=config.c.dbengine) user_manager = model.UserManager(s) app.post("/register/new/MacGyver", dict(password="******", email="*****@*****.**")) macgyver = user_manager.get_user("MacGyver")
def start(): """Starts the BespinServer on localhost port 8080 for development. You can change the port and allow remote connections by setting server.port or server.address on the command line. paver server.address=your.ip.address server.port=8000 start will allow remote connections (assuming you don't have a firewall blocking the connection) and start the server on port 8000. """ # automatically install Dojo if it's not there already if not (options.dojo.destination / "dojo").exists(): dojo() from bespin import config, controllers from paste.httpserver import serve options.order('server') config.set_profile('dev') if options.server.try_build: config.c.static_dir = (options.build_dir / "frontend").abspath() if options.server.dburl: config.c.dburl = options.server.dburl if options.server. async: config.c.async_jobs = True config_file = options.server.config_file if config_file.exists(): info("Loading config: %s", config_file) code = compile(config_file.bytes(), config_file, "exec") exec code in {} config.activate_profile() port = int(options.port) serve(controllers.make_app(), options.address, port, use_threadpool=True)
def start(): """Starts the BespinServer on localhost port 8080 for development. You can change the port and allow remote connections by setting server.port or server.address on the command line. paver server.address=your.ip.address server.port=8000 start will allow remote connections (assuming you don't have a firewall blocking the connection) and start the server on port 8000. """ from bespin import config, controllers from paste.httpserver import serve options.order('server') config.set_profile('dev') if options.staticdir: config.c.static_dir = path(options.clientdir) / options.staticdir if options.server.dburl: config.c.dburl = options.server.dburl if options.server. async: config.c.async_jobs = True config.c.server_base_url = options.server_base_url config_file = options.server.config_file if config_file.exists(): info("Loading config: %s", config_file) code = compile(config_file.bytes(), config_file, "exec") exec code in {} config.activate_profile() port = int(options.port) serve(controllers.make_app(), options.address, port, use_threadpool=True)
def start(): """Starts the BespinServer on localhost port 8080 for development. You can change the port and allow remote connections by setting server.port or server.address on the command line. paver server.address=your.ip.address server.port=8000 start will allow remote connections (assuming you don't have a firewall blocking the connection) and start the server on port 8000. """ from bespin import config, controllers from paste.httpserver import serve options.order('server') config.set_profile('dev') if options.staticdir: config.c.static_dir = path(options.clientdir) / options.staticdir if options.server.dburl: config.c.dburl = options.server.dburl if options.server.async: config.c.async_jobs = True config.c.server_base_url = options.server_base_url config_file = options.server.config_file if config_file.exists(): info("Loading config: %s", config_file) code = compile(config_file.bytes(), config_file, "exec") exec code in {} config.activate_profile() port = int(options.port) serve(controllers.make_app(), options.address, port, use_threadpool=True)
def process_queue(args=None): log.info("Bespin queue worker") if args is None: args = sys.argv[1:] if args: config.set_profile(args.pop(0)) else: config.set_profile("dev") config.c.async_jobs = True if args: config.load_pyconfig(args.pop(0)) config.activate_profile() bq = config.c.queue log.debug("Queue: %s", bq) for qi in bq.read_queue("vcs"): log.info("Processing job %s", qi.id) log.debug("Message: %s", qi.message) qi.run() qi.done()
def process_queue(args=None): log.info("Bespin queue worker") if args is None: args = sys.argv[1:] if args: config.set_profile(args.pop(0)) else: config.set_profile("dev") config.c.async_jobs=True if args: config.load_config(args.pop(0)) config.activate_profile() bq = config.c.queue log.debug("Queue: %s", bq) for qi in bq.read_queue("vcs"): log.info("Processing job %s", qi.id) log.debug("Message: %s", qi.message) qi.run() qi.done()
def setup_module(module): config.set_profile("test") config.activate_profile()