def __init__(self, args):
self._original_excepthook = sys.excepthook
self._configuration = CONF
self._security_manager = SecurityManager()
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._security_manager,
self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._reports_manager = ReportManager(
10, self._plugin_manager.createController("ReportManager"))
self._workspace_manager = WorkspaceManager(self._db_manager,
self._mappers_manager,
self._changes_controller,
self._reports_manager)
self.gui_app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager, args.gui)
self.gui_app.setSplashImage(
os.path.join(CONF.getImagePath(), "splash2.png"))
def __init__(self, args):
self._original_excepthook = sys.excepthook
self.args = args
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager(self.on_connection_lost)
self._model_controller = ModelController(self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._workspace_manager = WorkspaceManager(self._db_manager,
self._mappers_manager,
self._changes_controller)
# Create a PluginController and send this to UI selected.
self._plugin_controller = PluginController('PluginController',
self._plugin_manager,
self._mappers_manager)
if self.args.cli:
self.app = CliApp(self._workspace_manager, self._plugin_controller)
CONF.setMergeStrategy("new")
else:
self.app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager,
self._plugin_controller, self.args.gui)
self.timer = TimerClass()
self.timer.start()
def __init__(self, args):
self._original_excepthook = sys.excepthook
self._configuration = CONF
self._security_manager = SecurityManager()
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._security_manager, self._mappers_manager)
self._plugin_manager = PluginManager(os.path.join(CONF.getConfigPath(), "plugins"), self._mappers_manager)
self._reports_manager = ReportManager(10, self._plugin_manager.createController("ReportManager"))
self._workspace_manager = WorkspaceManager(
self._db_manager, self._mappers_manager, self._changes_controller, self._reports_manager
)
self.gui_app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, args.gui)
self.gui_app.setSplashImage(os.path.join(CONF.getImagePath(), "splash2.png"))
self.timer = TimerClass()
self.timer.start()
def __init__(self, args):
self._original_excepthook = sys.excepthook
self.args = args
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._workspace_manager = WorkspaceManager(
self._db_manager,
self._mappers_manager,
self._changes_controller)
if self.args.cli:
self.app = CliApp(self._workspace_manager)
CONF.setMergeStrategy("new")
else:
self.app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager,
self.args.gui)
self.timer = TimerClass()
self.timer.start()
def testThreadStopsInFS(self):
dbManagerClass = DbManager
dbManagerClass._loadDbs = lambda x: None
dbManager = DbManager()
changes_controller = ChangeController()
mapper = mock()
fsController = dbManager.createDb('testWkspc', DBTYPE.FS)
fsController.saveDocument({'_id': 'testwkspc', 'type': 'workspace'})
changes_controller.watch(mapper, fsController)
self.assertTrue(changes_controller.isAlive())
changes_controller.unwatch()
self.assertFalse(changes_controller.isAlive())
def testThreadStopsInFS(self):
dbManagerClass = DbManager
dbManagerClass._loadDbs = lambda x: None
dbManager = DbManager()
changes_controller = ChangeController()
mapper = mock()
fsController = dbManager.createDb('testWkspc', DBTYPE.FS)
fsController.saveDocument({'_id':'testwkspc',
'type':'workspace' })
changes_controller.watch(mapper, fsController)
self.assertTrue(changes_controller.isAlive())
changes_controller.unwatch()
self.assertFalse(changes_controller.isAlive())
def testThreadStops(self):
changes_controller = ChangeController()
mapper = mock()
uri = CONF.getCouchURI()
url = urlparse(uri)
getLogger(self).debug("Setting user,pass %s %s" %
(url.username, url.password))
self.cdbManager = CouchDbManager(uri=uri)
dbCouchController = self.cdbManager.createDb('testWkspc')
dbCouchController.saveDocument({
'_id': 'testwkspc',
'type': 'workspace'
})
changes_controller.watch(mapper, dbCouchController)
self.assertTrue(changes_controller.isAlive())
changes_controller.unwatch()
self.assertFalse(changes_controller.isAlive())
def testThreadStops(self):
changes_controller = ChangeController()
mapper = mock()
uri = CONF.getCouchURI()
url = urlparse(uri)
getLogger(self).debug(
"Setting user,pass %s %s" % (url.username, url.password))
self.cdbManager = CouchDbManager(uri=uri)
dbCouchController = self.cdbManager.createDb('testWkspc')
dbCouchController.saveDocument({'_id':'testwkspc',
'type':'workspace' })
changes_controller.watch(mapper, dbCouchController)
self.assertTrue(changes_controller.isAlive())
changes_controller.unwatch()
self.assertFalse(changes_controller.isAlive())
class WorkspacePersister(object):
_instance = None
_persister = None
_workspace = None
_workspace_autoloader = None
_pending_actions = None
_change_controller = ChangeController()
def __new__(cls, *args, **kargs):
if cls._instance is None:
cls._instance = object.__new__(cls, *args, **kargs)
return cls._instance
def setPersister(self, workspace, persister):
WorkspacePersister._persister = persister
WorkspacePersister._workspace = workspace
WorkspacePersister._change_controller.setWorkspace(workspace)
WorkspacePersister._workspace_autoloader = WorkspaceAutoSync(
self.loadChanges, self.backendChangeListener)
WorkspacePersister._workspace_autoloader.start()
WorkspacePersister._pending_actions = PendingTransactionsQueue()
@staticmethod
def stopThreads():
WorkspacePersister._workspace_autoloader.stop()
def loadChanges(self, changes):
self._change_controller.loadChanges(changes)
def reloadWorkspace(self):
WorkspacePersister._workspace.load()
@staticmethod
def addPendingAction(obj, func, args, kwargs):
if "wait" not in func.__name__:
WorkspacePersister._pending_actions.pushPendingTransaction(
obj, func, args, kwargs)
@staticmethod
def reExecutePendingActions():
for (obj, func, args, kwargs) in WorkspacePersister._pending_actions:
func(obj, *args, **kwargs)
model.api.devlog("Re executing")
@staticmethod
def notifyPersisterConnectionLost():
WorkspacePersister._workspace.notifyWorkspaceNoConnection()
def backendChangeListener(self):
changes = WorkspacePersister._persister.waitForDBChange(
WorkspacePersister._workspace.name)
return changes
@staticmethod
def save(obj):
if WorkspacePersister._workspace is not None:
WorkspacePersister._workspace.saveObj(obj)
@staticmethod
def delete(obj):
if WorkspacePersister._workspace:
WorkspacePersister._workspace.delObj(obj)
class MainApplication(object):
"""
"""
def __init__(self, args):
self._original_excepthook = sys.excepthook
self._configuration = CONF
self._security_manager = SecurityManager()
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._security_manager,
self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._reports_manager = ReportManager(
10, self._plugin_manager.createController("ReportManager"))
self._workspace_manager = WorkspaceManager(self._db_manager,
self._mappers_manager,
self._changes_controller,
self._reports_manager)
self.gui_app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager, args.gui)
self.gui_app.setSplashImage(
os.path.join(CONF.getImagePath(), "splash2.png"))
def enableExceptHook(self):
sys.excepthook = exception_handler
installThreadExcepthook()
def disableLogin(self):
CONF.setAuth(sys.disablelogin)
def start(self):
try:
self.gui_app.startSplashScreen()
self.gui_app.splashMessage("Starting Faraday")
signal.signal(signal.SIGINT, self.ctrlC)
logged = True
while True:
username, password = "******", "password"
if username is None and password is None:
break
result = self._security_manager.authenticateUser(
username, password)
if result == codes.successfulLogin:
logged = True
break
if logged:
model.api.devlog("Starting application...")
model.api.devlog("Setting up remote API's...")
# We need to create the last used workspace (or the default
# workspace) before we start the model controller and the
# report manager
last_workspace = CONF.getLastWorkspace()
if not self._workspace_manager.workspaceExists(last_workspace):
getLogger(self).info(
"Your last workspace (" + last_workspace +
") wasn't accessible, check configuration...")
self._workspace_manager.openDefaultWorkspace()
#self._workspace_manager.createWorkspace(last_workspace, 'default workspace, probably created already in couchb')
else:
self._workspace_manager.openWorkspace(last_workspace)
model.api.setUpAPIs(self._model_controller,
self._workspace_manager,
CONF.getApiConInfoHost(),
CONF.getApiConInfoPort())
model.guiapi.setUpGUIAPIs(self._model_controller)
model.api.devlog("Starting model controller daemon...")
self._model_controller.start()
model.api.startAPIServer()
restapi.startAPIs(self._plugin_manager, self._model_controller,
self._mappers_manager,
CONF.getApiConInfoHost(),
CONF.getApiRestfulConInfoPort())
# Start report manager here
getLogger(self).debug("Starting Reports Manager Thread")
self._reports_manager.startWatch()
model.api.devlog("Faraday ready...")
model.api.__current_logged_user = username
self.gui_app.splashMessage("Loading workspace... Please wait.")
self.gui_app.loadWorkspaces()
self.gui_app.stopSplashScreen()
except Exception:
print "There was an error while starting Faraday"
print "-" * 50
traceback.print_exc()
print "-" * 50
self.__exit(-1)
if logged:
exit_code = self.gui_app.run([])
#exit_code = self.app.exec_loop()
else:
exit_code = -1
return self.__exit(exit_code)
def __exit(self, exit_code=0):
"""
Exits the application with the provided code.
It also waits until all app threads end.
"""
model.api.devlog("Closing Faraday...")
model.api.devlog("stopping model controller thread...")
model.api.stopAPIServer()
restapi.stopServer()
self._reports_manager.stop()
self._changes_controller.stop()
self._model_controller.stop()
self._model_controller.join()
self.gui_app.quit()
model.api.devlog("Waiting for controller threads to end...")
return exit_code
def quit(self):
"""
Redefined quit handler to nicely end up things
"""
self.gui_app.quit()
def ctrlC(self, signal, frame):
getLogger(self).info("Exiting...")
self.__exit(exit_code=0)
def getWorkspaceManager(self):
return self._workspace_manager
class MainApplication(object):
"""
"""
def __init__(self, args):
self._original_excepthook = sys.excepthook
self.args = args
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager(self.on_connection_lost)
self._model_controller = ModelController(self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._workspace_manager = WorkspaceManager(self._db_manager,
self._mappers_manager,
self._changes_controller)
# Create a PluginController and send this to UI selected.
self._plugin_controller = PluginController('PluginController',
self._plugin_manager,
self._mappers_manager)
if self.args.cli:
self.app = CliApp(self._workspace_manager, self._plugin_controller)
CONF.setMergeStrategy("new")
else:
self.app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager,
self._plugin_controller, self.args.gui)
self.timer = TimerClass()
self.timer.start()
def on_connection_lost(self):
"""All it does is send a notification to the notification center"""
model.guiapi.notification_center.CouchDBConnectionProblem()
def enableExceptHook(self):
sys.excepthook = exception_handler
installThreadExcepthook()
def start(self):
try:
signal.signal(signal.SIGINT, self.ctrlC)
model.api.devlog("Starting application...")
model.api.devlog("Setting up remote API's...")
if not self.args.workspace:
workspace = CONF.getLastWorkspace()
self.args.workspace = workspace
model.api.setUpAPIs(self._model_controller,
self._workspace_manager,
CONF.getApiConInfoHost(),
CONF.getApiConInfoPort())
model.guiapi.setUpGUIAPIs(self._model_controller)
model.api.devlog("Starting model controller daemon...")
self._model_controller.start()
model.api.startAPIServer()
restapi.startAPIs(self._plugin_controller, self._model_controller,
CONF.getApiConInfoHost(),
CONF.getApiRestfulConInfoPort())
model.api.devlog("Faraday ready...")
exit_code = self.app.run(self.args)
except Exception:
print "There was an error while starting Faraday"
print "-" * 50
traceback.print_exc()
print "-" * 50
exit_code = -1
finally:
return self.__exit(exit_code)
def __exit(self, exit_code=0):
"""
Exits the application with the provided code.
It also waits until all app threads end.
"""
model.api.log("Closing Faraday...")
model.api.devlog("stopping model controller thread...")
model.api.stopAPIServer()
restapi.stopServer()
self._changes_controller.stop()
self._model_controller.stop()
self._model_controller.join()
self.timer.stop()
model.api.devlog("Waiting for controller threads to end...")
return exit_code
def quit(self):
"""
Redefined quit handler to nicely end up things
"""
self.app.quit()
def ctrlC(self, signal, frame):
getLogger(self).info("Exiting...")
self.app.quit()
class MainApplication(object):
"""
"""
def __init__(self, args):
self._original_excepthook = sys.excepthook
self._configuration = CONF
self._security_manager = SecurityManager()
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._security_manager, self._mappers_manager)
self._plugin_manager = PluginManager(os.path.join(CONF.getConfigPath(), "plugins"), self._mappers_manager)
self._reports_manager = ReportManager(10, self._plugin_manager.createController("ReportManager"))
self._workspace_manager = WorkspaceManager(
self._db_manager, self._mappers_manager, self._changes_controller, self._reports_manager
)
self.gui_app = UiFactory.create(self._model_controller, self._plugin_manager, self._workspace_manager, args.gui)
self.gui_app.setSplashImage(os.path.join(CONF.getImagePath(), "splash2.png"))
self.timer = TimerClass()
self.timer.start()
def enableExceptHook(self):
sys.excepthook = exception_handler
installThreadExcepthook()
def disableLogin(self):
CONF.setAuth(sys.disablelogin)
def start(self):
try:
self.gui_app.startSplashScreen()
self.gui_app.splashMessage("Starting Faraday")
signal.signal(signal.SIGINT, self.ctrlC)
logged = True
while True:
username, password = "******", "password"
if username is None and password is None:
break
result = self._security_manager.authenticateUser(username, password)
if result == codes.successfulLogin:
logged = True
break
if logged:
model.api.devlog("Starting application...")
model.api.devlog("Setting up remote API's...")
# We need to create the last used workspace (or the default
# workspace) before we start the model controller and the
# report manager
last_workspace = CONF.getLastWorkspace()
try:
if not self._workspace_manager.workspaceExists(last_workspace):
getLogger(self).info(
"Your last workspace ("
+ str(last_workspace)
+ ") wasn't accessible, check configuration..."
)
self._workspace_manager.openDefaultWorkspace()
# self._workspace_manager.createWorkspace(last_workspace, 'default workspace, probably created already in couchb')
else:
self._workspace_manager.openWorkspace(last_workspace)
except restkit.errors.Unauthorized:
print "You are trying to enter CouchDB with authentication"
print "Add your credentials to your user configuration file in $HOME/.faraday/config/user.xml"
print "For example: <couch_uri>http://john:[email protected]:5984</couch_uri>"
return
model.api.setUpAPIs(
self._model_controller, self._workspace_manager, CONF.getApiConInfoHost(), CONF.getApiConInfoPort()
)
model.guiapi.setUpGUIAPIs(self._model_controller)
model.api.devlog("Starting model controller daemon...")
self._model_controller.start()
model.api.startAPIServer()
restapi.startAPIs(
self._plugin_manager,
self._model_controller,
self._mappers_manager,
CONF.getApiConInfoHost(),
CONF.getApiRestfulConInfoPort(),
)
# Start report manager here
getLogger(self).debug("Starting Reports Manager Thread")
self._reports_manager.startWatch()
model.api.devlog("Faraday ready...")
model.api.__current_logged_user = username
self.gui_app.splashMessage("Loading workspace... Please wait.")
self.gui_app.loadWorkspaces()
self.gui_app.stopSplashScreen()
except Exception:
print "There was an error while starting Faraday"
print "-" * 50
traceback.print_exc()
print "-" * 50
self.__exit(-1)
if logged:
exit_code = self.gui_app.run([])
# exit_code = self.app.exec_loop()
else:
exit_code = -1
return self.__exit(exit_code)
def __exit(self, exit_code=0):
"""
Exits the application with the provided code.
It also waits until all app threads end.
"""
model.api.devlog("Closing Faraday...")
model.api.devlog("stopping model controller thread...")
model.api.stopAPIServer()
restapi.stopServer()
self._reports_manager.stop()
self._changes_controller.stop()
self._model_controller.stop()
self._model_controller.join()
self.gui_app.quit()
self.timer.stop()
model.api.devlog("Waiting for controller threads to end...")
return exit_code
def quit(self):
"""
Redefined quit handler to nicely end up things
"""
self.gui_app.quit()
def ctrlC(self, signal, frame):
getLogger(self).info("Exiting...")
self.__exit(exit_code=0)
def getWorkspaceManager(self):
return self._workspace_manager
class MainApplication(object):
"""
"""
def __init__(self, args):
self._original_excepthook = sys.excepthook
self.args = args
self._mappers_manager = MapperManager()
self._changes_controller = ChangeController()
self._db_manager = DbManager()
self._model_controller = ModelController(self._mappers_manager)
self._plugin_manager = PluginManager(
os.path.join(CONF.getConfigPath(), "plugins"),
self._mappers_manager)
self._workspace_manager = WorkspaceManager(
self._db_manager,
self._mappers_manager,
self._changes_controller)
if self.args.cli:
self.app = CliApp(self._workspace_manager)
CONF.setMergeStrategy("new")
else:
self.app = UiFactory.create(self._model_controller,
self._plugin_manager,
self._workspace_manager,
self.args.gui)
self.timer = TimerClass()
self.timer.start()
def enableExceptHook(self):
sys.excepthook = exception_handler
installThreadExcepthook()
def start(self):
try:
signal.signal(signal.SIGINT, self.ctrlC)
model.api.devlog("Starting application...")
model.api.devlog("Setting up remote API's...")
if not self.args.workspace:
workspace = CONF.getLastWorkspace()
self.args.workspace = workspace
model.api.setUpAPIs(
self._model_controller,
self._workspace_manager,
CONF.getApiConInfoHost(),
CONF.getApiConInfoPort())
model.guiapi.setUpGUIAPIs(self._model_controller)
model.api.devlog("Starting model controller daemon...")
self._model_controller.start()
model.api.startAPIServer()
restapi.startAPIs(
self._plugin_manager,
self._model_controller,
self._mappers_manager,
CONF.getApiConInfoHost(),
CONF.getApiRestfulConInfoPort())
model.api.devlog("Faraday ready...")
exit_code = self.app.run(self.args)
except Exception:
print "There was an error while starting Faraday"
print "-" * 50
traceback.print_exc()
print "-" * 50
exit_code = -1
finally:
return self.__exit(exit_code)
def __exit(self, exit_code=0):
"""
Exits the application with the provided code.
It also waits until all app threads end.
"""
model.api.log("Closing Faraday...")
model.api.devlog("stopping model controller thread...")
model.api.stopAPIServer()
restapi.stopServer()
self._changes_controller.stop()
self._model_controller.stop()
self._model_controller.join()
self.timer.stop()
model.api.devlog("Waiting for controller threads to end...")
return exit_code
def quit(self):
"""
Redefined quit handler to nicely end up things
"""
self.app.quit()
def ctrlC(self, signal, frame):
getLogger(self).info("Exiting...")
self.app.quit()
