Ejemplo n.º 1
0
    def makeup(self):
        if self.current_project_def == None:
            tkinter_messagebox.showwarning('', 'No project selected.')
            return
        if self.current_stage_def == None:
            tkinter_messagebox.showwarning('', 'No stage selected.')
            return

        top = self.winfo_toplevel()
        old_cursor = top['cursor']
        try:
            top['cursor'] = 'watch'
            top.update_idletasks()
            project.dosubmit(self.current_project_def,
                             self.current_stage_def,
                             makeup=True,
                             recur=self.current_stage_def.recur)
            top['cursor'] = old_cursor
        except:
            top['cursor'] = old_cursor
            e = sys.exc_info()
            traceback.print_tb(e[2])
            tkinter_messagebox.showerror('', e[1])
        BatchStatus.update_jobs()
        self.project_view.update_status()
Ejemplo n.º 2
0
 def update_jobs(self):
     top = self.winfo_toplevel()
     old_cursor = top['cursor']
     try:
         top['cursor'] = 'watch'
         top.update_idletasks()
         BatchStatus.update_jobs()
         top['cursor'] = old_cursor
     except:
         top['cursor'] = old_cursor
         e = sys.exc_info()
         traceback.print_tb(e[2])
         tkMessageBox.showerror('', e[1])
     self.update_status()
Ejemplo n.º 3
0
    def kill_jobs(self):
        if self.current_project_def == None:
            tkinter_messagebox.showwarning('', 'No project selected.')
            return
        if self.current_stage_def == None:
            tkinter_messagebox.showwarning('', 'No stage selected.')
            return

        top = self.winfo_toplevel()
        old_cursor = top['cursor']
        try:
            top['cursor'] = 'watch'
            top.update_idletasks()
            BatchStatus.update_jobs()
            jobs = BatchStatus.get_jobs()
            top['cursor'] = old_cursor
        except:
            top['cursor'] = old_cursor
            e = sys.exc_info()
            traceback.print_tb(e[2])
            tkinter_messagebox.showerror('', e[1])

        # Figure out which clusters to kill.

        cluster_ids = set()
        for job in jobs:
            words = job.split()
            if len(words) >= 2:
                jobid = words[0]
                script = words[-1]
                workscript = '%s-%s-%s.sh' % (
                    self.current_stage_def.name, self.current_project_def.name,
                    self.current_project_def.release_tag)
                if script.find(workscript) == 0:
                    cp_server = jobid.split('@')
                    if len(cp_server) == 2:
                        clusproc = cp_server[0]
                        server = cp_server[1]
                        cp = clusproc.split('.')
                        if len(cp) == 2:
                            cluster = cp[0]
                            process = cp[1]
                            cluster_id = '%s@%s' % (cluster, server)
                            if not cluster_id in cluster_ids:
                                cluster_ids.add(cluster_id)

        # Actually issue kill commands.

        for cluster_id in cluster_ids:
            print('Kill cluster id %s' % cluster_id)
            command = ['jobsub_rm']
            if self.current_project_def.server != '-' and self.current_project_def.server != '':
                command.append('--jobsub-server=%s' %
                               self.current_project_def.server)
            command.append('--jobid=%s' % cluster_id)
            command.append('--role=%s' % project_utilities.get_role())
            jobinfo = subprocess.Popen(command,
                                       stdout=subprocess.PIPE,
                                       stderr=subprocess.PIPE)
            jobout, joberr = jobinfo.communicate()
            jobout = convert_str(jobout)
            joberr = convert_str(joberr)
            rc = jobinfo.poll()
            if rc != 0:
                raise JobsubError(command, rc, jobout, joberr)

        self.update_jobs()
Ejemplo n.º 4
0
    def update_status(self):

        top = self.winfo_toplevel()
        old_cursor = top['cursor']
        try:
            top['cursor'] = 'watch'
            top.update_idletasks()
            ps = ProjectStatus(self.project_defs)
            bs = BatchStatus(self.project_defs)
            top['cursor'] = old_cursor
        except:
            top['cursor'] = old_cursor
            e = sys.exc_info()
            traceback.print_tb(e[2])
            tkMessageBox.showerror('', e[1])

        # Update label widgets.

        for key in self.stage_name_labels.keys():
            self.stage_name_labels[key].grid_forget()
        for key in self.exists_labels.keys():
            self.exists_labels[key].grid_forget()
        for key in self.nfile_labels.keys():
            self.nfile_labels[key].grid_forget()
        for key in self.nev_labels.keys():
            self.nev_labels[key].grid_forget()
        for key in self.nana_labels.keys():
            self.nana_labels[key].grid_forget()
        for key in self.nerror_labels.keys():
            self.nerror_labels[key].grid_forget()
        for key in self.nmiss_labels.keys():
            self.nmiss_labels[key].grid_forget()
        for key in self.nidle_labels.keys():
            self.nidle_labels[key].grid_forget()
        for key in self.nrunning_labels.keys():
            self.nrunning_labels[key].grid_forget()
        for key in self.nheld_labels.keys():
            self.nheld_labels[key].grid_forget()
        for key in self.nother_labels.keys():
            self.nother_labels[key].grid_forget()

        row = 1
        for project_def in self.project_defs:
            for stage in project_def.stages:
                row = row + 1
                ss = ps.get_stage_status(stage.name)
                bss = bs.get_stage_status(stage.name)

                if not self.stage_name_labels.has_key(stage.name):
                    self.stage_name_labels[stage.name] = tk.Label(
                        self,
                        bg='powderblue',
                        relief=tk.RIDGE,
                        padx=10,
                        pady=5,
                        font=tkFont.Font(size=12))
                self.stage_name_labels[stage.name]['text'] = stage.name
                self.stage_name_labels[stage.name].bind(
                    '<Button-1>', self.click_stage)
                self.stage_name_labels[stage.name].grid(row=row,
                                                        column=0,
                                                        sticky=tk.N + tk.E +
                                                        tk.W + tk.S)
                self.rowconfigure(row, weight=1)

                if not self.exists_labels.has_key(stage.name):
                    self.exists_labels[stage.name] = tk.Label(
                        self,
                        bg='aliceblue',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                if ss.exists:
                    self.exists_labels[stage.name]['text'] = 'Yes'
                    self.exists_labels[stage.name]['fg'] = 'black'
                else:
                    self.exists_labels[stage.name]['text'] = 'No'
                    self.exists_labels[stage.name]['fg'] = 'red'
                self.exists_labels[stage.name].grid(row=row,
                                                    column=kEXISTS,
                                                    sticky=tk.N + tk.E + tk.W +
                                                    tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nfile_labels.has_key(stage.name):
                    self.nfile_labels[stage.name] = tk.Label(
                        self,
                        bg='aliceblue',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nfile_labels[stage.name]['text'] = str(ss.nfile)
                self.nfile_labels[stage.name].grid(row=row,
                                                   column=kNFILE,
                                                   sticky=tk.N + tk.E + tk.W +
                                                   tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nev_labels.has_key(stage.name):
                    self.nev_labels[stage.name] = tk.Label(
                        self,
                        bg='aliceblue',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nev_labels[stage.name]['text'] = str(ss.nev)
                self.nev_labels[stage.name].grid(row=row,
                                                 column=kNEV,
                                                 sticky=tk.N + tk.E + tk.W +
                                                 tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nana_labels.has_key(stage.name):
                    self.nana_labels[stage.name] = tk.Label(
                        self,
                        bg='aliceblue',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nana_labels[stage.name]['text'] = str(ss.nana)
                self.nana_labels[stage.name].grid(row=row,
                                                  column=kNANA,
                                                  sticky=tk.N + tk.E + tk.W +
                                                  tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nerror_labels.has_key(stage.name):
                    self.nerror_labels[stage.name] = tk.Label(
                        self,
                        bg='aliceblue',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nerror_labels[stage.name]['text'] = str(ss.nerror)
                if ss.nerror == 0:
                    self.nerror_labels[stage.name]['fg'] = 'black'
                else:
                    self.nerror_labels[stage.name]['fg'] = 'red'
                self.nerror_labels[stage.name].grid(row=row,
                                                    column=kNERROR,
                                                    sticky=tk.N + tk.E + tk.W +
                                                    tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nmiss_labels.has_key(stage.name):
                    self.nmiss_labels[stage.name] = tk.Label(
                        self,
                        bg='aliceblue',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nmiss_labels[stage.name]['text'] = str(ss.nmiss)
                if ss.nmiss == 0:
                    self.nmiss_labels[stage.name]['fg'] = 'black'
                else:
                    self.nmiss_labels[stage.name]['fg'] = 'red'
                self.nmiss_labels[stage.name].grid(row=row,
                                                   column=kNMISS,
                                                   sticky=tk.N + tk.E + tk.W +
                                                   tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nidle_labels.has_key(stage.name):
                    self.nidle_labels[stage.name] = tk.Label(
                        self,
                        bg='lightcyan',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nidle_labels[stage.name]['text'] = bss[0]
                self.nidle_labels[stage.name].grid(row=row,
                                                   column=kIDLE,
                                                   sticky=tk.N + tk.E + tk.W +
                                                   tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nrunning_labels.has_key(stage.name):
                    self.nrunning_labels[stage.name] = tk.Label(
                        self,
                        bg='lightcyan',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nrunning_labels[stage.name]['text'] = bss[1]
                self.nrunning_labels[stage.name].grid(row=row,
                                                      column=kRUNNING,
                                                      sticky=tk.N + tk.E +
                                                      tk.W + tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nheld_labels.has_key(stage.name):
                    self.nheld_labels[stage.name] = tk.Label(
                        self,
                        bg='lightcyan',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nheld_labels[stage.name]['text'] = bss[2]
                self.nheld_labels[stage.name].grid(row=row,
                                                   column=kHELD,
                                                   sticky=tk.N + tk.E + tk.W +
                                                   tk.S)
                self.rowconfigure(row, weight=1)

                if not self.nother_labels.has_key(stage.name):
                    self.nother_labels[stage.name] = tk.Label(
                        self,
                        bg='lightcyan',
                        relief=tk.RIDGE,
                        font=tkFont.Font(size=12))
                self.nother_labels[stage.name]['text'] = bss[3]
                self.nother_labels[stage.name].grid(row=row,
                                                    column=kOTHER,
                                                    sticky=tk.N + tk.E + tk.W +
                                                    tk.S)
                self.rowconfigure(row, weight=1)