def success(event): if (event.GetId() == KeyDist.EVT_KEYDIST_AUTHSUCCESS): logger.debug("received AUTHSUCCESS event") event.keydist._completed.set() if (event.keydist.callback_success != None): event.keydist.callback_success() event.Skip()
def get_log(topology_name, num_lines=10): filenames = StormUI.getWorkersByTopologyName(topology_name) lines = "" if filenames: logger.debug("Filenames for topology " + topology_name + " -> " + str(filenames)) for filename in filenames: logger.info("Topology :" + topology_name + " - LogFilename: " + filename) # get log file from storm cluster n_lines = int(num_lines) * 100 content = StormUI.getFile(filename, n_lines) try: # Remove HTML tags from Storm Log 8000 port logcontent = BeautifulSoup(content, "lxml").find( "pre", {"id": "logContent"}) if logcontent: lines += "\n###################################################\n" (hostname, port, name) = LogViewer.parse_worker_info(filename) lines += "Log from worker: " + hostname + " - " + name + "\n" lines += "###################################################\n" lines += logcontent.getText() logger.debug("Getting " + str(len(lines.splitlines())) + " lines.") except Exception as e: return "Error parsing data from Storm UI:" + str(e) return lines
def keyLockedCallback(): logger.debug("Callback: Key locked.") dlg = wx.MessageDialog(self, "Your key appears to be locked.", "MASSIVE/CVL Launcher", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() self.existingPassphraseField.SetSelection(-1,-1) self.existingPassphraseField.SetFocus()
def createKey(self): createNewKeyDialog = CreateNewKeyDialog( None, None, wx.ID_ANY, "Strudel Private Key", self.launcherMainFrame.keyModel.getPrivateKeyFilePath(), self.launcherMainFrame.displayStrings, ) createNewKeyDialog.Center() if createNewKeyDialog.ShowModal() == wx.ID_OK: logger.debug("User pressed OK from CreateNewKeyDialog.") password = createNewKeyDialog.getPassphrase() def success(): pass def failure(): pass self.launcherMainFrame.keyModel.generateNewKey(password, success, failure, failure) createdKey = True else: logger.debug("User canceled from CreateNewKeyDialog.") createdKey = False return createdKey
def run(self): # I have a problem where I have multiple identity files in my ~/.ssh, and I want to use only identities loaded into the agent # since openssh does not seem to have an option to use only an agent we have a workaround, # by passing the -o IdentityFile option a path that does not exist, openssh can't use any other identities, and can only use the agent. # This is a little "racy" in that a tempfile with the same path could conceivably be created between the unlink and openssh attempting to use it # but since the pub key is extracted from the agent not the identity file I can't see anyway an attacker could use this to trick a user into uploading the attackers key. threadid = threading.currentThread().ident logger.debug("testAuthThread %i: started" % threadid) try: if (self.keydistObject.authorise.testAuth( keyModel=self.keydistObject.keyModel, username=self.keydistObject.username, host=self.keydistObject.host, timeout=160)): newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_AUTHSUCCESS, self.keydistObject) else: newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_AUTHFAIL, self.keydistObject) except Exception as e: import traceback logger.debug("testAuth failed with exception %s" % e) logger.debug(traceback.format_exc()) newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_AUTHFAIL, self.keydistObject) if (not self.stopped()): logger.debug( "testAuthThread %i: self.stopped() == False, so posting event: " % threadid + str(newevent)) wx.PostEvent(self.keydistObject.notifywindow.GetEventHandler(), newevent) logger.debug("testAuthThread %i: stopped" % threadid)
def getPassphrase(self, reason=None): from CreateNewKeyDialog import CreateNewKeyDialog createNewKeyDialog = CreateNewKeyDialog( self.parentWindow, self.progressDialog, wx.ID_ANY, self.parentWindow.programName, self.keyModel.getPrivateKeyFilePath(), self.displayStrings, displayMessageBoxReportingSuccess=False) try: wx.EndBusyCursor() stoppedBusyCursor = True except: stoppedBusyCursor = False canceled = createNewKeyDialog.ShowModal() == wx.ID_CANCEL if stoppedBusyCursor: wx.BeginBusyCursor() if (not canceled): logger.debug("User didn't cancel from CreateNewKeyDialog.") self.password = createNewKeyDialog.getPassphrase() event = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_NEWPASS_COMPLETE, self) wx.PostEvent(self.notifywindow.GetEventHandler(), event) else: logger.debug( "KeyDist.getPassphrase: User canceled from CreateNewKeyDialog." ) self.cancel()
def compile(base_path, quiet_mode=True): try: result = Mvn.compile_module(base_path, quiet_mode) except CommandException as e: result = e logger.debug('Command output: ' + str(result.log())) return Mvn.parse_process_result(result)
def keyLockedCallback(): logger.debug("Callback: Key locked.") dlg = wx.MessageDialog(self, "Your key appears to be locked.", "Strudel", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() self.existingPassphraseField.SetSelection(-1, -1) self.existingPassphraseField.SetFocus()
def authfail(event): if (event.GetId() == KeyDist.EVT_KEYDIST_AUTHFAIL and not event.keydist.canceled()): if (not event.keydist.keyloaded.isSet()): newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_LOADKEY, event.keydist) wx.PostEvent(event.keydist.notifywindow.GetEventHandler(), newevent) else: # If the key is loaded into the ssh agent, then authentication failed because the public key isn't on the server. # *****TODO***** # Actually this might not be strictly true. GNOME Keychain (and possibly others) will report a key loaded even if its still locked # we probably need a button that says "I can't remember my old key's passphrase, please generate a new keypair" if (event.keydist.keycopied.isSet()): newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_TESTAUTH, event.keydist) logger.debug( "received AUTHFAIL event from thread %i %s posting TESTAUTH event in response" % (event.threadid, event.threadname)) wx.PostEvent( event.keydist.notifywindow.GetEventHandler(), newevent) else: newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_COPYID, event.keydist) logger.debug( "received AUTHFAIL event from thread %i %s posting COPYID event in response" % (event.threadid, event.threadname)) wx.PostEvent( event.keydist.notifywindow.GetEventHandler(), newevent) else: event.Skip()
def createKey(self): logger.debug('in createKey method') if not self._stopped.isSet(): if self.keyModel.isTemporaryKey(): logger.debug('generating a temporary key passphrase') import string import random oneTimePassphrase=''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for x in range(10)) logger.debug("tempoary key oneTimePassphrase: " + oneTimePassphrase) self.password = oneTimePassphrase self.removeKeyOnExit.set() else: logger.debug('requesting a permenant key passphrase') queue=Queue.queue() wx.CallAfter(self.getPassphrase,queue=queue) (canceled,self.password)=queue.get() if canceled: self._stopped.set() self.cancelMessage="canceled while requesting a new ssh key passphrase" self._exit.set() if not self._stopped.isSet(): def success(): logger.debug('succesfully generated a new ssh key') self.keyCreated.set() def failure(): logger.debug("failed to generate a new ssh key") self.cancelMessage="Unable to generate a new key pair" self._stopped.set() self._exit.set() if not self._stopped.isSet(): logger.debug('generating a new ssh key') self.keyModel.generateNewKey(self.password,success,failure,failure)
def processIdP(self,session,text,url,idpName,user,pw): p = AAF_Auth.genericForm() p.feed(text) import getpass import sys import Queue userRequired=False passwordRequired=False queue=Queue.Queue() for i in p.inputs.keys(): if ('user' in i or 'User' in i) and p.inputs[i]==None: p.inputs[i] = user if ('pass' in i or 'Pass' in i) and p.inputs[i]==None: p.inputs[i] = pw try: nexturl = p.attrs['action'] except: nexturl = url logger.debug('idp form inputs %s'%p.inputs) for k in p.inputs.keys(): if 'RESET' in k.upper(): logger.debug('deleting the input %s from the attribute release form'%k) del p.inputs[k] if not 'http' in nexturl[0:4]: nexturl=url.split('/')[0]+'//'+url.split('/')[2]+nexturl r=session.post(nexturl,data=p.inputs,verify=False) return r
def removeEC2Creds(self): from logger.Logger import logger import shutil try: shutil.rmtree(self.ec2path, ignore_errors=True) except: logger.debug("unable to remove ec2 credentials")
def getFingerprintAndKeyTypeFromPrivateKeyFile(self): logger.debug("KeyModel.getFingerprintAndKeyTypeFromPrivateKeyFile") proc = subprocess.Popen([ self.sshPathsObject.sshKeyGenBinary.strip('"'), "-yl", "-f", self.getPrivateKeyFilePath() ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, startupinfo=self.startupinfo, creationflags=self.creationflags) stdout, stderr = proc.communicate() publicKeyFingerprint = None keyType = None if stdout != None: sshKeyGenOutComponents = stdout.split(" ") if len(sshKeyGenOutComponents) > 1: publicKeyFingerprint = sshKeyGenOutComponents[1] if len(sshKeyGenOutComponents) > 3: keyType = sshKeyGenOutComponents[-1].strip().strip("(").strip( ")") self.pubKeyFingerprint = publicKeyFingerprint return (publicKeyFingerprint, keyType)
def startevent(event): if (event.GetId() == KeyDist.EVT_KEYDIST_START): logger.debug("received KEYDIST_START event") newevent = KeyDist.sshKeyDistEvent(KeyDist.EVT_KEYDIST_SCANHOSTKEYS,event.keydist) wx.PostEvent(event.keydist.notifywindow.GetEventHandler(),newevent) else: event.Skip()
def onClose(self, e): logger.debug("ListSelectionDialog.onClose: button ID %s okButton ID %s cancelButton ID %s"%(e.GetId(),self.okButton.GetId(),self.cancelButton.GetId())) if (e.GetId() == self.cancelButton.GetId()): logger.debug("ListSelectionDialog.onClose: User canceled.") if self.cancelCallback != None: #self.cancelCallback("User canceled from ListSelectionDialog.") self.cancelCallback("") self.Destroy() return if self.listSelectionList.GetFirstSelected()==-1: dlg = wx.MessageDialog(self.parent, self.noSelectionMessage, "MASSIVE/CVL Launcher", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() self.listSelectionList.SetFocus() return itemnum=self.listSelectionList.GetFocusedItem() item=self.listSelectionList.GetItem(itemnum,0) if self.okCallback != None: self.okCallback(item) self.Destroy() if self.closedProgressDialog: if self.progressDialog is not None: self.progressDialog.Show(True)
def createKey(self): createNewKeyDialog = CreateNewKeyDialog( None, None, wx.ID_ANY, 'Strudel Private Key', self.launcherMainFrame.keyModel.getPrivateKeyFilePath(), self.launcherMainFrame.displayStrings) createNewKeyDialog.Center() if createNewKeyDialog.ShowModal() == wx.ID_OK: logger.debug("User pressed OK from CreateNewKeyDialog.") password = createNewKeyDialog.getPassphrase() def success(): pass def failure(): pass self.launcherMainFrame.keyModel.generateNewKey( password, success, failure, failure) createdKey = True else: logger.debug("User canceled from CreateNewKeyDialog.") createdKey = False return createdKey
def gettoken(self): retry = True while retry: import Queue queue = Queue.Queue() wx.CallAfter(self.queryUserPass, queue, self.username) res = queue.get() if res == None: raise Exception("Login cancelled") else: (self.username, self.passwd) = res logger.debug('queryIdPUserPass set values for user: %s.' % (self.username)) r = self.session.post(self.destURL, auth=(self.clientusername, self.clientpasswd), data={ 'grant_type': 'password', 'username': self.username, 'password': self.passwd }, verify=False) if r.status_code == 200: data = json.loads(r.text) retry = False else: logger.debug('AS portal reported %s %s' % (r.status_code, r.text)) return data['data']['access_token']
def cancel(self,message=""): if (not self.canceled()): self._canceled.set() newevent = KeyDist.sshKeyDistEvent(KeyDist.EVT_KEYDIST_SHUTDOWN, self) newevent.arg = message logger.debug('sshKeyDist.cancel: setting canceled, sending EVT_KEYDIST_SHUTDOWN event.') wx.PostEvent(self.notifywindow.GetEventHandler(), newevent)
def processIdP(self,session,text,url,idpName,user,pw): p = AAF_Auth.genericForm() p.feed(text) import getpass import sys import Queue userRequired=False passwordRequired=False queue=Queue.Queue() for i in p.inputs.keys(): if ('user' in i or 'User' in i) and p.inputs[i]==None: p.inputs[i] = user if ('pass' in i or 'Pass' in i) and p.inputs[i]==None: p.inputs[i] = pw try: nexturl = p.attrs['action'] except: nexturl = url #logger.debug('idp form inputs %s'%p.inputs) for k in p.inputs.keys(): if 'RESET' in k.upper(): logger.debug('deleting the input %s from the attribute release form'%k) del p.inputs[k] if not 'http' in nexturl[0:4]: nexturl=url.split('/')[0]+'//'+url.split('/')[2]+nexturl r=session.post(nexturl,data=p.inputs,verify=False) return r
def Refresh(self, incrementProgressDialog): dataDir = self.settingsModel.GetDataDirectory() logger.debug("UsersModel.Refresh(): Scanning " + dataDir + "...") usernames = os.walk(dataDir).next()[1] for username in usernames: logger.debug("\nFound subdirectory assumed to be username: "******"Didn't find a MyTardis user record for \"" + \ username + "\"" dlg = wx.MessageDialog(None, message, "User not found", wx.OK | wx.ICON_ERROR) dlg.ShowModal() userRecord = UserModel(settingsModel=self.settingsModel, id=id, username=username, name="USER NOT FOUND IN MYTARDIS", email="USER NOT FOUND IN MYTARDIS") userRecord.SetId(id) self.AddRow(userRecord) self.foldersModel\ .ImportFolders(os.path.join(dataDir, username), userRecord) incrementProgressDialog()
def run(self): try: pubKeyPath=self.keydistObject.keyModel.getPrivateKeyFilePath()+".pub" with open(pubKeyPath,'r') as f: pubkey=f.read() self.obj.copyID() logger.debug("KeyDist.CopyIDThread: copyID returned without error") event = KeyDist.sshKeyDistEvent(KeyDist.EVT_KEYDIST_TESTAUTH,self.keydistObject) # If the object represented an attempt at logging onto AAF, then we will try to get the IdP and save it for next time. # If its not an AAF login, we will catch the exception and pass try: idp=self.obj.getIdP() self.keydistObject.updateDict['idp']=idp except Exception as e: pass # This try catch means that if, in the course of authenticing the user, the authentication mechanism was able to tell us the username # That username will be updated. Example. Authenticing via AAF, I know I'm at Monash, and my Monash username is chines. # Monash will tell CVL what my email address is. CVL can look up my CVL username based on my email address. try: newusername=self.obj.getUsername() self.keydistObject.updateDict['username']=newusername except Exception as e: pass except Exception as e: logger.debug('CopyIDThread: threw exception : ' + str(e)) self.keydistObject.cancel(message=str(e)) return if (not self.stopped()): wx.PostEvent(self.keydistObject.notifywindow.GetEventHandler(), event) self.keydistObject.keyModel.copiedID.set() self.keydistObject.keycopied.set() self.keydistObject.__dict__.update(self.keydistObject.updateDict)
def stopAgent(self): logger.debug("KeyModel.stopAgent: stopping the agent") logger.debug("KeyModel.stopAgent: On Windows, we will stop charade.exe or ssh-agent.exe (whichever one is running),") logger.debug("KeyModel.stopAgent: but we won't stop Pageant, because Pageant is what allows the user to run the") logger.debug("KeyModel.stopAgent: Launcher again without having to re-enter their passphrase.") # The code below was presumably added so that when a new Launcher version is installed, # we can avoid the warning from the Setup Wizard that a Pageant process will need to be terminated # and then restarted after the new version is installed. But this mechanism of allowing the Setup # Wizard to terminate and restart Pageant seems to work fine in my experience - JW. # This is not the case for the OpenSSH / Cygwin binaries and DLLs - we definitely don't want any # of them to be running when we try to install a new Launcher version with the Windows Setup Wizard. #if self.pageant!=None: #pageantPid=self.pageant.pid #self.pageant.kill() #self.pageant=None # Do no use self.sshAgentProcess.kill() the sshAgentProcess forks the real agent and exits so the kill won't get the real process if self.sshAgentProcess!=None: import signal try: os.kill(int(self.agentPid),signal.SIGTERM) except: logger.debug(traceback.format_exc()) if 'PREVIOUS_SSH_AUTH_SOCK' in os.environ: os.environ['SSH_AUTH_SOCK'] = os.environ['PREVIOUS_SSH_AUTH_SOCK'] del os.environ['PREVIOUS_SSH_AUTH_SOCK'] else: del os.environ['SSH_AUTH_SOCK'] self.sshAgentProcess=None
def testAuth(self): logger.debug('skd attempting to test authorisation') logger.debug('usernamed set to %s' % self.jobParams['username']) return self.authoriser.testAuth(keyModel=self.keyModel, username=self.jobParams['username'], host=self.jobParams['loginHost'], timeout=160)
def __init__(self,s,destURL,parent,idp=None): self.parent=parent self.idp=idp r=s.get(destURL,verify=False) if destURL in r.url: # We already have a valid session with the web service logger.debug('AAF cycle unnecessary, we\'re already auth\'d to this service') self.response=r return if r.url.startswith('https://ds'): # we've been redirected to the AAF discovery service logger.debug('AAF cycle sent us to the discovery service. Prompting for the correct IdP') p = AAF_Auth.DSForm() p.feed(r.text) import Queue queue=Queue.Queue() wx.CallAfter(self.queryIdP,p.options,queue,self.idp) res=queue.get() if res==None: raise Exception("Login cancled") else: (myidp,self.idp)=res d={} d['user_idp'] = myidp.encode('ascii') d['Select']='Select' nexturl = p.attrs['action'] if not 'http' in nexturl[0:4]: nexturl=r.url.split('/')[0]+'//'+r.url.split('/')[2]+nexturl r=s.post(nexturl,data=d,verify=False) else: logger.debug('AAF cycle bypassed the discovery service. Perhaps the web service sent us directly to an IdP? This is unusual, but within spec') if destURL in r.url: # If we have a session with the IdP and the IdP didn't ask to release attributes, we might already be at the destionation URL self.response=r return p=AAF_Auth.genericForm() # If we're no at the destURL we should be at either the IdP authentication page, or the IdP attribute release page # Not tested. I think if we already have session with the idp, the IdP may return an attribute release form rather than a login form. the method self.idp should still work. while (not p.inputs.has_key('SAMLResponse')): if destURL in r.url: # I'm puzzled by this, I though the SAMLResponse would always come as a hidden field in a form from the IdP along with a redirect, but apparently not self.response=r return r=self.processIdP(s,r.text,r.url) p=AAF_Auth.genericForm() p.feed(r.text) if destURL in r.url: # We have succeeded logger.debug('AAF cycle succeeded') self.response=r return nexturl = p.attrs['action'] r=s.post(nexturl,data=p.inputs,verify=False) # We need one more post? This seems to be the behaviour on NeCTAR if destURL in r.url: # We have succeeded logger.debug('AAF Cycle succeeded with the extra post') self.response=r return else: raise Exception("We went through the whole AAF cycle, but didn't end up where the though we would. This is a bug. Please help us fix this up by sending an email/crash report")
def privateKeyFileNotFoundCallback(): message = "Private key file not found." logger.debug( "InspectKeyDialog.onAddKeyToOrRemoveFromAgent callback: " + message) dlg = wx.MessageDialog(self, message, "Strudel", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal()
def keylocked(event): if (event.GetId() == KeyDist.EVT_KEYDIST_KEY_LOCKED): logger.debug("received KEY_LOCKED event") wx.CallAfter(event.keydist.GetKeyPassphrase) if (event.GetId() == KeyDist.EVT_KEYDIST_KEY_WRONGPASS): logger.debug("received KEY_WRONGPASS event") wx.CallAfter(event.keydist.GetKeyPassphrase,incorrect=True) event.Skip()
def scanhostkeys(event): if (event.GetId() == KeyDist.EVT_KEYDIST_SCANHOSTKEYS): logger.debug("received SCANHOSTKEYS event") t = KeyDist.scanHostKeysThread(event.keydist) t.setDaemon(True) t.start() event.keydist.threads.append(t) event.Skip()
def passphraseIncorrectCallback(): message = "Passphrase incorrect." logger.debug( "InspectKeyDialog.onAddKeyToOrRemoveFromAgent callback: " + message) dlg = wx.MessageDialog(self, message, "Strudel", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal()
def failedToConnectToAgentCallback(): message = "Could not open a connection to your authentication agent." logger.debug( "InspectKeyDialog.onAddKeyToOrRemoveFromAgent callback: " + message) dlg = wx.MessageDialog(self, message, "Strudel", wx.OK | wx.ICON_INFORMATION) dlg.ShowModal()
def build_jar_with_dependencies(self, quiet_mode=False): result = Mvn.build_topology_jar(self.base_path, quiet_mode) logger.debug('Command output: ' + str(result.log())) result = Mvn.parse_process_result(result) if result: self.jar_name = self.topology[ TopologyConsts.FIELD_NAME] + '-1.0-jar-with-dependencies.jar' return result
def keylocked(event): if (event.GetId() == KeyDist.EVT_KEYDIST_KEY_LOCKED): logger.debug("received KEY_LOCKED event") wx.CallAfter(event.keydist.GetKeyPassphrase) if (event.GetId() == KeyDist.EVT_KEYDIST_KEY_WRONGPASS): logger.debug("received KEY_WRONGPASS event") wx.CallAfter(event.keydist.GetKeyPassphrase, incorrect=True) event.Skip()
def build_module_jar(self): execution = Mvn.build_module_jar(self.base_path, self.name, self.version) output = execution.stdout logger.debug('Command output: ' + str(output)) self.jar_file = os.path.join(self.base_path, 'target', self.name + '.' + self.version + '.jar')
def run(self,callback,failcallback): from logger.Logger import logger q=Queue.Queue() wx.CallAfter(self.createProgressDialog,q) self.progressDialog=q.get() logger.debug("Running NeCTAR Provisioning") try: wx.CallAfter(self.progressDialog.Update,0, "Logging into NeCTAR Dashboard") if not self._canceled.isSet(): self.loginNeCTAR() wx.CallAfter(self.progressDialog.Update,1, "Getting a list of your NeCTAR Projects") if not self._canceled.isSet(): self.getProjects() if not self._canceled.isSet(): self.queryProject() wx.CallAfter(self.progressDialog.Update,2, "Getting Cloud Credentials") if not self._canceled.isSet(): try: self.getEC2Creds() self.removeEC2Creds() self.connect() except Exception as e: import traceback logger.debug(traceback.format_exc()) raise e if not self._canceled.isSet(): self.ec2key=self.getKeyPairByFP(self.keyModel.getFingerprint()) if self.ec2key==None: tmpkey=self.getKeyPairByName("%s_%s"%(self.keyModel.sshpaths.keyFileName,self.ec2_access_key)) if tmpkey==None: self.ec2key=self.setKeyPair("%s_%s"%(self.keyModel.sshpaths.keyFileName,self.ec2_access_key),self.keyModel.getPubKey()) else: logger.debug("A keypair exists with my default name, but its fingerprint doesn't match. Deleting and recreating") self.connection.delete_key_pair("%s_%s"%(self.keyModel.sshpaths.keyFileName,self.ec2_access_key)) self.ec2key=self.setKeyPair("%s_%s"%(self.keyModel.sshpaths.keyFileName,self.ec2_access_key),self.keyModel.getPubKey()) wx.CallAfter(self.progressDialog.Update,3, "Getting a list of VMs you can connect to") if not self._canceled.isSet(): self.getInstances(keyname=self.ec2key.name) if not self._canceled.isSet(): if len(self.instances)>0: self.queryExisting() else: self.bootNew=True if not self._canceled.isSet(): if self.bootNew==True: wx.CallAfter(self.progressDialog.Update,3, "Booting a new Instance") self.bootVM() if not self._canceled.isSet(): self.updateDict.update(self.getInstanceDetails()) wx.CallAfter(self.progressDialog.Show,False) callback() except Exception as e: import traceback logger.debug(traceback.format_exc()) logger.debug(e) self.cancel(traceback.format_exc()) failcallback()
def startevent(event): if (event.GetId() == KeyDist.EVT_KEYDIST_START): logger.debug("received KEYDIST_START event") newevent = KeyDist.sshKeyDistEvent( KeyDist.EVT_KEYDIST_SCANHOSTKEYS, event.keydist) wx.PostEvent(event.keydist.notifywindow.GetEventHandler(), newevent) else: event.Skip()
def needagent(event): if (event.GetId() == KeyDist.EVT_KEYDIST_NEEDAGENT and not event.keydist.canceled()): logger.debug("received NEEDAGENT event") t = KeyDist.startAgentThread(event.keydist) t.setDaemon(True) t.start() event.keydist.threads.append(t) else: event.Skip()
def testauth(event): if (event.GetId() == KeyDist.EVT_KEYDIST_TESTAUTH): t = KeyDist.testAuthThread(event.keydist) t.setDaemon(True) t.start() logger.debug("received TESTAUTH event from thread %i %s, starting thread %i %s in response"%(event.threadid,event.threadname,t.ident,t.name)) event.keydist.threads.append(t) else: event.Skip()
def install_jar(self): if self.jar_file is None: self.build_module_jar() execution = Mvn.install_jar(self.base_path, self.jar_file, self.name, self.version) output = execution.stdout logger.debug('Command output: ' + str(output)) return
def loadkey(event): if (event.GetId() == KeyDist.EVT_KEYDIST_LOADKEY and not event.keydist.canceled()): t = KeyDist.loadKeyThread(event.keydist) t.setDaemon(True) t.start() logger.debug("received LOADKEY event from thread %i %s, starting thread %i %s in response"%(event.threadid,event.threadname,t.ident,t.name)) event.keydist.threads.append(t) else: event.Skip()
def OnInit(self): resetKeyDialog = ResetKeyDialog(None, wx.ID_ANY, 'Reset Key') resetKeyDialog.Center() if resetKeyDialog.ShowModal()==wx.ID_OK: logger.debug("Passphrase = " + resetKeyDialog.getPassphrase()) else: logger.debug("User canceled.") return False return True
def cancel(self, message=""): if (not self.canceled()): self._canceled.set() newevent = KeyDist.sshKeyDistEvent(KeyDist.EVT_KEYDIST_SHUTDOWN, self) newevent.arg = message logger.debug( 'sshKeyDist.cancel: setting canceled, sending EVT_KEYDIST_SHUTDOWN event.' ) wx.PostEvent(self.notifywindow.GetEventHandler(), newevent)
def OnInit(self): changeKeyPassphraseDialog = ChangeKeyPassphraseDialog(None, wx.ID_ANY, 'Change Key Passphrase', os.path.join(os.path.expanduser('~'), '.ssh', "MassiveLauncherKey")) changeKeyPassphraseDialog.Center() if changeKeyPassphraseDialog.ShowModal()==wx.ID_OK: logger.debug("New passphrase = " + changeKeyPassphraseDialog.getNewPassphrase()) else: logger.debug("User canceled.") return False return True
def getPubKey(self): pubKeyPath = self.getPrivateKeyFilePath() + ".pub" try: with open(pubKeyPath, 'r') as f: pubkey = f.read() return pubkey except: logger.debug("KeyModel.getPubKey: %s not found" % pubKeyPath) return "" return None
def getPubKey(self): pubKeyPath=self.getPrivateKeyFilePath()+".pub" try: with open(pubKeyPath,'r') as f: pubkey=f.read() return pubkey except: logger.debug("KeyModel.getPubKey: %s not found"%pubKeyPath) return "" return None
def OnInit(self): resetKeyDialog = ResetKeyDialog(None, wx.ID_ANY, 'Reset Key') resetKeyDialog.Center() if resetKeyDialog.ShowModal() == wx.ID_OK: logger.debug("Passphrase = " + resetKeyDialog.getPassphrase()) else: logger.debug("User canceled.") return False return True
def completeEvent(event): if (event.GetId() == KeyDist.EVT_KEYDIST_COMPLETE): if (event.keydist.canceled()): if (event.keydist.callback_fail != None): logger.debug("sshKeyDist.completeEvent: calling-back to indicate completion") if event.arg!=None: event.keydist.callback_fail(event.arg) else: event.keydist.callback_fail() event.keydist._completed.set()
def testauth(event): if (event.GetId() == KeyDist.EVT_KEYDIST_TESTAUTH): t = KeyDist.testAuthThread(event.keydist) t.setDaemon(True) t.start() logger.debug( "received TESTAUTH event from thread %i %s, starting thread %i %s in response" % (event.threadid, event.threadname, t.ident, t.name)) event.keydist.threads.append(t) else: event.Skip()
def deleteKey(self): success = self.launcherMainFrame.keyModel.deleteKey(ignoreFailureToConnectToAgent=True) #success = success and self.launcherMainFrame.keyModel.removeKeyFromAgent() if success: message = "Launcher key was successfully deleted!" logger.debug(message) else: message = "An error occured while attempting to delete the existing key." logger.debug(message) return success
def loadkey(event): if (event.GetId() == KeyDist.EVT_KEYDIST_LOADKEY and not event.keydist.canceled()): t = KeyDist.loadKeyThread(event.keydist) t.setDaemon(True) t.start() logger.debug( "received LOADKEY event from thread %i %s, starting thread %i %s in response" % (event.threadid, event.threadname, t.ident, t.name)) event.keydist.threads.append(t) else: event.Skip()
def run(self): logger.debug("genkeyThread: started") self.nextEvent=None def success(): self.nextEvent = KeyDist.sshKeyDistEvent(KeyDist.EVT_KEYDIST_LOADKEY,self.keydistObject) def failure(): self.keydistObject.cancel("Unable to generate a new key pair") self.keydistObject.keyModel.generateNewKey(self.keydistObject.password,success,failure,failure) self.keydistObject.keyCreated.set() if (not self.stopped() and self.nextEvent != None): logger.debug("genkeyThread: generating LOADKEY event from genkeyThread") wx.PostEvent(self.keydistObject.notifywindow.GetEventHandler(),self.nextEvent)
def shutdownEvent(event): if (event.GetId() == KeyDist.EVT_KEYDIST_SHUTDOWN): logger.debug("received EVT_KEYDIST_SHUTDOWN event") nextevent = KeyDist.sshKeyDistEvent(KeyDist.EVT_KEYDIST_COMPLETE,event.keydist) try: nextevent.arg=event.arg except: pass event.keydist.shutdownThread=threading.Thread(target=event.keydist.shutdownReal,args=[nextevent]) event.keydist.shutdownThread.start() else: event.Skip()
def deleteRemoteKey(self,host,username): if self.copiedID.isSet() and self.pubKey!=None: import tempfile fd=tempfile.NamedTemporaryFile(delete=True) path=fd.name fd.close() cmd='{sshBinary} -A -T -o IdentityFile={nonexistantpath} -o PasswordAuthentication=no -o PubkeyAuthentication=yes -o StrictHostKeyChecking=no -l {username} {host} "sed \'\\#{key}# D\' -i ~/.ssh/authorized_keys"' key=self.pubKey.split(' ')[1] command = cmd.format(sshBinary=self.sshpaths.sshBinary,username=username,host=host,key=key,nonexistantpath=path) logger.debug('KeyModel.deleteRemoteKey: running %s to delete remote key'%command) p = subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True,universal_newlines=True,startupinfo=self.startupinfo,creationflags=self.creationflags) (stdout,stderr) = p.communicate()
def run(self): import os import hashlib nres=0 while nres<self.nthreads: r=self.q.get() nres=nres+1 if r[1]!=None: filename=os.path.join(self.path,hashlib.md5(r[0]).hexdigest()) with open(filename,'w') as f: logger.debug("retrieved site %s in a background download"%r[0]) f.write(r[1])
def loadKey(self): km = self.keyModel self._loadKeySuccess = threading.Event() self._addKeyComplete = threading.Event() self._loadKeySuccess.clear() self._addKeyComplete.clear() if (self.password != None): password = self.password else: password = "" def incorrectCallback(): queue = Queue.Queue() if self.password != None: wx.CallAfter(self.GetKeyPassphrase, incorrect=True, queue=queue) else: wx.CallAfter(self.GetKeyPassphrase, incorrect=False, queue=queue) (canceled, self.password) = queue.get() if canceled: self._stopped.set() self.cancelMessage = "canceled while requesting the existing ssh key passphrase" self._exit.set() self._addKeyComplete.set() def loadedCallback(): self._loadKeySuccess.set() def failedToConnectToAgentCallback(): self.cancelMessage = "failed to connect to agent callback" self._exit.set() self._stopped.set() logger.debug( "sshKeyDist.loadKeyThread.run: KeyModel information temporary: %s path: %s exists: %s" % (km.isTemporaryKey(), km.getPrivateKeyFilePath(), km.privateKeyExists())) if not os.path.exists(self.keyModel.sshPathsObject.sshKeyPath): if not self._stopped.isSet(): self.createKey() while not self._loadKeySuccess.isSet() and not self._stopped.isSet( ) and not self._exit.isSet(): logger.debug('attempting to add key to the ssh agent') if (self.password != None): password = self.password else: password = "" km.addKeyToAgent(password, loadedCallback, incorrectCallback, None, failedToConnectToAgentCallback)
def CreateDatasetIfNecessary(folderModel): description = folderModel.GetFolder() myTardisUrl = folderModel.settingsModel.GetMyTardisUrl() myTardisDefaultUsername = folderModel.settingsModel.GetUsername() myTardisDefaultUserApiKey = folderModel.settingsModel.GetApiKey() url = myTardisUrl + "/api/v1/dataset/?format=json" + \ "&experiments__id=" + str(folderModel.GetExperiment().GetId()) url = url + "&description=" + urllib.quote(description) headers = {"Authorization": "ApiKey " + myTardisDefaultUsername + ":" + myTardisDefaultUserApiKey} response = requests.get(headers=headers, url=url) existingMatchingDatasets = response.json() numExistingMatchingDatasets = \ existingMatchingDatasets['meta']['total_count'] if numExistingMatchingDatasets == 1: logger.debug("Found existing dataset for folder " + description) elif numExistingMatchingDatasets > 1: logger.debug("WARNING: Found multiple datasets for folder " + description) if numExistingMatchingDatasets == 0: logger.debug("Creating dataset record for folder: " + description) description = folderModel.GetFolder() experimentUri = folderModel.GetExperiment().GetResourceUri() immutable = False datasetJson = { "description": description, "experiments": [experimentUri], "immutable": immutable} data = json.dumps(datasetJson) headers = {"Authorization": "ApiKey " + myTardisDefaultUsername + ":" + myTardisDefaultUserApiKey, "Content-Type": "application/json", "Accept": "application/json"} url = myTardisUrl + "/api/v1/dataset/" response = requests.post(headers=headers, url=url, data=data) if response.status_code >= 200 and response.status_code < 300: newDatasetJson = response.json() return DatasetModel(folderModel.settingsModel, newDatasetJson) else: logger.debug(url) logger.debug("response.status_code = " + str(response.status_code)) return None else: return DatasetModel(folderModel.settingsModel, existingMatchingDatasets['objects'][0])
def getInstances(self,keyname=None): # Get a list of VMs that match a) the image name b) the flavour c) the keypair try: self.instances=[] reservations = self.connection.get_all_reservations() for res in reservations: for instance in res.instances: if instance.image_id == self.imageid: if keyname !=None and keyname == instance.key_name: self.instances.append(instance) except Exception as e: logger.debug(traceback.format_exc()) logger.debug(e)