def testReleaseMutex(self):
mutex = win32event.CreateMutex(None, True, None)
res = win32event.ReleaseMutex(mutex)
assert res == None
res = win32event.WaitForSingleObject(mutex, 0)
assert res == win32event.WAIT_OBJECT_0
mutex.close()
with pytest.raises(pywintypes.error):
win32event.ReleaseMutex(mutex)
def issueKomodoCommandments(cmds):
if not cmds:
return
if sys.platform.startswith("win"):
# Grab the lock.
lock = win32event.CreateMutex(None, 0, _gCommandmentsLockName)
win32event.WaitForSingleObject(lock, win32event.INFINITE)
# Append the new commandments.
f = open(_gCommandmentsFileName, 'a')
for cmd in cmds:
f.write(cmd)
f.close()
# Signal Komodo that there are new commandments.
newCommandments = win32event.CreateEvent(None, 1, 0,
_gCommandmentsEventName)
win32event.SetEvent(newCommandments)
win32api.CloseHandle(newCommandments)
# Release the lock.
win32event.ReleaseMutex(lock)
win32api.CloseHandle(lock)
else:
fd = os.open(_gCommandmentsFileName, os.O_WRONLY)
for cmd in cmds:
os.write(fd, cmd)
os.close(fd)
def issueCommandments(options):
cmds = ["open\t%s\n" % f for f in options.files]
if not cmds: return
if sys.platform == "win32":
# Grab the lock.
lock = win32event.CreateMutex(None, 0, gCommandmentsLockName)
win32event.WaitForSingleObject(lock, win32event.INFINITE)
# Append the new commandments.
f = open(gCommandmentsFileName, 'a')
for cmd in cmds:
log.info("issue %r", cmd)
f.write(cmd)
f.close()
# Signal Komodo that there are new commandments.
newCommandments = win32event.CreateEvent(None, 1, 0,
gCommandmentsEventName)
win32event.SetEvent(newCommandments)
win32api.CloseHandle(newCommandments)
# Release the lock.
win32event.ReleaseMutex(lock)
win32api.CloseHandle(lock)
else:
fd = os.open(gCommandmentsFileName, os.O_WRONLY | os.O_APPEND)
for cmd in cmds:
log.info("issue %r", cmd)
os.write(fd, cmd)
os.close(fd)
def OnExit(self):
#設定の保存やリソースの開放など、終了前に行いたい処理があれば記述できる
#ビューへのアクセスや終了の抑制はできないので注意。
if globalVars.app.config.getboolean(
"player", "fadeOutOnExit", False
) and globalVars.play.getStatus() == PLAYER_STATUS_PLAYING:
while globalVars.play.setVolumeByDiff(-2):
time.sleep(0.07)
globalVars.play.exit()
m3uManager.dumpHistory()
globalVars.app.config.write()
try:
lampPipe.stopPipeServer()
except:
pass
if self.mutex != 0:
try:
win32event.ReleaseMutex(self.mutex)
except:
pass
self.mutex = 0
# アップデート
globalVars.update.runUpdate()
#戻り値は無視される
return 0
def exchandler(type, exc, tb):
msg = traceback.format_exception(type, exc, tb)
print("".join(msg))
try:
f = open("errorLog.txt", "a")
f.writelines(msg)
f.close()
except:
pass
# パイプとミューテックスの終了
try:
import lampPipe, globalVars
lampPipe.stopPipeServer()
win32event.ReleaseMutex(globalVars.app.mutex)
except:
pass
if hasattr(sys, "frozen") == False:
winsound.Beep(1500, 100)
winsound.Beep(1500, 100)
winsound.Beep(1500, 300)
else:
simpleDialog.winDialog(
"error",
"An error has occured. Contact to the developer for further assistance. Detail:"
+ "\n".join(msg[-2:]))
os._exit(1)
def testReleaseMutex(self):
mutex = win32event.CreateMutex(None, True, None)
res = win32event.ReleaseMutex(mutex)
self.assertEqual(res, None)
res = win32event.WaitForSingleObject(mutex, 0)
self.assertEqual(res, win32event.WAIT_OBJECT_0)
mutex.close()
self.assertRaises(pywintypes.error, win32event.ReleaseMutex, mutex)
def OnDestroy(self, hwnd, msg, wparam, lparam):
nid = (self.hwnd, 0)
win32gui.Shell_NotifyIcon(win32gui.NIM_DELETE, nid)
self._Terminate()
win32event.ReleaseMutex(self._hActiveMutex)
win32api.CloseHandle(self._hActiveMutex)
# Terminate the app.
win32gui.PostQuitMessage(0)
def release(self):
'''
Release an acquired mutex. Raises IOError on error.
'''
if is_windows():
win32event.ReleaseMutex(self.handle) # pylint: disable=no-member
else:
fcntl.flock(self.handle, fcntl.LOCK_UN)
self.acquired = False
def write(self, data):
#Ensure that the output is thread-safe when writing from 2 separate streams into the same file
# (typical when redirecting both stdout and stderr to the same file).
win32event.WaitForSingleObject(self.hMutexWrite, win32event.INFINITE)
try:
self.stream.write(data)
self.stream.flush()
finally:
win32event.ReleaseMutex(self.hMutexWrite)
def release(self, skip_delete=False):
''' Unlocks. (caller must own the lock!)
@param skip_delete: don't try to delete the file. This can
be used when the original filename has changed; for
instance, if the lockfile is erased out-of-band, or if
the directory it contains has been renamed.
@return: The lock count.
@exception IOError: if file lock can't be released
@exception NotOwner: Attempt to release somebody else's lock.
'''
if not self.is_locked:
return
if not skip_delete:
if self.logger:
self.logger.debug('Removing lock file: %s', self.fpath)
os.unlink(self.fpath)
elif self.logger:
# At certain times the lockfile will have been removed or
# moved away before we call release(); log a message because
# this is unusual and could be an error.
self.logger.debug('Oops, my lock file disappeared: %s', self.fpath)
if _windows:
if ctypes:
result = ctypes.windll.kernel32.ReleaseMutex(self.mutex.handle)
if not result:
raise NotOwner("Attempt to release somebody else's lock")
else:
try:
win32event.ReleaseMutex(self.mutex)
#print "released mutex"
except pywintypes.error as e:
errCode, fctName, errMsg = e.args
if errCode == 288:
raise NotOwner(
"Attempt to release somebody else's lock")
else:
raise GlobalLockError('%s: err#%d: %s' %
(fctName, errCode, errMsg))
else:
# First release the local (inter-thread) lock:
try:
self.threadLock.release()
except AssertionError:
raise NotOwner("Attempt to release somebody else's lock")
# Then release the global (inter-process) lock:
try:
fcntl.flock(self.fdlock, fcntl.LOCK_UN)
except IOError: # (errno 13: permission denied)
raise GlobalLockError('Unlock of file "%s" failed\n' %
self.name)
self.is_locked = False
def __del__(self):
try:
lampPipe.stopPipeServer()
except:
pass
if self.mutex != 0:
try:
win32event.ReleaseMutex(self.mutex)
except:
pass
self.mutex = 0
def discover_sic_socket(self):
takeover = 0
# mutex exists and has been opened (not created, not locked).
# wait for it so we can read the file
r = win32event.WaitForSingleObject(self.mutex, win32event.INFINITE)
# WAIT_OBJECT_0 means the mutex was obtained
# WAIT_ABANDONED means the mutex was obtained, and it had previously been abandoned
if (r != win32event.WAIT_OBJECT_0) and (r !=
win32event.WAIT_ABANDONED):
raise BTFailure(
_("Could not acquire global mutex lock for controlsocket file!"
))
filename = self._get_sic_path()
try:
f = open(filename, "r")
self.port = int(f.read())
f.close()
except:
if (r == win32event.WAIT_ABANDONED):
self.log(
WARNING,
_("A previous instance of BT was not cleaned up properly. Continuing."
))
# take over the role of master
takeover = 1
else:
self.log(WARNING, (_(
"Another instance of BT is running, but \"%s\" does not exist.\n"
) % filename) + _("I'll guess at the port."))
try:
self.port = CONTROL_SOCKET_PORT
self.send_command('no-op')
self.log(WARNING, _("Port found: %d") % self.port)
try:
f = open(filename, "w")
f.write(str(self.port))
f.close()
except:
traceback.print_exc()
except:
# this is where this system falls down.
# There's another copy of BitTorrent running, or something locking the mutex,
# but I can't communicate with it.
self.log(WARNING, _("Could not find port."))
# we're done reading the control file, release the mutex so other instances can lock it and read the file
win32event.ReleaseMutex(self.mutex)
return takeover
def stop(self):
if self.master:
r = win32event.WaitForSingleObject(self.mutex, win32event.INFINITE)
filename = self._get_sic_path()
try:
os.remove(filename)
except OSError, e:
# print, but continue
traceback.print_exc()
self.master = 0
win32event.ReleaseMutex(self.mutex)
# close it so the named mutex goes away
win32api.CloseHandle(self.mutex)
self.mutex = None
def release(self):
# unlock
assert self._mylock
if os.name == 'nt':
win32event.ReleaseMutex(self._mutex)
# Error code 123?
#lasterror = win32api.GetLastError()
#if lasterror != 0:
# raise IOError( _("Could not release mutex %s due to "
# "error windows code %d.") %
# (self._name,lasterror) )
elif os.name == 'posix':
self._mylock = False
if not os.path.exists(self._path):
raise IOError(_("Non-existent file: %s") % self._path)
flock(self._mutex.fileno(), fcntl.LOCK_UN)
self._mutex.close()
def exit(self):
# Grab the lock.
lock = win32event.CreateMutex(None, 0, _gCommandmentsLockName)
win32event.WaitForSingleObject(lock, win32event.INFINITE)
# Send __exit__ commandment.
f = open(_gCommandmentsFileName, 'a')
f.write("__exit__\n")
f.close()
# Signal hat there are new commandments.
newCommandments = win32event.CreateEvent(None, 1, 0,
_gCommandmentsEventName)
win32event.SetEvent(newCommandments)
win32api.CloseHandle(newCommandments)
# Release the lock.
win32event.ReleaseMutex(lock)
win32api.CloseHandle(lock)
self.join()
def run(self):
lock = win32event.CreateMutex(None, 0, gCommandmentsLockName)
existing = os.path.exists(gCommandmentsFileName)
newCommandments = win32event.CreateEvent(None, 0, existing,
gCommandmentsEventName)
while 1:
# Wait for new commandments.
rv = win32event.WaitForSingleObject(newCommandments,
win32event.INFINITE)
if rv == win32event.WAIT_OBJECT_0:
retval = 1
else:
raise "Error waiting for new commandments: %r" % rv
# Grab the lock.
win32event.WaitForSingleObject(lock, win32event.INFINITE)
# Consume the commandments.
f = open(gCommandmentsFileName, 'r')
cmds = []
for line in f.readlines():
if line[-1] == '\n':
line = line[:-1]
if line.strip(): # skip empty lines
cmds.append(line)
f.close()
os.unlink(gCommandmentsFileName)
# Reset the "new commandments" event.
win32event.ResetEvent(newCommandments)
# Release the lock.
win32event.ReleaseMutex(lock)
# Handle the commandments.
exit = 0
for cmd in cmds:
log.info("handle: %r", cmd)
if cmd == "__exit__":
exit = 1
break
if exit:
break
win32api.CloseHandle(newCommandments)
win32api.CloseHandle(lock)
def run(self):
lock = win32event.CreateMutex(None, 0, _gCommandmentsLockName)
newCommandments = win32event.CreateEvent(None, 1, 0,
_gCommandmentsEventName)
while 1:
# Wait for new commandments.
rv = win32event.WaitForSingleObject(newCommandments,
win32event.INFINITE)
if rv == win32event.WAIT_OBJECT_0:
retval = 1
else:
raise "Error waiting for new commandments: %r" % rv
# Grab the lock.
win32event.WaitForSingleObject(lock, win32event.INFINITE)
# Consume the commandments.
f = open(_gCommandmentsFileName, 'r')
cmds = []
for line in f.readlines():
if line.endswith('\n'):
cmds.append( line[:-1] )
f.close()
os.unlink(_gCommandmentsFileName)
# Reset the "new commandments" event.
win32event.ResetEvent(newCommandments)
# Release the lock.
win32event.ReleaseMutex(lock)
# Handle the commandments.
exit = 0
for cmd in cmds:
print "command handler: cmd=%r" % cmd
if cmd == "__exit__":
exit = 1
break
if exit:
break
win32api.CloseHandle(newCommandments)
win32api.CloseHandle(lock)
def OnExit(self):
#設定の保存やリソースの開放など、終了前に行いたい処理があれば記述できる
#ビューへのアクセスや終了の抑制はできないので注意。
m3uManager.dumpHistory()
globalVars.app.config.write()
try:
lampPipe.stopPipeServer()
except:
pass
if self.mutex != 0:
try:
win32event.ReleaseMutex(self.mutex)
except:
pass
self.mutex = 0
# アップデート
globalVars.update.runUpdate()
#戻り値は無視される
return 0
break
elif close_watch_method == "playnite_mutex":
while True:
try:
#Instance is spelled wrong in the Playnite source code, this may need to be fixed someday
#for now it must be spelled Instace
playnite_mutex_handle = win32event.OpenMutex(
win32event.SYNCHRONIZE, False, "PlayniteInstaceMutex")
break
except Exception as e:
print(f"Exception attempting to open Playnite mutex:{e}")
sleep(0.1)
#Playnite creates and locks a mutex so if we can lock the mutex it means Playnite has quit
win32event.WaitForSingleObject(playnite_mutex_handle, 0xffffffff)
#We need to tear down the mutex or Playnite won't start again
win32event.ReleaseMutex(playnite_mutex_handle)
win32api.CloseHandle(playnite_mutex_handle)
else:
print(
"No valid close_watch_method in the config. Press Enter when you're done."
)
input()
# Terminate background and launch session_end programs, if they're available
kill_processes(cfg_bg_paths)
launch_processes(cfg_end_paths)
# Restore original resolution
if skip_res_reset == False:
print('Restoring original resolution.')
cfg = get_configuration_alexnet()
prepare_detect(cfg, False)
model = load_model(model_path)
# make evaluator
evaluator = FasterRCNN_Evaluator(model, cfg)
# prepare main image detect. BCZ It is too slow first,second time.
od.predict_dummy_image(model, cfg, evaluator)
od.predict_dummy_image(model, cfg, evaluator)
od.predict_dummy_image(model, cfg, evaluator)
#od.predict_dummy_image(model, cfg,evaluator)
#od.predict_dummy_image(model, cfg,evaluator)
# model load finished
win32event.WaitForSingleObject(mutex, win32event.INFINITE)
shm.write(bytes(str(1), "ascii"))
win32event.ReleaseMutex(mutex)
#=======================================================================================================================
while (ctypes.windll.user32.IsWindow(hwnd)):
win32event.WaitForSingleObject(mutex, win32event.INFINITE)
shm.seek(0)
run_type = shm.read(1)
if (run_type == b'2'):
img_path = shm.read(256).decode('cp949')
img_path = img_path.split('\0', 1)[0]
# detect
regressed_rois, cls_probs = od.predict_single_image(
model, img_path, cfg, evaluator)
# fix roi
img = imreadEX(img_path)
height, width = img.shape[:2]
scale = 850.0 / max(width, height)
def releaseMutex(mutex):
if sys.platform == "win32":
win32event.ReleaseMutex(mutex)
win32api.CloseHandle(mutex)
else:
fcntl.lockf(mutex, fcntl.LOCK_UN)
def release(self):
return win32event.ReleaseMutex(self.mutex)
def closeMutex(self):
if self.MutexHndle:
win32event.ReleaseMutex(self.MutexHndle)
self.MutexHndle = None
KILL_EVENT.close()
exit(1)
with SafeExecutionPack(MEM, MUTEX, RECOGNITION_EVENT, RESULT_TAKEN_EVENT, KILL_EVENT):
exception_counter = 0
while True:
try:
w = win32event.WaitForSingleObject(KILL_EVENT, 100)
if w == win32event.WAIT_OBJECT_0:
print('Kill event accepted')
break
img = event_generator_proc.get_webcam_image()
if not event_generator_proc.is_passport(img):
continue
w = win32event.WaitForSingleObject(MUTEX, 0)
if w == win32event.WAIT_TIMEOUT:
continue
data = event_generator_proc.recognition(img)
event_generator_proc.json_to_mem(MEM_BUF, data)
win32event.ReleaseMutex(MUTEX)
win32event.SetEvent(RECOGNITION_EVENT)
w = win32event.WaitForSingleObject(RESULT_TAKEN_EVENT, 10000)
if w == win32event.WAIT_TIMEOUT:
print('Missing recognized passport, data:\n')
except Exception as e:
print('Exception', e)
exception_counter += 1
if exception_counter == 5:
print('TOO MUCH EXCEPTIONS')
break
filename = self._get_sic_path()
(path, name) = os.path.split(filename)
try:
os.makedirs(path)
except OSError, e:
# 17 is dir exists
if e.errno != 17:
BTFailure(_("Could not create application data directory!"))
f = open(filename, "w")
f.write(str(self.port))
f.close()
# we're done writing the control file, release the mutex so other instances can lock it and read the file
# but don't destroy the handle until the application closes, so that the named mutex is still around
win32event.ReleaseMutex(self.mutex)
def discover_sic_socket(self):
takeover = 0
# mutex exists and has been opened (not created, not locked).
# wait for it so we can read the file
r = win32event.WaitForSingleObject(self.mutex, win32event.INFINITE)
# WAIT_OBJECT_0 means the mutex was obtained
# WAIT_ABANDONED means the mutex was obtained, and it had previously been abandoned
if (r != win32event.WAIT_OBJECT_0) and (r !=
win32event.WAIT_ABANDONED):
raise BTFailure(
_("Could not acquire global mutex lock for controlsocket file!"
))
bufsize = 65535
pos = 0
while pos < tempsize:
# read text from our temporary log file
text = ftemp.read(min(bufsize,
tempsize - pos)).replace('\r\n', '\n')
f.write(text)
pos = pos + bufsize
except IOError, e:
print('Could not write to the log file %s. Error: %s' %
(logfile, str(e)))
# release our synchronisation mutex
if sys.platform.startswith("win") and hMutex is not None:
try:
win32event.ReleaseMutex(hMutex)
except win32api.error, e:
print('Could not release mutex %s Error: %s' % (name, str(e)))
def GetDBInfo(filename):
try:
# first 100 bytes of the file are definitely text
f = file(filename, 'rt')
# read first 100 bytes
data = f.read(100)
data = data.split(':')
updatestr, ver, numv = data[1:4]
# set C locale, otherwise python and wxpython complain
locale.setlocale(locale.LC_ALL, 'C')
def __ReleaseMutex__(self):
w.ReleaseMutex(self.__class__.__sMutex[self.key])
if dbg: print("Lock Released for " + self.key)
def releaseKomodoStatusLock(lock):
# No such lock used on Linux.
if sys.platform.startswith("win"):
win32event.ReleaseMutex(lock)
win32api.CloseHandle(lock)
def unlock(self):
try:
win32event.ReleaseMutex(self._mutex)
return True
except:
return False
def release(self):
win32event.ReleaseMutex(self.handle)
self.locked = False
