Ejemplo n.º 1
0
 def createWorkspace(self, name, desc, dbtype=DBTYPE.COUCHDB):
     workspace = Workspace(name, desc)
     try:
         dbConnector = self.dbManager.createDb(name, dbtype)
     except restkit.Unauthorized:
         raise WorkspaceException(
             (
                 "You're not authorized to create workspaces\n"
                 "Make sure you're an admin and add your credentials"
                 "to your user configuration "
                 "file in $HOME/.faraday/config/user.xml\n"
                 "For example: "
                 "<couch_uri>http://john:[email protected]:5984</couch_uri>"
             )
         )
     except Exception as e:
         raise WorkspaceException(str(e))
     if dbConnector:
         self.closeWorkspace()
         self.mappersManager.createMappers(dbConnector)
         self.mappersManager.save(workspace)
         self.setActiveWorkspace(workspace)
         notification_center.workspaceChanged(workspace, self.getWorkspaceType(name))
         notification_center.workspaceLoad(workspace.getHosts())
         self.changesManager.watch(self.mappersManager, dbConnector)
         return workspace
     return False
Ejemplo n.º 2
0
 def createWorkspace(self, name, desc, dbtype=DBTYPE.COUCHDB):
     workspace = Workspace(name, desc)
     try:
         dbConnector = self.dbManager.createDb(name, dbtype)
     except restkit.Unauthorized:
         raise WorkspaceException(
             ("You're not authorized to create workspaces\n"
              "Make sure you're an admin and add your credentials"
              "to your user configuration "
              "file in $HOME/.faraday/config/user.xml\n"
              "For example: "
              "<couch_uri>http://john:[email protected]:5984</couch_uri>"))
     except Exception as e:
         raise WorkspaceException(str(e))
     if dbConnector:
         self.closeWorkspace()
         self.mappersManager.createMappers(dbConnector)
         self.mappersManager.save(workspace)
         self.setActiveWorkspace(workspace)
         notification_center.workspaceChanged(workspace,
                                              self.getWorkspaceType(name))
         notification_center.workspaceLoad(workspace.getHosts())
         self.changesManager.watch(self.mappersManager, dbConnector)
         return workspace
     return False
Ejemplo n.º 3
0
 def test_workspace_serialization(self):
     workspace = Workspace(name="workspace_test")
     workspace.setDescription("Some description")
     workspace.setCustomer("Infobyte")
     wserialized = self.wmapper.serialize(workspace)
     # if serialization fails, returns None
     self.assertNotEqual(
         wserialized,
         None,
         "Serialized workspace shouldn't be None")
     # we check the host attributes
     self.assertEquals(
         wserialized.get("_id"),
         workspace.getID(),
         "Serialized ID is not the same as workspace ID")
     self.assertEquals(
         wserialized.get("name"),
         workspace.getName(),
         "Serialized name is not the same as workspace name")
     self.assertEquals(
         wserialized.get("description"),
         workspace.getDescription(),
         "Serialized description is not the same as workspace description")
     self.assertEquals(
         wserialized.get("customer"),
         workspace.getCustomer(),
         "Serialized customer is not the same as workspace customer")
Ejemplo n.º 4
0
    def testGetWorkspaceTypeFS(self):
        work = Workspace('testname')
        dbManager = mock()
        mappersManager = mock()
        changesController = mock()
        when(dbManager).getDbType('testname').thenReturn(DBTYPE.FS)
        workspace_manager = WorkspaceManager(dbManager, mappersManager, changesController, mock())

        wtype = workspace_manager.getWorkspaceType(work.getName())
        self.assertEquals(wtype, 'FS', 'Workspace type not returning correct value')
Ejemplo n.º 5
0
 def openDefaultWorkspace(self):
     # This method opens the default workspace called 'untitled'
     if "untitled" not in self.getWorkspacesNames():
         workspace = Workspace("untitled", "default workspace")
         dbConnector = self.dbManager.createDb(workspace.getName(), DBTYPE.FS)
         if self.active_workspace:
             self.closeWorkspace()
         self.mappersManager.createMappers(dbConnector)
         self.mappersManager.save(workspace)
     return self.openWorkspace("untitled")
Ejemplo n.º 6
0
 def test_workspace_creation(self):
     workspace = Workspace(name="workspace_test")
     self.wmapper.save(workspace)
     w = self.wmapper.find(workspace.getID())
     self.assertEquals(
         w, workspace,
         "Workspace retrieved should be the same as persisted")
     self.assertEquals(
         w.getID(), workspace.getID(),
         "Workspace retrieved's Id should be the same as persisted's Id")
Ejemplo n.º 7
0
 def openDefaultWorkspace(self):
     #This method opens the default workspace called 'untitled'
     if 'untitled' not in self.getWorkspacesNames():
         workspace = Workspace('untitled', 'default workspace')
         dbConnector = self.dbManager.createDb(workspace.getName(),
                                               DBTYPE.FS)
         if self.active_workspace:
             self.closeWorkspace()
         self.mappersManager.createMappers(dbConnector)
         self.mappersManager.save(workspace)
     return self.openWorkspace('untitled')
Ejemplo n.º 8
0
 def test_workspace_creation(self):
     workspace = Workspace(name="workspace_test")
     self.wmapper.save(workspace)
     w = self.wmapper.find(workspace.getID())
     self.assertEquals(
         w,
         workspace,
         "Workspace retrieved should be the same as persisted")
     self.assertEquals(
         w.getID(),
         workspace.getID(),
         "Workspace retrieved's Id should be the same as persisted's Id")
Ejemplo n.º 9
0
	def post(self):
		user = users.get_current_user()
		name = self.request.get("name")
		ws = Workspace(user = user, name = unicode(name))
		ws.put()

		backlog = Column(workspace = ws, name = u"Backlog", allow_create = True)
		backlog.put()

		for i in range(1, 5):
			c = Column(workspace = ws, name = u"Column %s" % i)
			c.put()
Ejemplo n.º 10
0
    def testGetWorkspaceTypeFS(self):
        work = Workspace('testname')
        dbManager = mock()
        mappersManager = mock()
        changesController = mock()
        when(dbManager).getDbType('testname').thenReturn(DBTYPE.FS)
        workspace_manager = WorkspaceManager(dbManager, mappersManager,
                                             changesController, mock())

        wtype = workspace_manager.getWorkspaceType(work.getName())
        self.assertEquals(wtype, 'FS',
                          'Workspace type not returning correct value')
Ejemplo n.º 11
0
    def test_workspace_create_and_delete(self):
        workspace = Workspace(name="workspace_test")
        self.wmapper.save(workspace)
        w_id = workspace.getID()

        self.assertNotEquals(self.wmapper.load(w_id), None,
                             "Workspace should be saved")

        self.wmapper.delete(w_id)

        self.assertEquals(self.wmapper.find(w_id), None,
                          "Workspace shouldn't exist anymore")
Ejemplo n.º 12
0
    def testSetActiveWorkspace(self):
        work = Workspace('testname')
        dbManager = mock()
        mappersManager = mock()
        changesController = mock()
        workspace_manager = WorkspaceManager(dbManager, mappersManager, changesController, mock())

        workspace_manager.setActiveWorkspace(work)

        self.assertEquals(workspace_manager.active_workspace, work,
                'active workspace not set')
        self.assertTrue(workspace_manager.isActive(work.getName()),
                'could not retrive as active workspace')
Ejemplo n.º 13
0
 def createWorkspace(self, name, desc, dbtype=DBTYPE.FS):
     workspace = Workspace(name, desc)
     dbConnector = self.dbManager.createDb(name, dbtype)
     if dbConnector:
         self.closeWorkspace()
         self.mappersManager.createMappers(dbConnector)
         self.mappersManager.save(workspace)
         self.setActiveWorkspace(workspace)
         notification_center.workspaceChanged(workspace)
         notification_center.workspaceLoad(workspace.getHosts())
         self.changesManager.watch(self.mappersManager, dbConnector)
         self.reportsManager.watch(name)
         return workspace
     return False
Ejemplo n.º 14
0
    def testSetActiveWorkspace(self):
        work = Workspace('testname')
        dbManager = mock()
        mappersManager = mock()
        changesController = mock()
        workspace_manager = WorkspaceManager(dbManager, mappersManager,
                                             changesController, mock())

        workspace_manager.setActiveWorkspace(work)

        self.assertEquals(workspace_manager.active_workspace, work,
                          'active workspace not set')
        self.assertTrue(workspace_manager.isActive(work.getName()),
                        'could not retrive as active workspace')
Ejemplo n.º 15
0
    def testOpenWorkspaceChangesAndReportManagerWatch(self):
        reportManager = mock()

        dbManager = mock()
        mappersManager = mock()
        dbConnector = mock()
        mappers = mock()
        changesController = mock()
        workspaceMapper = mock()

        workspace = Workspace('test_workspace', 'a desc')

        when(dbManager).getAllDbNames().thenReturn(['test_workspace'])
        when(dbManager).getConnector('test_workspace').thenReturn(dbConnector)
        when(mappersManager).createMappers(dbConnector).thenReturn(True)
        when(mappersManager).getMapper(
            Workspace.__name__).thenReturn(workspaceMapper)
        when(workspaceMapper).find('test_workspace').thenReturn(workspace)

        workspace_manager = WorkspaceManager(dbManager, mappersManager,
                                             changesController, reportManager)

        opened_workspace = workspace_manager.openWorkspace('test_workspace')

        verify(reportManager).watch('test_workspace')
        verify(changesController).watch(mappersManager, dbConnector)
        self.assertEquals(opened_workspace.getName(), 'test_workspace')
Ejemplo n.º 16
0
    def test_workspace_create_and_delete(self):
        workspace = Workspace(name="workspace_test")
        self.wmapper.save(workspace)
        w_id = workspace.getID()

        self.assertNotEquals(
            self.wmapper.load(w_id),
            None,
            "Workspace should be saved")

        self.wmapper.delete(w_id)

        self.assertEquals(
            self.wmapper.find(w_id),
            None,
            "Workspace shouldn't exist anymore")
Ejemplo n.º 17
0
 def createWorkspace(self,
                     name,
                     desc,
                     start_date=int(time.time() * 1000),
                     finish_date=int(time.time() * 1000),
                     customer=""):
     # XXX: DEPRECATE NEXT LINE
     workspace = Workspace(name, desc)
     try:
         create_workspace(name,
                          description=desc,
                          start_date=start_date,
                          finish_date=finish_date,
                          customer=customer)
     except Unauthorized:
         raise WorkspaceException(
             ("You're not authorized to create workspaces\n"
              "Make sure you're an admin and add your credentials"
              "to your user configuration "
              "file in $HOME/.faraday/config/user.xml\n"
              "For example: "
              "<couch_uri>http://john:[email protected]:5984</couch_uri>"))
     except Exception as e:
         raise WorkspaceException(str(e))
     self.mappersManager.createMappers(name)
     self.setActiveWorkspace(workspace)
     notification_center.workspaceChanged(workspace)
     return name
Ejemplo n.º 18
0
 def __init__(self, config):
     self.config = config
     self.score_dir = config.get_argv().score_file
     self.benchmark_config = config.get_argv().benchmark_config
     self.task = Task(config)
     self.workspace = Workspace(config)
     self.ssh_user = config.get_value('User', 'SSH')
     self.ssh_passwd_file = config.get_value('PasswdFile', 'SSH')
     self.ssh_port = config.get_value('Port', 'SSH')
     self.subnet_ip = config.get_value('ip', 'Subnet')
     self.subnet_name = config.get_value('name', 'Subnet')
     self.mode = config.get_value('Mode')
     self.pwd = os.path.dirname(__file__)
     self.mq_tag = str(time.time()).replace('.', '_')
     self._benchmark_pressure_tag_id = None
     self.logs_dir = os.path.join(self.pwd, '../logs/')
     self.logger = logging.getLogger(__name__)
     self.lockfile = self.__lockfile()
     self.logger.setLevel(logging.DEBUG)
     handler = logging.FileHandler("log.txt")
     handler.setLevel(logging.DEBUG)
     formatter = logging.Formatter(
         '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
     handler.setFormatter(formatter)
     self.logger.addHandler(handler)
Ejemplo n.º 19
0
 def createWorkspace(self, name, desc, dbtype=DBTYPE.FS):
     workspace = Workspace(name, desc)
     dbConnector = self.dbManager.createDb(name, dbtype)
     if dbConnector:
         self.closeWorkspace()
         self.mappersManager.createMappers(dbConnector)
         self.mappersManager.save(workspace)
         self.setActiveWorkspace(workspace)
         CONF.setLastWorkspace(name)
         CONF.saveConfig()
         notification_center.workspaceChanged(workspace)
         notification_center.workspaceLoad(workspace.getHosts())
         self.changesManager.watch(self.mappersManager, dbConnector)
         self.reportsManager.watch(name)
         return workspace
     return False
Ejemplo n.º 20
0
	def post(self):
		user = users.get_current_user()
		name = self.request.get("name")
		ws = Workspace(user = user, name = unicode(name))
		ws.put()

		backlog = Column(workspace = ws, name = u"Backlog", allow_create = True)
		backlog.put()

		for i in range(1, 5):
			c = Column(workspace = ws, name = u"Column %s" % i)
			c.put()

		data = {ws.id: ws.json}
		res = json.dumps(data, indent=4)
		self.error(200)
		self.response.out.write(res)
Ejemplo n.º 21
0
 def delete(cls, user_name, id):
     workspace = Workspace.select().get(id)
     if workspace.user_name != user_name:
         raise ServerException('无权限')
     planners = WeeklyPlanner.select().filter(
         WeeklyPlanner.workspace_id == id).all()
     if len(planners) != 0:
         raise ServerException('存在计划,请先删除计划')
     workspace.delete()
     return True
Ejemplo n.º 22
0
 def get(self, *args):
     if not len(args):
         user = users.get_current_user()
         workspaceList = Workspace.gql("WHERE user = :1", user)
         data = {}
         for w in workspaceList:
             data[w.id] = w.json
         res = json.dumps(data, indent=4)
         self.error(200)
         self.response.out.write(res)
     elif len(args) == 1:
         ws = Workspace.get("WHERE name = :1", args[0])
         if not ws:
             self.response.out.write("{}")
             return
         data = {ws.id: ws.json}
         res = json.dumps(data, indent=4)
         self.error(200)
         self.response.out.write(res)
         return
     else:
         raise NotImplemented("WorkspaceQuery does not expect more than one parameter")
Ejemplo n.º 23
0
	def get(self):
		user = users.get_current_user()
		if user:
			nickname = user.nickname()
		else:
			nickname = None

		workspaces = Workspace.gql("WHERE user = :1", user)
		params = {
			"sign_in_url": users.create_login_url("/"),
		    "sign_out_url": users.create_logout_url("/"),
		    "nickname": nickname,
		    "workspaces": workspaces,
		    "add_workspace_url": "/"
		}
		self.response.out.write(template.render("templates/main.html", params))
Ejemplo n.º 24
0
 def save(cls, user_name, id, name):
     if id is not None:
         workspace = Workspace.select().get(id)
         workspace.name = name
         workspace.update()
         return id
     else:
         workspace = Workspace(user_name=user_name, name=name)
         workspace.insert()
         return Workspace.select().filter(Workspace.user_name == user_name,
                                          Workspace.name == name).first().id
Ejemplo n.º 25
0
    def testRemoveWorkspace(self):
        dbManager = mock()
        mappersManager = mock()
        dbConnector = mock()
        mappers = mock()
        changesController = mock()

        workspace = Workspace('test_workspace', 'a desc')
        when(dbManager).removeDb('test_workspace').thenReturn(True)
        when(dbManager).getAllDbNames().thenReturn(['test_workspace'])

        workspace_manager = WorkspaceManager(dbManager, mappersManager,
                                             changesController, mock())
        remove_ret = workspace_manager.removeWorkspace('test_workspace')

        verify(dbManager).removeDb('test_workspace')
        self.assertTrue(remove_ret, 'bbdd not removed')
Ejemplo n.º 26
0
    def testOpenWorkspaceNoneExisting(self):
        dbManager = mock()
        mappersManager = mock()
        dbConnector = mock()
        mappers = mock()
        changesController = mock()

        workspace = Workspace('test_workspace', 'a desc')
        when(dbManager).getAllDbNames().thenReturn([])

        workspace_manager = WorkspaceManager(dbManager, mappersManager,
                                             changesController, mock())
        opened_workspace = workspace_manager.openWorkspace('test_workspace')

        verify(mappersManager, times=0).createMappers(dbConnector)
        verify(mappersManager, times=0).find('test_workspace')
        self.assertFalse(opened_workspace,
                         'Workspace retrieved but non existing')
Ejemplo n.º 27
0
 def list(cls, user_name):
     workspaces = Workspace.select().filter(
         Workspace.user_name == user_name).order_by(
             Workspace.updated_at.desc()).all()
     workspace_ids = [workspace.id for workspace in workspaces]
     planners = WeeklyPlanner.select().filter(
         WeeklyPlanner.workspace_id.in_(workspace_ids)).all()
     planner_map = {}
     for planner in planners:
         if planner_map.get(planner.workspace_id, None) is None:
             planner_map[planner.workspace_id] = [planner.get_json()]
         else:
             planner_map[planner.workspace_id].append(planner.get_json())
     results = []
     for workspace in workspaces:
         result = workspace.get_json()
         result['planners'] = planner_map.get(workspace.id, [])
         results.append(result)
     return results
Ejemplo n.º 28
0
    def testOpenWorkspaceSetsChangesCallback(self):
        dbManager = mock()
        mappersManager = mock()
        dbConnector = mock()
        mappers = mock()
        changesController = mock()
        workspaceMapper = mock()

        workspace = Workspace('test_workspace', 'a desc')

        when(dbManager).getConnector('test_workspace').thenReturn(dbConnector)
        when(mappersManager).getMapper(
            Workspace.__name__).thenReturn(workspaceMapper)
        when(dbManager).getAllDbNames().thenReturn(['test_workspace'])
        when(mappersManager).createMappers(dbConnector).thenReturn(True)
        when(workspaceMapper).find('test_workspace').thenReturn(workspace)

        workspace_manager = WorkspaceManager(dbManager, mappersManager,
                                             changesController, mock())

        opened_workspace = workspace_manager.openWorkspace('test_workspace')

        verify(changesController).watch(mappersManager, dbConnector)
Ejemplo n.º 29
0
    # Argos Application
    class ArgosApp(wx.App):

        def OnInit(self):
            return True

    app = ArgosApp(0)

    # The user can specify default colorblindness and palette shuffle modes with these environment variables
    colorblindness_option = os.environ.get('ARGOS_COLORBLINDNESS_MODE', 'default')
    palette_shuffle_option = os.environ.get('ARGOS_PALETTE_SHUFFLE_MODE', 'default')
    gui.autocoloring.BuildBrushes(colorblindness_option, palette_shuffle_option)

    # Preconfigure the workspace with options
    # Must be after wx.App is instantiated
    ws = Workspace()
    ws.SetPalette(colorblindness_option)
    ws.SetColorShuffleState(palette_shuffle_option)

    if args.resource_dir is not None:
        for rd in args.resource_dir:
            ws.AddUserResourceDir(rd)

    # Parse clock
    if args.clock is not None:
        select_clock = str(args.clock)
    else:
        select_clock = None

    # Determine start tick
    start_tick = None
Ejemplo n.º 30
0
    logging.getLogger().addHandler(fileHandler)

    # Argos Application
    class ArgosApp(wx.App):
        def OnInit(self):
            return True

    app = ArgosApp(0)

    settings = ArgosSettings()
    # The user can specify default colorblindness and palette shuffle modes with these environment variables
    gui.autocoloring.BuildBrushes(settings.palette, settings.palette_shuffle)

    # Preconfigure the workspace with options
    # Must be after wx.App is instantiated
    ws = Workspace(settings)

    if args.resource_dir is not None:
        for rd in args.resource_dir:
            ws.AddUserResourceDir(rd)

    # Parse clock
    if args.clock is not None:
        select_clock = str(args.clock)
    else:
        select_clock = None

    # Determine start tick
    start_tick = None
    if args.start_tick is not None:
        start_tick = int(args.start_tick)
Ejemplo n.º 31
0
from model.workspace import Workspace
from view.workspace import CabelFrame
import wx

# Create model
w = Workspace()


# Create view
class CabelApp(wx.App):
    def OnInit(self):
        self.frame = CabelFrame(w)
        self.frame.Show()
        self.SetTopWindow(self.frame)
        return True


app = CabelApp()

# Show view
app.MainLoop()