def write_cluster(cluster):
if not os.path.isdir(globals.CONFIG_DIR):
try:
os.mkdir(globals.CONFIG_DIR)
except:
fail("failed to create directory: {}".format(globals.CONFIG_DIR))
# initialize locking - NOTE: make sure to release_local() prior to all exceptions/returns)
lock = Lock(globals.CLUSTER_FILE_LOCK)
# get lock (for concurrent datamodel access across)
lock.get_lock()
current_clusters = get_clusters(None)
if len(current_clusters) == 0:
current_clusters.append(cluster)
with open(globals.CLUSTER_FILE, 'w') as outfile:
json.dump(current_clusters, outfile)
else:
update_clusters = []
flag_found = False
for c in current_clusters:
if c['name'] == cluster['name']:
update_clusters.append(cluster)
flag_found = True
else:
update_clusters.append(c)
if not flag_found:
update_clusters.append(cluster)
with open(globals.CLUSTER_FILE, 'w') as outfile:
json.dump(update_clusters, outfile)
# release lock
lock.release_lock()
def _kickGC(self):
# don't bother if an instance already running (this is just an
# optimization to reduce the overhead of forking a new process if we
# don't have to, but the process will check the lock anyways)
lockRunning = Lock(cleanup.LOCK_TYPE_RUNNING, self.uuid)
if not lockRunning.acquireNoblock():
if cleanup.should_preempt(self.session, self.uuid):
util.SMlog(
"Aborting currently-running coalesce of garbage VDI")
try:
if not cleanup.abort(self.uuid, soft=True):
util.SMlog("The GC has already been scheduled to "
"re-start")
except util.CommandException as e:
if e.code != errno.ETIMEDOUT:
raise
util.SMlog('failed to abort the GC')
finally:
return
else:
util.SMlog("A GC instance already running, not kicking")
return
else:
lockRunning.release()
util.SMlog("Kicking GC")
cleanup.gc(self.session, self.uuid, True)
def main(package_id, dryrun):
logger.info(f'package_id={package_id}')
lock = Lock('/tmp/poll_manager.lock')
if lock.locked:
logger.error('Lock file {} exists, exiting...'.format(lock.lock_file))
return 1
else:
lock.acquire()
logger.warning('Lock file {} acquired'.format(lock.lock_file))
try:
scope, identifier, revision = package_id.split('.')
connection = connect()
event = get_package_info(connection, scope, identifier, revision)
if event:
qm = QueueManager()
msg = f"Enqueue: {event.package} - {event.datetime} - " + \
f"{event.owner} - {event.doi} - {event.method}"
logger.warning(msg)
if not dryrun:
qm.enqueue(event=event)
else:
msg = f"DRYRUN: qm.enqueue(event=event)"
logger.info(msg)
except AdapterRequestFailureException as e:
logger.error(e)
lock.release()
logger.warning('Lock file {} released'.format(lock.lock_file))
return 0
def write_auth_profile(auth):
"""Write authorization file to disk"""
# initialize locking - NOTE: make sure to release_local() prior to all exceptions/returns)
lock = Lock(globals.AUTH_PROFILE_FILE_LOCK)
# get lock (for concurrent datamodel access across)
lock.get_lock()
current_profile = get_auth_profiles()
if len(current_profile) == 0:
current_profile.append(auth)
with open(globals.AUTH_PROFILE_FILE, 'w') as outfile:
json.dump(current_profile, outfile)
else:
update_profile = []
flag_found = False
for profile in current_profile:
if profile['auth_name'] == auth['auth_name']:
update_profile.append(auth)
flag_found = True
else:
update_profile.append(profile)
if not flag_found:
update_profile.append(auth)
with open(globals.AUTH_PROFILE_FILE, 'w') as outfile:
json.dump(update_profile, outfile)
# release lock
lock.release_lock()
def daemonize(args, callback):
with DaemonContext():
create_process = False
lock = Lock(LOCKFILE, os.getpid(), args.name, args.sea_ep[0],
args.sea_ep[1], args.port)
if lock.is_locked():
lock_pid = lock.get_pid()
if not lock.is_same_file(args.name, args.sea_ep[0],
args.sea_ep[1]) \
or not is_process_running(lock_pid):
try:
os.kill(lock_pid, signal.SIGQUIT)
except OSError:
pass
except TypeError:
pass
lock.break_lock()
create_process = True
else:
create_process = True
if create_process:
lock.acquire()
callback(args.name, season=args.sea_ep[0], episode=args.sea_ep[1],
serve=True, port=args.port)
lock.release()
def main():
lock = Lock()
lock.set_server_url("http://192.168.0.17:5000/validate-pin")
lock.set_wifi_conf("GOT", "MASTER2D")
lock.connect_to_wifi()
lock.set_rc522_uid_addr(0x08)
lock.run()
def lock_file(self):
'''Handle the mc1.Lock object. Public objects:
lock = mfc1.Lock
lockstate = Status of the lock file.
'' = No status.
'written' = Lock file is written
'deleted' = Lock file is deleted
'exit' = Program exit
'''
userid = wx.GetUserId()
wxpath = wx.StandardPaths.Get()
userdir = wxpath.GetDocumentsDir()
self.lock = Lock(path=userdir, userid=userid)
self.lockstate = ''
if self.lock.one_instance('mindfulclock1'):
# One instance.
self.lock.write_lock()
self.lockstate = 'written'
else:
# More than one instance.
if self.start_question():
# Start the clock.
self.lock.write_lock()
self.lockstate = 'written'
else:
# Exit the program.
self.lockstate = 'exit'
def main():
lock = Lock('/tmp/poll_manager.lock')
if lock.locked:
logger.error('Lock file {} exists, exiting...'.format(lock.lock_file))
return 1
else:
lock.acquire()
logger.warn('Lock file {} acquired'.format(lock.lock_file))
url = properties.PASTA_BASE_URL + '/changes/eml?'
qm = QueueManager()
fromDate = None
dt = qm.get_last_datetime()
if dt is not None:
fromDate = datetime.strftime(dt, '%Y-%m-%dT%H:%M:%S.%f')
if fromDate is None:
bootstrap(url=url)
else:
parse(url=url, fromDate=fromDate)
lock.release()
logger.warn('Lock file {} released'.format(lock.lock_file))
return 0
def load(self, sr_uuid):
self.ops_exclusive = FileSR.OPS_EXCLUSIVE
self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid)
self.sr_vditype = SR.DEFAULT_TAP
self.driver_config = DRIVER_CONFIG
if not self.dconf.has_key('server'):
raise xs_errors.XenError('ConfigServerMissing')
self.remoteserver = self.dconf['server']
self.nosubdir = False
if self.sr_ref and self.session is not None:
self.sm_config = self.session.xenapi.SR.get_sm_config(self.sr_ref)
else:
self.sm_config = self.srcmd.params.get('sr_sm_config') or {}
self.nosubdir = self.sm_config.get('nosubdir') == "true"
if self.dconf.has_key('serverpath'):
self.remotepath = os.path.join(self.dconf['serverpath'],
not self.nosubdir and sr_uuid
or "").encode('utf-8')
self.path = os.path.join(SR.MOUNT_BASE, sr_uuid)
# Handle optional dconf attributes
self.transport = DEFAULT_TRANSPORT
if self.dconf.has_key('useUDP') and self.dconf['useUDP'] == 'true':
self.transport = "udp"
self.nfsversion = nfs.validate_nfsversion(self.dconf.get('nfsversion'))
if 'options' in self.dconf:
self.options = self.dconf['options']
else:
self.options = ''
def detachThin(session, lvmCache, srUuid, vdiUuid):
"""Shrink the VDI to the minimal size if no one is using it"""
lvName = LV_PREFIX[vhdutil.VDI_TYPE_VHD] + vdiUuid
path = os.path.join(VG_LOCATION, VG_PREFIX + srUuid, lvName)
lock = Lock(vhdutil.LOCK_TYPE_SR, srUuid)
_tryAcquire(lock)
vdiRef = session.xenapi.VDI.get_by_uuid(vdiUuid)
vbds = session.xenapi.VBD.get_all_records_where( \
"field \"VDI\" = \"%s\"" % vdiRef)
numPlugged = 0
for vbdRec in vbds.values():
if vbdRec["currently_attached"]:
numPlugged += 1
if numPlugged > 1:
raise util.SMException("%s still in use by %d others" % \
(vdiUuid, numPlugged - 1))
lvmCache.activate(NS_PREFIX_LVM + srUuid, vdiUuid, lvName, False)
try:
newSize = calcSizeLV(vhdutil.getSizePhys(path))
deflate(lvmCache, lvName, newSize)
finally:
lvmCache.deactivate(NS_PREFIX_LVM + srUuid, vdiUuid, lvName, False)
lock.release()
def test_release_free_resource():
"""
TestCase Senario:
trying to send a release request for a free resource which is not allowed
so the wrong message response is expected.
"""
#targeted resource and client_address
resource_name = 'resourceX'
client_address = '127.0.0.1'
client_lock = Lock(resource_name, client_address)
status = client_lock.check_status()
#initiate socket s and send the release request for resourceX
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall('release resourceX')
data = s.recv(1024)
#expecting error message as a response
assert data == 'resource is already free.'
# the status of the resource was free and still free
assert client_lock.check_status() == 'free'
#close the socket client
s.close()
def OnAddedToSpace(self, ballpark, dbspacecomponent):
persister = Persister(ballpark.solarsystemID, self.itemID,
dbspacecomponent)
bountyEscrowBonus, bounties = persister.GetStateForSystem()
iskRegistry = IskRegistry(bounties)
iskMover = IskMover(ballpark.broker.account)
itemCreator = GetItemCreator(ballpark.inventory2, ballpark,
self.attributes.tagTypeIDs.keys())
escrow = Escrow(self, ballpark, iskRegistry, iskMover, itemCreator,
persister)
item = ballpark.inventory2.GetItem(self.itemID)
eventLogger = EventLogger(ballpark.broker.eventLog,
ballpark.solarsystemID, item.ownerID,
self.itemID)
notifier = Notifier(ballpark.broker.notificationMgr)
self.rangeNotifier = RangeNotifier(ballpark.solarsystemID, ballpark,
ballpark.broker.machoNet,
self.GetWallclockTime)
ballpark.proximityRegistry.RegisterForProximity(
self.itemID, 30000, self.rangeNotifier.PlayerInRange)
lock = Lock(self)
self.warpScrambler = WarpScrambler(self.itemID, lock, ballpark.dogmaLM)
self.Initialize(ballpark, escrow, lock, persister, eventLogger,
notifier)
self.escrow.SetBonus(bountyEscrowBonus)
def get_agencies(cls, truncate=True):
"""
Get a list of agencies
"""
with Lock("agencies"):
request_params = {
'command': 'agencyList',
}
agencies_xml, api_call = cls.request(request_params, 'agency')
if not agencies_xml:
return []
db.session.begin()
if truncate:
db.session.query(Agency).delete()
agencies = []
for agency in agencies_xml:
region = Region.get_or_create(db.session,
title=agency.get('regionTitle'))
a = Agency.get_or_create(db.session,
tag=agency.get('tag'),
title=agency.get('title'),
short_title=agency.get('shortTitle'),
region=region,
api_call=api_call)
agencies.append(a)
db.session.commit()
return agencies
def daemonize(args, callback):
with DaemonContext():
from touchandgo.logger import log_set_up
log_set_up(True)
log = logging.getLogger('touchandgo.daemon')
log.info("running daemon")
create_process = False
lock = Lock(LOCKFILE, os.getpid(), args.name, args.sea_ep[0],
args.sea_ep[1], args.port)
if lock.is_locked():
log.debug("lock active")
lock_pid = lock.get_pid()
if not lock.is_same_file(args.name, args.sea_ep[0],
args.sea_ep[1]) \
or not is_process_running(lock_pid):
try:
log.debug("killing process %s" % lock_pid)
os.kill(lock_pid, signal.SIGQUIT)
except OSError:
pass
except TypeError:
pass
lock.break_lock()
create_process = True
else:
create_process = True
if create_process:
log.debug("creating proccess")
lock.acquire()
callback()
lock.release()
else:
log.debug("same daemon process")
def testStateUnlocked(self):
testState2: bool = False
lock2 = Lock(state=testState2)
lock2.set_needKey = testState2
self.assertEqual(lock2._state,
False) #It isn't being called here either
self.assertEqual(lock2._needKey, False)
def load(self, sr_uuid):
self.ops_exclusive = OPS_EXCLUSIVE
self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid)
self.sr_vditype = vhdutil.VDI_TYPE_VHD
if not self.dconf.has_key('location') or not self.dconf['location']:
raise xs_errors.XenError('ConfigLocationMissing')
self.path = self.dconf['location']
self.attached = False
def __init__(self, name, is_master_callback, lost_master_callback):
self.lock = Lock(name,
lock_callback=self._lock,
lock_lost_callback=self._lost_lock)
self.master_callback = is_master_callback
self.lost_master_callback = lost_master_callback
self.running = False
self.condition = threading.Condition()
def checkLocked(obj, ns):
"""Lock-protected access"""
lock = Lock(obj, ns)
lock.acquire()
try:
return RefCounter.check(obj, ns)
finally:
lock.release()
def load(self, sr_uuid):
self.ops_exclusive = FileSR.OPS_EXCLUSIVE
self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid)
self.sr_vditype = SR.DEFAULT_TAP
self.path = os.path.join(SR.MOUNT_BASE, sr_uuid)
self.vgname = EXT_PREFIX + sr_uuid
self.remotepath = os.path.join("/dev", self.vgname, sr_uuid)
self.attached = self._checkmount()
self.driver_config = DRIVER_CONFIG
def setReadonly(self, lvName, readonly):
path = self._getPath(lvName)
if self.lvs[lvName].readonly != readonly:
uuids = util.findall_uuid(path)
ns = lvhdutil.NS_PREFIX_LVM + uuids[0]
lock = Lock(uuids[1], ns)
lock.acquire()
lvutil.setReadonly(path, readonly)
lock.release()
self.lvs[lvName].readonly = readonly
def acquire_lock(self, sid, lock_type, tran_id):
# Find the corresponding rid given the sid.
if self.index[self.key].contains_key(sid):
rid = self.index[self.key].locate(sid)[0]
else:
print("Acquire_Lock_Error: Provided SID is not valid!!!!!!!")
return False
self.lock.acquire()
# If the record already has a lock list. Check if it contains a exclusive
# lock and check if the exclusive lock belongs to the same transaction.
if len(self.page_directory[rid]) == 3:
# Shallow copy the lock list
lock_list = self.page_directory[rid][2]
# The lock list might be empty when we release all locks.
# Doesn't mean there were no lock appended before.
if lock_list.head is not None:
if lock_list.has_exlock():
print("A:LKJF:LKAJFA")
if not lock_list.same_exlock_tranID(tran_id):
print(
"Adding lock after an exclusive lock. Lock appending failed and abort the transaction."
)
self.lock.release()
return False
else:
if not lock_list.has_lock(tran_id, lock_type):
new_lock = Lock(lock_type, tran_id)
lock_list.append_list(new_lock)
else:
new_lock = Lock(lock_type, tran_id)
lock_list.append_list(new_lock)
# If the record doesn't have a lock list, make a lock list and append the lock.
else:
self.page_directory[rid].append(Lock_List())
new_lock = Lock(lock_type, tran_id)
self.page_directory[rid][2].append_list(new_lock)
self.lock.release()
return True
def test_lock_resourceX_then_close_connection():
"""
TestCase Senario:
the client try to lock the resourceX then this client close the connection.
when the connection between the client and the server is down, the server should release the
lock on the resourceX automatically
"""
#targeted resource and client_address
resource_name = 'resourceX'
resource_id = get_resource_id_by_name(resource_name)[0]
client_address = '127.0.0.1'
client_lock = Lock(resource_name, client_address)
status = client_lock.check_status()
#initiate socket s and send the request access to resourceX
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
if status == 'free':
s.sendall('lock resourceX')
data = s.recv(1024)
# make sure the access is granted
assert data == 'You have an exclusive access to resource resourceX'
assert client_lock.check_status() == 'busy'
# make sure this operation stored into the db
#select operations
# client_ip_address, operation_time, operation_type
operations = get_operations_by_resource_id(resource_id)
assert len(operations) == 1
assert operations[0][0] == client_address
assert operations[0][2] == "lock"
# the client terminate the connection
s.close()
#delete operations
delete_operation_by_resource_id(resource_id)
elif status == 'busy':
s.sendall('lock resourceX')
data = s.recv(1024)
# make sure the resourceX is busy
assert data == 'required resource is busy now, you have to wait a while'
assert client_lock.check_status() == 'busy'
# the client terminate the connection
s.close()
# sleep for 5 seconds to make sure the server cleaning up is done
time.sleep(5)
# make sure the server make resourceX free after the client terminates the connection
assert client_lock.check_status() == 'free'
def setReadonly(self, lvName, readonly):
path = self._getPath(lvName)
if self.lvs[lvName].readonly != readonly:
uuids = util.findall_uuid(path)
ns = lvhdutil.NS_PREFIX_LVM + uuids[0]
# Taking this lock is needed to avoid a race condition
# with tap-ctl open (which is now taking the same lock)
lock = Lock("lvchange-p", ns)
lock.acquire()
lvutil.setReadonly(path, readonly)
lock.release()
self.lvs[lvName].readonly = readonly
def __init__(self,
woodType: str = DEFAULT_WOOD,
height: float = DEFAULT_HEIGHT,
width: float = DEFAULT_WIDTH,
lockdiameter: float = Lock.DEFAULT_DIAMETER,
state: bool = Lock.DEFAULT_STATE,
handlediameter: float = Handle.DEFAULT_DIAMETER):
self._woodType: str = woodType
self._height: float = height
self._width: float = width
self._lock: Lock = Lock(lockdiameter)
self._handle: Handle = Handle(handlediameter)
def recoverSite(self):
# reset timestamp:
self.timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
self.isRunning = True
for ID in self.variables:
self.lockTable[ID] = Lock()
# note the isReplicated() here!
for ID in self.isReady:
if not self.isReplicated(ID):
self.isReady[ID] = True
else:
self.isReady[ID] = False
def __init__(self):
self.pir = MyPiPIR(MyPiPIR.DEFAULT)
self.led = MyPiLed(MyPiLed.RED)
self.buzzer = MyPiBuzzer(MyPiBuzzer.DEFAULT)
self.locks = []
self.tries = 0
self.max_tries = 3
self.locks.append(Lock('Vault'))
self.logger = MyLogger("SecuritySystem")
self.check_interval = self.__class__.CHECK_INTERVAL
self.enabled = False
def load(self, sr_uuid):
self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid)
self.sr_vditype = SR.DEFAULT_TAP
if not self.dconf.has_key('server'):
raise xs_errors.XenError('ConfigServerMissing')
self.remoteserver = self.dconf['server']
self.path = os.path.join(SR.MOUNT_BASE, sr_uuid)
# Test for the optional 'nfsoptions' dconf attribute
self.transport = DEFAULT_TRANSPORT
if self.dconf.has_key('useUDP') and self.dconf['useUDP'] == 'true':
self.transport = "udp"
def load(self, sr_uuid):
self.ops_exclusive = OPS_EXCLUSIVE
self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid)
self.sr_vditype = vhdutil.VDI_TYPE_VHD
if not self.dconf.has_key('location') or not self.dconf['location']:
raise xs_errors.XenError('ConfigLocationMissing')
self.remotepath = self.dconf['location']
self.path = os.path.join(SR.MOUNT_BASE, sr_uuid)
self.linkpath = self.path
self.mountpoint = self.path
self.attached = False
self.driver_config = DRIVER_CONFIG
def activate(self, ns, ref, lvName, binary):
lock = Lock(ref, ns)
lock.acquire()
try:
count = RefCounter.get(ref, binary, ns)
if count == 1:
try:
self.activateNoRefcount(lvName)
except util.CommandException:
RefCounter.put(ref, binary, ns)
raise
finally:
lock.release()
def __init__(self, siteNum):
self.isRunning = True
self.isRecovered = True
self.siteNum = siteNum
# key: VariableID, value: Variable, this is for fast query data by ID
self.variables = {}
# key: VariableID, value: Lock(s)
# Locks keep tracking of who locked, who is waiting and what's the current lock type.
self.lockTable = {}
# key: VariableID, value: boolean, ready or not
# Note this isReady is to determine whether a variable's value is valid for read.
self.isReady = {}
self.timeStamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
# initialize the site here.
for i in range(1, 21):
v = Variable(i)
if i % 2 == 0:
self.variables["x" + str(i)] = v
self.lockTable["x" + str(i)] = Lock()
self.isReady["x" + str(i)] = True
elif (i + 1) % 10 == self.siteNum:
self.variables["x" + str(i)] = v
self.lockTable["x" + str(i)] = Lock()
self.isReady["x" + str(i)] = True
