def test_new_singleton_lock() -> None:
assert isinstance(new_singleton_lock({"lock_file": None}),
NullSingletonLock)
lock_file = tempfile.mktemp()
singleton_lock = new_singleton_lock({"lock_file": lock_file})
assert isinstance(singleton_lock, SingletonFileLock)
assert os.path.exists(lock_file)
expected = str(os.getpid())
with open(lock_file) as fr:
assert expected == fr.read()
singleton_lock.unlock()
os.remove(lock_file)
def __init__(
self,
node_mgr: NodeManager,
node_history: NodeHistory = NullNodeHistory(),
node_queue: Optional[NodeQueue] = None,
singleton_lock: Optional[SingletonLock] = None,
) -> None:
assert isinstance(node_mgr, NodeManager)
self.node_mgr = node_mgr
self.node_history = node_history
if node_queue is None:
node_queue = NodeQueue()
self.__scheduler_nodes_queue: NodeQueue = node_queue
for node in self.node_mgr.get_non_failed_nodes():
self.__scheduler_nodes_queue.push(node)
self.__set_buffer_delayed_invocations: List[Tuple[Any, ...]] = []
self.node_history.decorate(list(self.__scheduler_nodes_queue))
if not singleton_lock:
singleton_lock = new_singleton_lock({})
self.__singleton_lock = singleton_lock
logging.debug(
"Calculating demand using the following pre-existing nodes: %s",
[n.name for n in self.__scheduler_nodes_queue],
)
def new_demand_calculator(
config: Union[str, dict],
existing_nodes: Optional[List[SchedulerNode]] = None,
node_mgr: Optional[NodeManager] = None,
node_history: Optional[NodeHistory] = None,
disable_default_resources: bool = False,
node_queue: Optional[NodeQueue] = None,
singleton_lock: Optional[SingletonLock] = NullSingletonLock(),
) -> DemandCalculator:
config_dict = load_config(config)
existing_nodes = existing_nodes or []
if node_mgr is None:
node_mgr = new_node_manager(
config_dict,
disable_default_resources=disable_default_resources,
)
else:
logging.initialize_logging(config_dict)
if not disable_default_resources:
node_mgr.set_system_default_resources()
node_history = node_history or SQLiteNodeHistory()
if singleton_lock is None:
singleton_lock = new_singleton_lock(config_dict)
dc = DemandCalculator(node_mgr, node_history, node_queue, singleton_lock)
dc.update_scheduler_nodes(existing_nodes)
return dc