def get_gid(self):
self.gid = self.group
if is_string(self.gid):
try:
info = grp.getgrnam(self.gid)
self.gid = info[2]
except:
pass
def get_uid(self):
self.uid = self.user
if is_string(self.uid):
try:
info = pwd.getpwnam(self.uid)
self.uid = info[2]
except:
pass
def gid(self):
gid = self.group
if is_string(gid):
try:
info = grp.getgrnam(gid)
gid = info[2]
except:
pass
return gid
def uid(self):
uid = self.user
if is_string(uid):
try:
info = pwd.getpwnam(uid)
uid = info[2]
except:
pass
return uid
def format_rule_val(self, val):
if is_string(val):
try:
tmp = json.loads(val)
val = json.dumps(tmp)
except Exception as e:
pass
if six.PY2:
val = val.encode("utf-8")
else:
val = str(val)
return val
def get_valid_actions(self, section, action):
"""
Given a section and an action prefix, return the list of
valid actions
"""
valid_actions = []
for candidate_action in sorted(self.actions[section]):
if is_string(action) and \
not candidate_action.startswith(action):
continue
if isinstance(action, list) and candidate_action not in action:
continue
valid_actions.append(candidate_action)
return valid_actions
def gce_auth(self):
cmd = ["gcloud", "auth", "list", "--format", "json"]
out, err, ret = justcall(cmd)
if ret != 0:
return False
self.log.debug(out)
data = json.loads(out)
if "active_account" not in data:
return False
if not is_string(data["active_account"]):
return False
if len(data["active_account"]) == 0:
return False
return True
def _add_key(self, key, data):
if not key:
raise ex.excError("configuration key name can not be empty")
if not data:
raise ex.excError("configuration value can not be empty")
if not is_string(data):
data = "base64:"+bdecode(base64.urlsafe_b64encode(data))
elif "\n" in data:
data = "base64:"+bdecode(base64.urlsafe_b64encode(bencode(data)))
else:
data = "literal:"+data
self.set_multi(["data.%s=%s" % (key, data)])
self.log.info("configuration key '%s' added (%s)", key, print_size(len(data), compact=True, unit="b"))
# refresh if in use
self.postinstall(key)
def _info(self):
"""
Contribute app resource standard and script-provided key/val pairs
to the service's resinfo.
"""
import re
keyvals = [
["script", self.script if self.script else ""],
["start", str(self.start_seq) if self.start_seq else ""],
["stop", str(self.stop_seq) if self.stop_seq else ""],
["check", str(self.check_seq) if self.check_seq else ""],
["info", str(self.info_seq) if self.info_seq else ""],
["timeout", str(self.timeout) if self.timeout else ""],
[
"start_timeout",
str(self.start_timeout) if self.start_timeout else ""
],
[
"stop_timeout",
str(self.stop_timeout) if self.stop_timeout else ""
],
[
"check_timeout",
str(self.check_timeout) if self.check_timeout else ""
],
[
"info_timeout",
str(self.info_timeout) if self.info_timeout else ""
],
]
try:
cmd = self.get_cmd("info")
except (ex.excAbortAction, AttributeError):
return keyvals
buff = self.run('info', cmd, dedicated_log=False, return_out=True)
if not is_string(buff) or len(buff) == 0:
keyvals.append(["Error", "info not implemented in launcher"])
return keyvals
for line in buff.splitlines():
try:
idx = line.find(':')
except ValueError:
continue
elements = line.split(":", 1)
keyvals.append([elements[0].strip(), elements[1].strip()])
return keyvals
def eval_condition(self, jsonpath_expr, oper, val, data):
for match in jsonpath_expr.find(data):
if oper is None:
if match.value:
return True
else:
continue
obj_class = type(match.value)
try:
if obj_class == bool:
val = convert_boolean(val)
else:
val = obj_class(val)
except Exception as exc:
raise ex.excError("can not convert to a common type")
if oper is None:
if match.value:
return True
if oper == "=":
if match.value == val:
return True
elif oper == ">":
if match.value > val:
return True
elif oper == "<":
if match.value < val:
return True
elif oper == ">=":
if match.value >= val:
return True
elif oper == "<=":
if match.value <= val:
return True
elif is_string(match.value) and oper == "~":
if re.match(val, match.value):
return True
elif oper == " in ":
try:
l = json.loads(val)
except:
l = val.split(",")
if match.value in l:
return True
return False
def create_volume(self):
volume = factory("vol")(name=self.r.volname,
namespace=self.r.svc.namespace,
node=self.r.svc.node)
if volume.exists():
self.r.log.info("volume %s already exists", self.r.volname)
data = volume.print_status_data(mon_data=True)
if not data or "cluster" not in data:
return volume
if not self.r.svc.node.get_pool(volume.pool):
raise ex.excError("pool %s not found on this node" %
volume.pool)
if self.r.svc.options.leader and volume.topology == "failover" and \
(self.owned() or not self.claimed(volume)) and \
data["avail"] != "up" and data["cluster"]["avail"] == "up":
self.r.log.info(
"volume %s is up on peer, we are leader: take it over",
self.r.volname)
volume.action("takeover", options={"wait": True, "time": 60})
return volume
elif not self.r.svc.options.leader:
self.r.log.info(
"volume %s does not exist, we are not leader: wait its propagation",
self.r.volname)
self.r.wait_for_fn(
lambda: volume.exists(), 10, 1,
"non leader instance waited for too long for the "
"volume to appear")
return volume
pooltype = self.r.oget("type")
self.r.log.info(
"create new volume %s (pool name: %s, pool type: %s, "
"access: %s, size: %s, format: %s, shared: %s)", self.r.volname,
self.r.pool, pooltype, self.r.access,
print_size(self.r.size, unit="B",
compact=True), self.r.format, self.r.shared)
pool = self.r.svc.node.find_pool(poolname=self.r.pool,
pooltype=pooltype,
access=self.r.access,
size=self.r.size,
fmt=self.r.format,
shared=self.r.shared)
if pool is None:
raise ex.excError("could not find a pool matching criteria")
pool.log = self.r.log
try:
nodes = self.r.svc._get("DEFAULT.nodes")
except ex.OptNotFound:
nodes = None
env = {}
for mapping in pool.volume_env:
try:
src, dst = mapping.split(":", 1)
except Exception:
continue
args = src.split(".", 1)
val = self.r.svc.oget(*args)
if val is None:
raise ex.excError("missing mapped key in %s: %s" %
(self.r.svc.path, mapping))
if is_string(val) and ".." in val:
raise ex.excError(
"the '..' substring is forbidden in volume env keys: %s=%s"
% (mapping, val))
env[dst] = val
pool.configure_volume(volume,
fmt=self.r.format,
size=self.r.size,
access=self.r.access,
nodes=nodes,
shared=self.r.shared,
env=env)
volume = factory("vol")(name=self.r.volname,
namespace=self.r.svc.namespace,
node=self.r.svc.node)
return volume
def format_default(d):
from rcPrintTable import print_table_default
if "error" in d and is_string(d["error"]):
print(d["error"], file=sys.stderr)
print_table_default(d)
def sched_get_schedule(self, section, option, schedules=None):
"""
Return the list of schedule structures for the spec string passed
as <schedules> or, if not passed, from the <section>.<option> value
in the configuration file.
"""
if schedules is None:
schedules = self.sched_get_schedule_raw(section, option)
try:
schedules = json.loads(schedules)
except:
pass
if is_string(schedules):
schedules = [schedules]
data = []
for schedule in schedules:
schedule_orig = schedule
schedule = schedule.strip()
if len(schedule) == 0:
continue
if schedule.startswith("!"):
exclude = True
schedule = schedule[1:].strip()
else:
exclude = False
if len(schedule) == 0:
continue
elements = schedule.split()
ecount = len(elements)
if ecount == 1:
_data = {
"timeranges":
self._sched_parse_timerange(elements[0], section=section),
"day":
"*",
"week":
"*",
"month":
"*",
}
elif ecount == 2:
_tr, _day = elements
_data = {
"timeranges": self._sched_parse_timerange(_tr,
section=section),
"day": _day,
"week": "*",
"month": "*",
}
elif ecount == 3:
_tr, _day, _week = elements
_data = {
"timeranges": self._sched_parse_timerange(_tr,
section=section),
"day": _day,
"week": _week,
"month": "*",
}
elif ecount == 4:
_tr, _day, _week, _month = elements
_data = {
"timeranges": self._sched_parse_timerange(_tr,
section=section),
"day": _day,
"week": _week,
"month": _month,
}
else:
raise SchedSyntaxError(
"invalid number of element, '%d' not in "
"(1, 2, 3, 4)" % ecount)
_data["exclude"] = exclude
_data["raw"] = schedule_orig
data.append(_data)
return data
def get_uid(self):
if is_string(self.user):
info = pwd.getpwnam(self.user)
self.uid = info[2]
else:
self.uid = int(self.user)
def get_gid(self):
if is_string(self.group):
info = grp.getgrnam(self.group)
self.gid = info[2]
else:
self.gid = int(self.group)