def decorator(*args, **kwargs):
if len(args) > 0 and hasattr(args[0], "log"):
log = args[0].log
else:
log = None
if len(args) > 0 and hasattr(args[0], "cache_sig_prefix"):
_sig = args[0].cache_sig_prefix + sig
else:
_sig = sig.format(args=args, kwargs=kwargs)
fpath = cache_fpath(_sig)
try:
lfd = lock.lock(timeout=30, delay=0.1, lockfile=fpath + '.lock', intent="cache")
except Exception as e:
if log:
log.warning("cache locking error: %s. run command uncached." % str(e))
return fn(*args, **kwargs)
try:
data = cache_get(fpath, log=log)
except Exception as e:
if log:
log.debug(str(e))
data = fn(*args, **kwargs)
cache_put(fpath, data, log=log)
lock.unlock(lfd)
return data
def provisioner(self, need_boot=True):
"""provision zone
- configure zone
- if snapof and zone brand is native
then create zonepath from snapshot of snapof
then attach zone
- if snapof and zone brand is ipkg
then try to detect zone associated with snapof
then define container_origin
- if container_origin
then clone container_origin
- create sysidcfg
- if need_boot boot and wait multiuser
"""
self.osver = get_solaris_version()
self.zone_configure()
if self.osver >= 11:
self.create_sysidcfg(self.r)
else:
if self.snapof is not None and self.r.brand == 'native':
self.create_zonepath()
self.r.zoneadm("attach", ["-F"])
elif self.snapof is not None and self.r.brand == 'ipkg':
zones = rcZone.Zones()
src_dataset = Dataset(self.snapof)
zonepath = src_dataset.getprop('mountpoint')
self.container_origin = zones.zonename_from_zonepath(
zonepath).zonename
self.log.info("source zone is %s (detected from snapof %s)" %
(self.container_origin, self.snapof))
if self.container_origin is not None:
lockname = 'create_zone2clone-' + self.container_origin
lockfile = os.path.join(rcEnv.paths.pathlock, lockname)
self.log.info("wait get lock %s" % (lockname))
try:
lockfd = lock.lock(timeout=1200, delay=5, lockfile=lockfile)
except:
raise (ex.excError("failure in get lock %s" % (lockname)))
try:
self.create_zone2clone()
except:
lock.unlock(lockfd)
raise
lock.unlock(lockfd)
self.create_cloned_zone()
if self.osver < 11:
self.create_sysidcfg(self.r)
if need_boot is True:
self.r.zone_boot()
self.r.wait_multi_user()
self.r.log.info("provisioned")
return True
def daemon_test_lock():
lockfd = None
try:
lockfd = lock.lock(lockfile=rcEnv.paths.daemon_lock, timeout=0, delay=0)
except:
return True
finally:
lock.unlock(lockfd)
return False
def unlock(self):
"""
Release the app action lock.
"""
if not self.lockfd:
return
self.log.debug("release app lock")
lock.unlock(self.lockfd)
try:
os.unlink(self.lockfile)
except OSError:
pass
self.lockfd = None
def clear_cache(sig, o=None):
if o and hasattr(o, "cache_sig_prefix"):
sig = o.cache_sig_prefix + sig
fpath = cache_fpath(sig)
if not os.path.exists(fpath):
return
if o and hasattr(o, "log"):
o.log.debug("cache CLEAR: %s" % fpath)
lfd = lock.lock(timeout=30, delay=0.1, lockfile=fpath + '.lock')
try:
os.unlink(fpath)
except:
pass
lock.unlock(lfd)
def process(command):
global data_is_encrypted
if (command == 'exit'):
conn.send("Exiting...\n")
close_all()
elif (command == 'encrypt'):
data_is_encrypted = True
return "Using Encrypted Commands now.\n"
elif (command == 'plain'):
data_is_encrypted = False
return "Using Plain-Text Commands now.\n"
elif (command == 'reboot please'):
reboot()
return "You asked for it.\n"
elif (command == 'reboot'):
return "If you ask nicely.\n"
elif (command == 'lock'):
return lock.lock() + "\n"
elif (command == 'unlock'):
return lock.unlock() + "\n"
elif (command == 'attempt'):
return "Attempt " + str(attempt_num) + "\n"
elif (command == 'hello'):
return "Hi.\n"
else:
return command + ' is not a recognized command\n'
def web_unlock():
if not (request.args.get("token") and request.args.get("state")):
return "Error"
else:
with shelve.open("Settings.conf") as settings:
if "token" in settings:
token = settings["token"]
else:
return "System not setup !"
if request.args.get("token") != token:
return "Invalid Token"
if request.args.get("state") == "open":
lock.unlock()
elif request.args.get("state") == "close":
lock.lock()
elif request.args.get("state") == "switch":
lock.switch()
else:
return "Invalid State"
return "Done"
def f_unlock():
lock.unlock()
def unlock(self):
import lock
lock.unlock(self.lockfd)
def unlock(self):
if self.lockfd:
unlock(self.lockfd)
self.set_last_shutdown()
def test_lock_unlock(tmp_file, timeout):
assert os.path.exists(tmp_file) is False
lock_fd = lock.lock(lockfile=tmp_file, timeout=timeout, intent="test")
assert os.path.exists(tmp_file) is True
lock.unlock(lock_fd)
def resunlock(self):
"""
Release the service action lock.
"""
lock.unlock(self.lockfd)
self.lockfd = None
def unlock(self):
"""
Release the startip lock.
"""
lock.unlock(self.lockfd)
def docker_start(self, verbose=True):
"""
Start the docker daemon if in private mode and not already running.
"""
if not self.docker_daemon_private:
return
if self.docker_cmd is None:
raise ex.excError("docker executable not found")
import lock
lockfile = os.path.join(self.svc.var_d, "lock.docker_start")
try:
lockfd = lock.lock(timeout=15, delay=1, lockfile=lockfile)
except lock.LOCK_EXCEPTIONS as exc:
self.svc.log.error("dockerd start lock acquire failed: %s",
str(exc))
return
# Sanity checks before deciding to start the daemon
if self.docker_running():
lock.unlock(lockfd)
return
if self.container_data_dir is None:
lock.unlock(lockfd)
return
resource = self._container_data_dir_resource()
if resource is not None:
state = resource._status()
if state not in (rcStatus.UP, rcStatus.STDBY_UP):
self.svc.log.warning(
"the docker daemon data dir is handled by the %s "
"resource in %s state. can't start the docker "
"daemon", resource.rid, rcStatus.Status(state))
lock.unlock(lockfd)
return
if os.path.exists(self.docker_pid_file):
self.svc.log.warning("removing leftover pid file %s",
self.docker_pid_file)
os.unlink(self.docker_pid_file)
# Now we can start the daemon, creating its data dir if necessary
cmd = self.dockerd_cmd
if verbose:
self.svc.log.info("starting docker daemon")
self.svc.log.info(" ".join(cmd))
import subprocess
subprocess.Popen(
["nohup"] + cmd,
stdout=open("/dev/null", "w"),
stderr=open("/dev/null", "a"),
preexec_fn=os.setpgrp,
close_fds=True,
)
import time
try:
for _ in range(self.max_wait_for_dockerd):
if self._docker_working():
self.clear_daemon_caches()
return
time.sleep(1)
finally:
lock.unlock(lockfd)
def unlock(self):
if self.lockfd is None:
return
lock.unlock(self.lockfd)
self.lockfd = None
