def setup_method(self,method): self.remove_files = [] # get user account info self.username,self.userpass = self.testdata.find_account_for('registeredworkspace') hubname = self.testdata.find_url_for('https') # access a tool session container cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) # copy the executable to the session directory self.sftp = SFTPClient( host=hubname, username=self.username, password=self.userpass) local_exe_path = os.path.join(hubcheck.conf.settings.data_dir, 'capacitor_voltage','sim1.py') self.ws.execute('cd $SESSIONDIR') sessiondir,es = self.ws.execute('pwd') self.exe_fn = 'sim1.py' self.exe_path = os.path.join(sessiondir,self.exe_fn) self.remove_files.append(self.exe_path) self.sftp.chdir(sessiondir) self.sftp.put(local_exe_path,self.exe_fn) self.sftp.chmod(self.exe_path,0700) # shouldn't take more than 60 seconds # to run submit --local commands self.ws.timeout = 60
def setup_method(self,method): # get into a tool session container hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('purdueworkspace') cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) # setup a web browser self.browser.get(self.https_authority) self.utils.account.login_as(self.username,self.userpass) # setup file paths fxf_fn = 'hcfxf.txt' self.ws.execute('cd $SESSIONDIR') sessiondir,es = self.ws.execute('pwd') self.fxf_path = os.path.join(sessiondir,fxf_fn) self.localfn = os.path.join(os.getcwd(),'hcfxf.tmp') self.expected = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
def setup_method(self,method): self.remove_files = [] # get user account info self.reguser,self.regpass = self.testdata.find_account_for('registeredworkspace') self.appsuser,self.appspass = self.testdata.find_account_for('appsworkspace') self.hubname = self.testdata.find_url_for('https') # setup a web browser self.browser.get(self.https_authority) # setup access to tool session containers cm = ContainerManager() self.reg_ws = cm.access(host=self.hubname, username=self.reguser, password=self.regpass) self.session = ToolSession( host=self.hubname, username=self.reguser, password=self.regpass) # get a list of session open before the test was run # incase the test fails unexpectedly, we can cleanup self.existing_sessions = self.session.get_open_session_detail() self.close_sessions = []
def setUp(self): self.remove_files = [] # get user account info self.username,self.userpass = self.testdata.find_account_for('registeredworkspace') hubname = self.testdata.find_url_for('https') cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) # cd into the session directory self.sftp = SFTPClient( host=hubname, username=self.username, password=self.userpass) self.ws.execute('cd $SESSIONDIR') self.sessiondir,es = self.ws.execute('pwd') self.sftp.chdir(self.sessiondir) # write data and script files to disk in the container. for fname,fprop in FILES.items(): with self.sftp.open(fname,mode='w') as f: f.write(fprop['contents']) self.remove_files.append(os.path.join(self.sessiondir,fname)) self.sftp.chmod(fname,fprop['mode'])
def setUp(self): self.remove_files = [] self.ws = None # get user account info self.hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('purdueworkspace') cm = ContainerManager() self.ws = cm.access(host=self.hubname, username=self.username, password=self.userpass) # copy the checknet executable to the session directory self.ws.execute('cd $SESSIONDIR') sessiondir,es = self.ws.execute('pwd') self.exe_fn = 'checknet.py' local_exe_path = os.path.join(hubcheck.conf.settings.data_dir,self.exe_fn) self.exe_path = os.path.join(sessiondir,self.exe_fn) self.remove_files.append(self.exe_path) self.ws.importfile(local_exe_path,self.exe_path,mode=0o700)
def setUp(self): # get user account info hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass)
def setup_method(self,method): # get user account info self.username,self.userpass = \ self.testdata.find_account_for('appsworkspace') hubname = self.testdata.find_url_for('https') # access a tool session container cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) self.sessiondir = self.ws.execute('echo $SESSIONDIR')
def setup_method(self,method): # get user account info self.hubname = self.testdata.find_url_for('https') # access a tool session container self.cm = ContainerManager()
def setUp(self): # start up a tool session container self.hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('purdueworkspace') self.cm = ContainerManager() self.ws = self.cm.create(host=self.hubname, username=self.username, password=self.userpass) self.session_number,es = self.ws.execute('echo $SESSION') self.session_number = int(self.session_number) # setup a web browser self.browser.get(self.https_authority) self.utils.account.login_as(self.username,self.userpass) self.po = self.catalog.load_pageobject('GenericPage') self.po.header.goto_myaccount() self.po = self.catalog.load_pageobject('MembersDashboardPage') self.my_sessions_module = self.po.modules.my_sessions
def setup_method(self,method): self.remove_files = [] # get user account info self.username,self.userpass = self.testdata.find_account_for('registeredworkspace') hubname = self.testdata.find_url_for('https') # access a tool session container cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) self.ws.execute('cd $SESSIONDIR') self.sessiondir,es = self.ws.execute('pwd')
def setup_method(self,method): # get user account info self.username,self.userpass = self.testdata.find_account_for('submituser') hubname = self.testdata.find_url_for('https') cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) self.ws.execute('cd $SESSIONDIR') sessiondir,es = self.ws.execute('pwd') self.exe_path = os.path.join(sessiondir,sayhi_py_fn) self.ws.importfile(sayhi_py_data,self.exe_path,mode=0o600,is_data=True) self.ws.timeout = 30
def setUp(self): self.ws = None if self.data is None: # only get the package list once # get user account info hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') cm = ContainerManager() self.ws = cm.access(host=hubname, username=self.username, password=self.userpass) self.data = self.ws.read_file('/var/tmp/installed_pkgs')
def checkout_repository(self, toolname, username, userpass): """ checkout the repository to see if it exists and is accessible. """ self.logger.info("checking out repository for the tool '%s'" % (toolname)) repo_url = self.repo_url_template % {"hubname": self.hubname, "toolname": toolname} # ssh into a tool session container cm = ContainerManager() ws = cm.access(host=self.hubname, username=username, password=userpass) svn = Subversion(ws, username, userpass) session_number = -1 repo_home = None try: session_number, es = ws.execute("echo $SESSION") if session_number <= 0: raise RuntimeError("invalid session number: %s" % (session_number)) # create a temp directory to hold the repo repo_home, es = ws.execute("mktemp -d --tmpdir=`pwd` -t tmp.XXXXXXXX") ws.execute("cd %s" % (repo_home)) # do the checkout svn.checkout(repo_url, toolname) # cd into the repo ws.execute("cd %s" % (toolname)) tool_repo, es = ws.execute("pwd") finally: # FIXME: remove the temp directory ws.send_raw("") ws.send_raw("") time.sleep(5) if repo_home is not None: ws.execute("rm -rf %s" % (repo_home)) # shut down the ssh connection ws.close()
def setup_method(self,method): # get user account info self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') self.hubname = self.testdata.find_url_for('https') # get into a workspace self.cm = ContainerManager() self.ws = self.cm.access(host=self.hubname, username=self.username, password=self.userpass)
def _time_groups_for(self,usertype): # get user account info hubname = self.testdata.find_url_for('https') username,userpass = \ self.testdata.find_account_for(usertype) cm = ContainerManager() self.ws = cm.access(host=hubname, username=username, password=userpass) command = '/usr/bin/time -f "{0}" groups {1}'.format('%e',username) output,es = self.ws.execute(command) time_re = re.compile('%s : ([^\n]+)\r\n([^\n]+)(\r\n)?' % (username)) match = time_re.search(output) self.assertTrue(match is not None, output) (grouplist,timecount,junk) = match.groups() self.assertTrue(float(timecount) < 1.0, "groups command took longer than 1 second: %s" % (timecount)) self.assertTrue(grouplist != "", "groups list is empty: %s" % (output)) fail_groups = [] for group in grouplist.split(): try: float(group) fail_groups.append(group) except ValueError: pass self.assertTrue(len(fail_groups) == 0, "groups with no name: %s" % (fail_groups))
class TestWorkspaceUser(TestCase2): def setup_method(self,method): # get user account info self.hubname = self.testdata.find_url_for('https') # access a tool session container self.cm = ContainerManager() def teardown_method(self,method): pass def test_workspace_access(self): """ the hc accounts specified as being in the mw-login group should be able to ssh into a workspace using virtual ssh """ failed_logins = [] for username in self.testdata.get_usernames(): userdata = self.testdata.get_userdata_for(username) if 'mw-login' not in userdata.admin_properties.groups: continue ws = None try: ws = self.cm.access(host=self.hubname, username=userdata.username, password=userdata.password) sessiondir = ws.execute('echo $SESSIONDIR') except: failed_logins.append(userdata.username) finally: if ws is not None: ws.close() ws = None assert len(failed_logins) == 0, \ 'login failed for the following accounts: %s' % (failed_logins)
def test_tty_recycle(self): """ check if ttys are being released after ssh connections are closed. ssh'ing into a workspace, opening a shell, and closing the ssh connection should release the pty. tool session containers get 15 ptys. we are checking to see if ptys are being released after the user exits the pty. the failue occurs in the call to cm.access(). """ session_number = 0 cm = ContainerManager() for i in range(31): try: # access a tool session container ws = cm.access(host=self.hubname, username=self.username, password=self.userpass) session_number,es = ws.execute('echo $SESSION') # start up a new bash shell manually ws.send('/bin/bash') # exit the workspace ws.close() except (ConnectionClosedError,socket.timeout) as e: if session_number > 0: # container is hosed, shut it down. cm.stop(self.hubname,self.username,int(session_number)) assert False, "After connecting %s time(s): %s" \ % (i,sys.exc_info()[0])
def setUp(self): self.cm = ContainerManager() self.host1 = '' self.user11 = '' self.pass11 = '' self.user12 = '' self.pass12 = '' self.host2 = '' self.user21 = '' self.pass21 = '' self.user22 = '' self.pass22 = ''
def setup_method(self,method): # start up a tool session container self.hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') self.cm = ContainerManager() self.ws = self.cm.access(host=self.hubname, username=self.username, password=self.userpass) self.session_number,es = self.ws.execute('echo $SESSION') self.ws.close() # setup a web browser self.browser.get(self.https_authority) self.utils.account.login_as(self.username,self.userpass) self.po = self.catalog.load_pageobject('ToolSessionPage', 'workspace',int(self.session_number)) self.po.goto_page()
class TestToolSessionShare(TestCase2): def setup_method(self,method): # start up a tool session container self.hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') self.cm = ContainerManager() self.ws = self.cm.access(host=self.hubname, username=self.username, password=self.userpass) self.session_number,es = self.ws.execute('echo $SESSION') self.ws.close() # setup a web browser self.browser.get(self.https_authority) self.utils.account.login_as(self.username,self.userpass) self.po = self.catalog.load_pageobject('ToolSessionPage', 'workspace',int(self.session_number)) self.po.goto_page() def teardown_method(self,method): # disconnect all users from workspace self.po.goto_page() self.po.share.disconnect_all() def test_share_session_with_1(self): """ test sharing the session with nobody """ shared_with_1 = self.po.share.get_shared_with() self.po.share.share.click() self.po.share.wait_for_overlay() shared_with_2 = self.po.share.get_shared_with() assert len(shared_with_1) == len(shared_with_2), \ "after pressing the share button, shared list changed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) s1 = set(shared_with_1) s2 = set(shared_with_2) s_union = s1 | s2 assert len(s_union) == len(shared_with_1), \ "after pressing the share button, shared list changed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) def test_share_session_with_2(self): """ test sharing the session with another user """ shared_with_1 = self.po.share.get_shared_with() username2,junk = \ self.testdata.find_account_for('purdueworkspace') user2_data = self.testdata.get_userdata_for(username2) user2_name = '{0} {1}'.format(user2_data.firstname,user2_data.lastname) self.po.share.share_session_with(username2) shared_with_2 = self.po.share.get_shared_with() assert len(shared_with_1)+1 == len(shared_with_2), \ "after sharing the session, wrong # users listed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) assert user2_name in shared_with_2, \ "after sharing session with %s, user %s" % (username2,user2_name) \ + " does not show up in shared with list: %s" % (shared_with_2) def test_share_session_with_3(self): """ test sharing the session with a fake user """ shared_with_1 = self.po.share.get_shared_with() self.po.share.share_session_with('fakeuserthatshouldnotexist') shared_with_2 = self.po.share.get_shared_with() assert len(shared_with_1) == len(shared_with_2), \ "after sharing the session with a fake user, shared list changed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) s1 = set(shared_with_1) s2 = set(shared_with_2) s_union = s1 | s2 assert len(s_union) == len(shared_with_1), \ "after sharing the session with a fake user, shared list changed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) # def test_share_session_with_4(self): # """ # test sharing the session with a group # """ # # self.po.share.share_session_with(group=0) # def test_share_session_with_5(self): # """ # test sharing the session with another user, read only # """ # # shared_with_1 = self.po.share.get_shared_with() # # username2,junk = \ # self.testdata.find_account_for('purdueworkspace') # user2_data = self.testdata.get_userdata_for(username2) # user2_name = '{0} {1}'.format(user2_data.firstname,user2_data.lastname) # self.po.share.share_session_with(username2,readonly=True) # # shared_with_2 = self.po.share.get_shared_with() # # assert len(shared_with_1)+1 == len(shared_with_2), \ # "after sharing the session, wrong # users listed: " \ # + "before: %s, after: %s" % (shared_with_1,shared_with_2) # # assert user2_name in shared_with_2, \ # "after sharing session with %s, user %s" % (username2,user2_name) \ # + " does not show up in shared with list: %s" % (shared_with_2) # # # check if the user was added to the list with the "read only" property def test_share_session_with_6(self): """ test sharing the session with another user twice user should only show up once in list """ shared_with_1 = self.po.share.get_shared_with() username2,junk = \ self.testdata.find_account_for('purdueworkspace') user2_data = self.testdata.get_userdata_for(username2) user2_name = '{0} {1}'.format(user2_data.firstname,user2_data.lastname) self.po.share.share_session_with(username2) self.po.share.share_session_with(username2) shared_with_2 = self.po.share.get_shared_with() assert len(shared_with_1)+1 == len(shared_with_2), \ "after sharing the session, wrong # users listed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) assert user2_name in shared_with_2, \ "after sharing session with %s, user %s" % (username2,user2_name) \ + " does not show up in shared with list: %s" % (shared_with_2) def test_share_session_with_7(self): """ test sharing the session with multiple users """ shared_with_1 = self.po.share.get_shared_with() username2,junk = \ self.testdata.find_account_for('purdueworkspace') user2_data = self.testdata.get_userdata_for(username2) user2_name = '{0} {1}'.format(user2_data.firstname,user2_data.lastname) username3,junk = \ self.testdata.find_account_for('networkworkspace') user3_data = self.testdata.get_userdata_for(username3) user3_name = '{0} {1}'.format(user3_data.firstname,user3_data.lastname) self.po.share.share_session_with([username2,username3]) shared_with_2 = self.po.share.get_shared_with() assert len(shared_with_1)+2 == len(shared_with_2), \ "after sharing the session, wrong # users listed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) assert user2_name in shared_with_2, \ "after sharing session with %s, user %s" % (username2,user2_name) \ + " does not show up in shared with list: %s" % (shared_with_2) assert user3_name in shared_with_2, \ "after sharing session with %s, user %s" % (username3,user3_name) \ + " does not show up in shared with list: %s" % (shared_with_2) def test_share_session_with_8(self): """ test sharing the session with multiple users, one at a time """ shared_with_1 = self.po.share.get_shared_with() username2,junk = \ self.testdata.find_account_for('purdueworkspace') user2_data = self.testdata.get_userdata_for(username2) user2_name = '{0} {1}'.format(user2_data.firstname,user2_data.lastname) username3,junk = \ self.testdata.find_account_for('networkworkspace') user3_data = self.testdata.get_userdata_for(username3) user3_name = '{0} {1}'.format(user3_data.firstname,user3_data.lastname) self.po.share.share_session_with([username2]) self.po.share.share_session_with([username3]) shared_with_2 = self.po.share.get_shared_with() assert len(shared_with_1)+2 == len(shared_with_2), \ "after sharing the session, wrong # users listed: " \ + "before: %s, after: %s" % (shared_with_1,shared_with_2) assert user2_name in shared_with_2, \ "after sharing session with %s, user %s" % (username2,user2_name) \ + " does not show up in shared with list: %s" % (shared_with_2) assert user3_name in shared_with_2, \ "after sharing session with %s, user %s" % (username3,user3_name) \ + " does not show up in shared with list: %s" % (shared_with_2) def test_disconnect_1(self): """ test disconnecting a connected user from a tool session container """ shared_with_1 = self.po.share.get_shared_with() username2,junk = \ self.testdata.find_account_for('purdueworkspace') user2_data = self.testdata.get_userdata_for(username2) user2_name = '{0} {1}'.format(user2_data.firstname,user2_data.lastname) # share the session with someone self.po.share.share_session_with(username2) shared_with_2 = self.po.share.get_shared_with() assert user2_name in shared_with_2, \ "after sharing session with %s, user does" % (username2) \ + " not show up in shared with list %s" % (shared_with_2) # disconnect user from session self.po.share.disconnect(username2) # check that user was disconnected shared_with_3 = self.po.share.get_shared_with() assert user2_name not in shared_with_3, \ "after unsharing session with %s, user %s" \ % (username2, user2_name) \ + " still shows up in shared with list: %s" \ % (shared_with_3)
class TestToolSessionApp(TestCase2): def setup_method(self,method): # start up a tool session container self.hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') self.cm = ContainerManager() self.ws = self.cm.access(host=self.hubname, username=self.username, password=self.userpass) self.session_number,es = self.ws.execute('echo $SESSION') self.ws.close() # setup a web browser self.browser.get(self.https_authority) self.utils.account.login_as(self.username,self.userpass) self.po = self.catalog.load_pageobject('ToolSessionPage', 'workspace',int(self.session_number)) self.po.goto_page() def teardown_method(self,method): # get out of the workspace # shut down the ssh connection self.cm.sync_open_sessions(self.hubname,self.username) def test_terminate_container(self): """ test pressing the terminate button on the app """ # press the terminate button self.po.app.do_terminate() # check that the container terminated po = self.catalog.load_pageobject('MembersDashboardPage') po.goto_page() open_sessions = po.modules.my_sessions.get_session_numbers() assert int(self.session_number) not in open_sessions,\ "after terminating session %s," % (self.session_number) \ + " session still listed as open in my_sessions module" def test_keep_container(self): """ test pressing the keep button on the app """ # press the keep button self.po.app.do_keep() # check that the container is still open po = self.catalog.load_pageobject('MembersDashboardPage') po.goto_page() open_sessions = po.modules.my_sessions.get_session_numbers() assert int(self.session_number) in open_sessions,\ "after keeping session %s," % (self.session_number) \ + " session not listed as open in my_sessions module" # def test_popout_container(self): # """ # test pressing the popout button on the app to popout the app # """ # # browser = self.browser._browser # # # get current window info # url1 = browser.current_url # current_window = browser.current_window_handle # # # press the popout button # self.po.app.do_popout() # # # find the popup window # other_window = None # for w in browser.window_handles: # if w != current_window: # other_window = w # # assert other_window is not None, \ # "after pressing the popout button, no window popped out" # # # def test_popout_container_close(self): # """ # test closing the popped out app does not end the session # """ # # browser = self.browser._browser # # # get current window info # url1 = browser.current_url # current_window = browser.current_window_handle # # # press the popout button # self.po.app.do_popout() # # # find the popup window # other_window = None # for w in browser.window_handles: # if w != current_window: # other_window = w # # assert other_window is not None, \ # "after pressing the popout button, no window popped out" # # # switch to the popup window # browser.switch_to_window(other_window) # # # close the popup window # browser.close() # browser.switch_to_window(current_window) # # # check that the container is still open # po = self.catalog.load_pageobject('MembersDashboardPage') # po.goto_page() # open_sessions = po.modules.my_sessions.get_session_numbers() # # assert int(self.session_number) in open_sessions,\ # "after closing popped out app," \ # + " session %s not listed as open in my_sessions module" \ # % (self.session_number) # # # def test_popout_container_popin(self): # """ # test popping-in a popped out app # """ # # browser = self.browser._browser # # # get current window info # url1 = browser.current_url # current_window = browser.current_window_handle # # # press the popout button # self.po.app.do_popout() # # # find the popup window # other_window = None # for w in browser.window_handles: # if w != current_window: # other_window = w # # assert other_window is not None, \ # "after pressing the popout button, no window popped out" # # # pop the container back in the browser # self.po.app.do_popout() # # # make sure the popped-out window closes # other_window = None # for w in browser.window_handles: # if w != current_window: # other_window = w # # assert other_window is None, \ # "after pressing the 'pop in' button," \ # + " the popped out window still exists" # # # check that the container is still open # po = self.catalog.load_pageobject('MembersDashboardPage') # po.goto_page() # open_sessions = po.modules.my_sessions.get_session_numbers() # # assert int(self.session_number) in open_sessions,\ # "after popping in the tool session container app," \ # + " session %s not listed as open in my_sessions module" \ # % (self.session_number) @hubcheck.utils.hub_version(min_version='1.1.2') @pytest.mark.user_storage def test_storage_meter(self): """ retrieve the free storage amount """ storage_amount = self.po.app.storage.storage_meter() assert storage_amount != '', \ "invalid storage amount returned: %s" % (storage_amount) assert storage_amount != '0% of 0GB', \ "user quotas not activated: storage_amount = %s" % (storage_amount)
class TestHCUnitContainerManager(object): def test_get_buffer_3(self,ssh_shell): """check for empty buffer after retrieving prompt """ p = ssh_shell.get_prompt() buf = ssh_shell.get_buffer() assert buf == '', "buf = '%s', expected ''" % (buf) def setUp(self): self.cm = ContainerManager() self.host1 = '' self.user11 = '' self.pass11 = '' self.user12 = '' self.pass12 = '' self.host2 = '' self.user21 = '' self.pass21 = '' self.user22 = '' self.pass22 = '' def tearDown(self): self.cm.stop_all() self.cm.clear() def test_access_new_session(self,cm): """ """ ws = cm.access(self.host1,self.user11,self.pass11) session_number,es = ws.execute('echo $SESSION') self.assertTrue(int(session_number) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number) ws.close() def test_access_previously_opened_session(self): """ """ # open the first tool session container ws1 = self.cm.access(self.host1,self.user11,self.pass11) session_number1,es = ws1.execute('echo $SESSION') # exit the container ws1.close() # make sure we got into the container self.assertTrue(int(session_number1) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number1) # open the second tool session container ws2 = self.cm.access(self.host1,self.user11,self.pass11) session_number2,es = ws2.execute('echo $SESSION') ws2.close() # make sure we got into the second container self.assertTrue(int(session_number2) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number2) # check that the first and second containers were the same # by comparing the session number self.assertTrue(int(session_number1) == int(session_number2), "connecting twice to the same session failed: session_number1 = %s, session_number2 = %s" \ % (session_number1,session_number2)) def test_access_sessions_for_different_users_same_host(self): """ """ # open tool session container for user1 ws1 = self.cm.access(self.host1,self.user11,self.pass11) session_number1,es = ws1.execute('echo $SESSION') # exit the container ws1.close() # make sure we got into the container self.assertTrue(int(session_number1) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number1) # open tool session container for user2 ws2 = self.cm.access(self.host1,self.user12,self.pass12) session_number2,es = ws2.execute('echo $SESSION') ws2.close() # make sure we got into the second container self.assertTrue(int(session_number2) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number2) # check that the first and second containers are different # by comparing the session number self.assertTrue(int(session_number1) != int(session_number2), "trying to connect to two different containers, as different users failed: session_number1 = %s, session_number2 = %s" \ % (session_number1,session_number2)) def test_access_sessions_for_different_users_different_host(self): """ """ # open tool session container for user1 ws1 = self.cm.access(self.host1,self.user11,self.pass11) session_number1,es = ws1.execute('echo $SESSION') # exit the container ws1.close() # make sure we got into the container self.assertTrue(int(session_number1) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number1) # open tool session container for user2 ws2 = self.cm.access(self.host2,self.user21,self.pass21) session_number2,es = ws2.execute('echo $SESSION') ws2.close() # make sure we got into the second container self.assertTrue(int(session_number2) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number2) # check that the first and second containers are different # by comparing the session number self.assertTrue(int(session_number1) != int(session_number2), "trying to connect to two different containers, as different users failed: session_number1 = %s, session_number2 = %s" \ % (session_number1,session_number2)) def test_stop_session_1(self): """ close a session that is open """ # open a session ws1 = self.cm.access(self.host1,self.user11,self.pass11) session_number1,es = ws1.execute('echo $SESSION') self.assertTrue(int(session_number1) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number1) ws1.close() # stop the tool session container self.cm.stop(self.host1,self.user11,session_number1) session = ToolSession(host=self.host1, username=self.user11, password=self.pass11) data = session.get_open_session_detail() for k,v in data.items(): if v['session_number'] == session_number1: self.assertTrue(v['session_number'] == session_number1, "session %s still open, after calling stop()" \ % (session_number1)) def test_stop_session_2(self): """ try to close a session that is not open """ # open a temporary session # so we can get a session in the stop() method ws1 = self.cm.access(self.host1,self.user11,self.pass11) session_number1,es = ws1.execute('echo $SESSION') self.assertTrue(int(session_number1) > 0, "session_number = %s, i don't think we are in a workspace" \ % session_number1) ws1.close() try: # stop the tool session container session_number2 = 1234 self.cm.stop(self.host1,self.user11,session_number2) finally: # close the temporary session self.cm.stop(self.host1,self.user11,session_number1)
def upload_code(self, toolname, data, username, userpass, msg): """ upload source code into the source code repository data is a dictionary that links files on the local file system to a path relative to the checked out svn repository. example: data = { '/home/hubzero/testuser/main.c' : 'src/main.c', '/home/hubzero/testuser/Makefile' : 'src/Makefile', '/home/hubzero/testuser/tool.xml' : 'rappture/tool.xml', } """ self.logger.info("uploading source code for the tool '%s'" % (toolname)) repo_url = self.repo_url_template % {"hubname": self.hubname, "toolname": toolname} # ssh into a tool session container cm = ContainerManager() ws = cm.access(host=self.hubname, username=username, password=userpass) svn = Subversion(ws, username, userpass) session_number = -1 repo_home = None try: session_number, es = ws.execute("echo $SESSION") if session_number <= 0: raise RuntimeError("invalid session number: %s" % (session_number)) # create a temp directory to hold the repo repo_home, es = ws.execute("mktemp -d --tmpdir=`pwd` -t tmp.XXXXXXXX") ws.execute("cd %s" % (repo_home)) # do the checkout svn.checkout(repo_url, toolname) # cd into the repo ws.execute("cd %s" % (toolname)) tool_repo, es = ws.execute("pwd") # add some code commit_files = [] for localpath, remotepath in data.items(): commit_files.append(remotepath) remotepath = os.path.join(tool_repo, remotepath) ws.importfile(localpath, remotepath) # commit the source code repository svn.add(commit_files) revision = svn.commit("initial upload of source code") if revision is None: raise RuntimeError("commit failure, revision is None") finally: # FIXME: remove the temp directory ws.send_raw("") ws.send_raw("") time.sleep(5) if repo_home is not None: ws.execute("rm -rf %s" % (repo_home)) # shut down the ssh connection ws.close()
def update(self, toolname, username, userpass): """ update the svn repository with a change so the tool can be installed in this case we update the invoke script because all tools should have one. we change a predetermined line starting with '# hc contribtool update: DATE' Where the term DATE is replaced with a date time stamp """ self.logger.info("updating svn repository for the tool '%s'" % (toolname)) repo_url = self.repo_url_template % {"hubname": self.hubname, "toolname": toolname} # ssh into a tool session container cm = ContainerManager() ws = cm.access(host=self.hubname, username=username, password=userpass) svn = Subversion(ws, username, userpass) session_number = -1 repo_home = None try: session_number, es = ws.execute("echo $SESSION") if session_number <= 0: raise RuntimeError("invalid session number: %s" % (session_number)) # create a temp directory to hold the repo repo_home, es = ws.execute("mktemp -d --tmpdir=`pwd` -t tmp.XXXXXXXX") ws.execute("cd %s" % (repo_home)) # do the checkout svn.checkout(repo_url, toolname) # cd into the repo ws.execute("cd %s" % (toolname)) tool_repo, es = ws.execute("pwd") # add the marker to the invoke script if it does not exist script_path = "middleware/invoke" script_data = ws.read_file(script_path) if re.search(self.update_marker, script_data) is None: # file doesn't have the marker, add it script_data += "\n%sDATE" % (self.update_marker) # update the marker with the current date time stamp dts = datetime.datetime.today().strftime("%Y%m%d%H%M%S") pattern = self.update_marker + ".*" replace = self.update_marker + dts script_data = re.sub(pattern, replace, script_data) # write the change back to the disk ws.write_file(script_path, script_data) # commit the changed file back to the source code repository revision = svn.commit("updating the invoke script") if revision is None: raise RuntimeError("commit failure, revision is None") finally: # FIXME: remove the temp directory ws.send_raw("") ws.send_raw("") time.sleep(5) if repo_home is not None: ws.execute("rm -rf %s" % (repo_home)) # shut down the ssh connection ws.close() # navigate to the tool status page po = self.catalog.load_pageobject("ToolsStatusInstalledPage", toolname) po.goto_page() # on web page, mark project as updated po.flip_status_to_updated() self.__wait_for_tool_state(po, "Updated")
def compile_code(self, toolname, adminuser, adminpass): """ ssh into a tool session container as a tool manager, compile a tool's source code, and install the binaries """ # ssh into a tool session container as the tools manager # compile and install the code # get into a tool session container. cm = ContainerManager() ws = cm.access(host=self.hubname, username=adminuser, password=adminpass) session_number, es = ws.execute("echo $SESSION") # catch errors that happen in the shell # so we can properly exit and close the workspace try: # become the apps user ws.send("sudo su - apps") ws.start_bash_shell() output, es = ws.execute("whoami") exit_apps = True if output != "apps": exit_apps = False msg = "doesn't look like we were able to become the apps user" self.logger.error(msg) raise Exception(msg) # catch compile and install errors # so we can report them back to the developer # navigate to the tool directory cmd = "cd /apps/%(toolname)s/dev/src" % {"toolname": toolname} ws.execute(cmd) # if there is a makefile available # run: # make clean # make all # make install # don't fail if there is no clean or all targets if ws.bash_test("-e Makefile"): # allow 30 minutes for the code to compile ws.timeout = 1800 output, es = ws.execute("make clean", False) output, es = ws.execute("make all", False) no_make_all_text = "make: *** No rule to make target `all'. Stop." if es > 0: if es == 2 and output == no_make_all_text: output, es = ws.execute("make") else: self.logger.exception(output) raise ExitCodeError(output) output, es = ws.execute("make install") ws.timeout = 10 else: msg = "No Makefile found" print msg self.logger.info(msg) finally: # exit sudo ws.stop_bash_shell() if exit_apps: ws.send("exit") # shut down the ssh connection ws.close()
class members_dashboard_my_session_item_2(TestCase): def setUp(self): # start up a tool session container self.hubname = self.testdata.find_url_for('https') self.username,self.userpass = \ self.testdata.find_account_for('purdueworkspace') self.cm = ContainerManager() self.ws = self.cm.create(host=self.hubname, username=self.username, password=self.userpass) self.session_number,es = self.ws.execute('echo $SESSION') self.session_number = int(self.session_number) # setup a web browser self.browser.get(self.https_authority) self.utils.account.login_as(self.username,self.userpass) self.po = self.catalog.load_pageobject('GenericPage') self.po.header.goto_myaccount() self.po = self.catalog.load_pageobject('MembersDashboardPage') self.my_sessions_module = self.po.modules.my_sessions def tearDown(self): # get out of the workspace # shut down the ssh connection self.ws.close() # resync our session data because in the test, # we attempted to close a session being tracked by cm self.cm.sync_open_sessions(self.hubname,self.username) @hubcheck.utils.hub_version(min_version='1.1.4') def test_terminate_click_accept(self): """ click the terminate session link and accept the confirmation """ pageurl1 = self.po.current_url() num_sessions_1 = self.my_sessions_module.count_sessions() session_item = self.my_sessions_module.get_session_by_session_number( self.session_number) self.assertTrue(session_item is not None, 'No session exists for session numbered: %s' % (self.session_number)) # open the slide down window if not session_item.is_slide_open(): session_item.toggle_slide() session_item.terminate_session(confirm=True) self.my_sessions_module = self.po.modules.my_sessions session_numbers = self.my_sessions_module.get_session_numbers() self.assertTrue(self.session_number not in session_numbers, "after confirming the termination of a session" + " the session %d still appears in the list of open sessions" % (self.session_number))
class TestIcewmUserConfig(TestCase2): def setup_method(self,method): # get user account info self.username,self.userpass = \ self.testdata.find_account_for('registeredworkspace') self.hubname = self.testdata.find_url_for('https') # get into a workspace self.cm = ContainerManager() self.ws = self.cm.access(host=self.hubname, username=self.username, password=self.userpass) def teardown_method(self,method): pass def _check_icewm_config_file(self,fname,points_to): # check the file is a link assert self.ws.bash_test('-L {0}'.format(fname)), \ '"{0}" not a link'.format(fname) # check the file points to default config command = 'readlink -e {0}'.format(fname) output,es = self.ws.execute(command) assert output == points_to, \ '"{0}" points to "{1}", expected "{2}"'.format(fname,output,points_to) # check the default config is readable assert self.ws.bash_test('-r {0}'.format(points_to)), \ '"{0}" not a readable'.format(points_to) def test_icewm_config(self): """ check icewm config files point to hubzero config """ # check if the icewm directory was created. msg = "User's IceWM config directory (~/.icewm) was not recreated" + \ " by new workspace after being deleted" assert self.ws.bash_test('-d {0}'.format(ICEWM_CONF_DIR)), msg msg = "User's IceWM config directory (~/.icewm) is not readable" + \ " by new workspace after being deleted" assert self.ws.bash_test('-r {0}'.format(ICEWM_CONF_DIR)), msg # check if the user has the default icewm user config for hubzero for (fname,points_to) in ICEWM_CONF_FILE_SPEC: self._check_icewm_config_file(fname,points_to) def test_updated_icewm_config(self): """ check if starting a workspace created a new icewm config directory after the user deleted their original one. """ # remove the user's icewm config dir self.ws.execute('rm -rf ~/.icewm') session_number = 0 # create a new workspace ws2 = self.cm.create(host=self.hubname, username=self.username, password=self.userpass) session_number,es = ws2.execute('echo $SESSION') # exit the new workspace ws2.close() # stop the new container self.cm.stop(self.hubname,self.username,int(session_number)) # check if the icewm directory was created. msg = "User's IceWM config directory (~/.icewm) was not recreated" + \ " by new workspace after being deleted" assert self.ws.bash_test('-d {0}'.format(ICEWM_CONF_DIR)), msg msg = "User's IceWM config directory (~/.icewm) is not readable" + \ " by new workspace after being deleted" assert self.ws.bash_test('-r {0}'.format(ICEWM_CONF_DIR)), msg # check if the user has the default icewm user config for hubzero for (fname,points_to) in ICEWM_CONF_FILE_SPEC: self._check_icewm_config_file(fname,points_to)