class FileLockTest(unittest.TestCase): def setUp(self): self.file_name = "__lock__" self.lock = FileLock(self.file_name, timeout=1) self.lock.acquire() def test_raise(self): with self.assertRaises(FileLockException): new_lock = FileLock(self.file_name, timeout=1) new_lock.acquire() def tearDown(self): self.lock.release()
class FileLockTest(unittest.TestCase): def setUp(self): self.file_name = "__lock__" self.lock = FileLock(self.file_name, timeout=1) self.lock.acquire() def test_raise(self): with self.assertRaises(FileLockException): new_lock = FileLock(self.file_name, timeout=1) new_lock.acquire() def tearDown(self): self.lock.release()
def save_lastnode_id(): """Save the id of the last node created.""" init_counter() with FileLock(_COUNTER_FILE): with AtomicFile(_COUNTER_FILE, mode="w") as fh: fh.write("%d\n" % _COUNTER)
def gbrv_rundb(options): """Build flow and run it.""" dbpath = os.path.abspath(options.path) retcode = 0 # Get list of jobs to execute. with FileLock(dbpath): outdb = GbrvOutdb.from_file(dbpath) jobs = outdb.find_jobs_torun(options.max_njobs) if not jobs: cprint("Nothing to do, returning 0", "yellow") return 0 gbrv_factory = GbrvCompoundsFactory(xc=outdb["xc_name"]) # Build workdir. s = "-".join(job.formula for job in jobs) m = hashlib.md5() m.update(s) workdir = os.path.join( os.getcwd(), "GBRV_OUTDB_" + jobs[0].formula + "_" + jobs[-1].formula + "_" + m.hexdigest()) #workdir = os.path.join(os.getcwd(), "GBRV_OUTDB_" + s) flow = GbrvCompoundsFlow(workdir=workdir) for job in jobs: #for accuracy in ("low", "normal", "high"): #for accuracy in ("high",): for accuracy in ("normal", "high"): ecut = max(p.hint_for_accuracy(accuracy).ecut for p in job.pseudos) pawecutdg = max( p.hint_for_accuracy(accuracy).pawecutdg for p in job.pseudos) if ecut <= 0.0: raise RuntimeError("Pseudos do not have hints") # Increase by 10 since many pseudos only have ppgen_hints #ecut += 10 work = gbrv_factory.relax_and_eos_work(accuracy, job.pseudos, job.formula, job.struct_type, ecut=ecut, pawecutdg=pawecutdg) # Attach the database to the work to trigger the storage of the results. flow.register_work(work.set_outdb(dbpath)) print("Working in:", flow.workdir) flow.build_and_pickle_dump() #abivalidate=options.dry_run) if options.dry_run: return 0 # Run the flow with the scheduler (enable smart_io) flow.use_smartio() retcode += flow.make_scheduler().start() return retcode
def add_entry_to_dojoreport(self, entry, overwrite_data=False, pop_trial=False): """ Write/update the DOJO_REPORT section of the pseudopotential. Important paramenters such as the name of the dojo_trial and the energy cutoff are provided by the sub-class. Client code is responsible for preparing the dictionary with the data. Args: entry: Dictionary with results. overwrite_data: If False, the routine raises an exception if this entry is already filled. pop_trial: True if the trial should be removed before adding the new entry. """ root, ext = os.path.splitext(self.dojo_pseudo.filepath) djrepo = root + ".djrepo" self.history.info("Writing dojreport data to %s" % djrepo) # Update file content with Filelock. with FileLock(djrepo): # Read report from file. file_report = DojoReport.from_file(djrepo) # Create new entry if not already there dojo_trial = self.dojo_trial if pop_trial: file_report.pop(dojo_trial, None) if dojo_trial not in file_report: file_report[dojo_trial] = {} # Convert float to string with 1 decimal digit. dojo_ecut = "%.1f" % self.ecut # Check that we are not going to overwrite data. if dojo_ecut in file_report[dojo_trial]: if not overwrite_data: raise RuntimeError( "dojo_ecut %s already exists in %s. Cannot overwrite data" % (dojo_ecut, dojo_trial)) else: file_report[dojo_trial].pop(dojo_ecut) # Update file_report by adding the new entry and write new file file_report[dojo_trial][dojo_ecut] = entry # Write new dojo report and update the pseudo attribute file_report.json_write() self._pseudo.dojo_report = file_report
def insert_results(cls, filepath, struct_type, formula, accuracy, pseudos, results): """ Update the entry in the database. """ with FileLock(filepath): outdb = cls.from_file(filepath) old_dict = outdb[struct_type][formula] if not isinstance(old_dict, dict): old_dict = {} old_dict[accuracy] = results outdb[struct_type][formula] = old_dict with AtomicFile(filepath, mode="wt") as fh: json.dump(outdb, fh, indent=-1, sort_keys=True) #, cls=MontyEncoder)
def write_pid_file(self): """ This function checks if we are already running the AbiPy |Flow| with a :class:`PyFlowScheduler`. Raises: Flow.Error if the pid file of the scheduler exists. """ if os.path.exists(self.pid_path): raise self.Error("""\n\ pid_path %s already exists. There are two possibilities: 1) There's an another instance of PyFlowScheduler running 2) The previous scheduler didn't exit in a clean way To solve case 1: Kill the previous scheduler (use 'kill pid' where pid is the number reported in the file) Then you can restart the new scheduler. To solve case 2: Remove the pid_path and restart the scheduler. Exiting""" % self.pid_path) # Make dir and file if not present. if not os.path.exists(os.path.dirname(self.pid_path)): os.makedirs(os.path.dirname(self.pid_path)) import json d = dict( pid=os.getpid(), host=self.host, port=self.port, ) #d["flows_db"] = dict( #) with FileLock(self.pid_path): with open(self.pid_path, "wt") as fh: json.dump(d, fh)
def check_and_write_pid_file(self): """ This function checks if we already have a running instance of :class:`MongoFlowScheduler`. Raises: RuntimeError if the pid file of the scheduler exists. """ if os.path.exists(self.pid_path): raise RuntimeError("""\n\ pid_path %s already exists. There are two possibilities: 1) There's an another instance of MongoFlowScheduler running 2) The previous scheduler didn't exit in a clean way To solve case 1: Kill the previous scheduler (use 'kill pid' where pid is the number reported in the file) Then you can restart the new scheduler. To solve case 2: Remove the pid_path and restart the scheduler. Exiting""" % self.pid_path) # Make dir and file if not present. if not os.path.exists(os.path.dirname(self.pid_path)): os.makedirs(os.path.dirname(self.pid_path)) d = dict(pid=os.getpid(), #host=self.host, #port=self.port, #"db_name"=self.db_name ) with FileLock(self.pid_path): with open(self.pid_path, "wt") as fh: json.dump(d, fh)
def test_raise(self): with self.assertRaises(FileLockException): new_lock = FileLock(self.file_name, timeout=1) new_lock.acquire()
def setUp(self): self.file_name = "__lock__" self.lock = FileLock(self.file_name, timeout=1) self.lock.acquire()
def on_all_ok(self): """ Results are written to the dojoreport. """ def vol2a(vol): """Function to compute cubic a0 from primitive v0 (depends on struct_type)""" return (4 * vol) ** (1/3.) entries = {} for task in self: ecut = task.input["ecut"] #final_structure = task.get_final_structure() with task.open_hist() as hist: final_structure = hist.final_structure initial_energy = hist.etotals[0] # Convert float to string with 1 decimal digit. dojo_ecut = "%.1f" % ecut entries[dojo_ecut] = { "relaxed_a": vol2a(final_structure.volume), "initial_energy_ev_per_atom": float(initial_energy) / len(final_structure), } #print(entries) # Convert to JSON and add results to the dojo report. #entry = dict(ecut=self.ecut, pawecutdg=self.dojo_pawecutdg, kppa=self.dojo_kppa) #self.add_entry_to_dojoreport(entry) #return results djrepo = self.djrepo_path # Update file content with Filelock. with FileLock(djrepo): # Read report from file. file_report = DojoReport.from_file(djrepo) # Create new entry if not already there dojo_trial = self.dojo_trial #if pop_trial: # file_report.pop(dojo_trial, None) if dojo_trial not in file_report: file_report[dojo_trial] = {} # Convert float to string with 1 decimal digit. #dojo_ecut = "%.1f" % self.ecut # Check that we are not going to overwrite data. #if dojo_ecut in file_report[dojo_trial]: # if not overwrite_data: # raise RuntimeError("dojo_ecut %s already exists in %s. Cannot overwrite data" % # (dojo_ecut, dojo_trial)) # else: # file_report[dojo_trial].pop(dojo_ecut) # Update file_report by adding the new entry and write new file for dojo_ecut, entry in entries.items(): file_report[dojo_trial][dojo_ecut] = entry # Write new dojo report and update the pseudo attribute file_report.json_write() self._pseudo.dojo_report = file_report return dict(returncode=0, message="Lattice paramenters computed and stored in djrepo file")
def test_raise(self): with self.assertRaises(FileLockException): new_lock = FileLock(self.file_name, timeout=1) new_lock.acquire()
def setUp(self): self.file_name = "__lock__" self.lock = FileLock(self.file_name, timeout=1) self.lock.acquire()