def wait_for_operation(conn, options, zone, operation):
if 'name' not in operation:
logging.warning('Cannot wait for operation to complete, the'
' requested operation will continue asynchronously')
return False
wait_time = 0
project = options["--project"]
while True:
result = retry_api_execute(
options,
conn.zoneOperations().get(project=project,
zone=zone,
operation=operation['name']))
if result['status'] == 'DONE':
if 'error' in result:
raise_fence_agent(options, result['error'])
return True
if "--errortimeout" in options and wait_time > int(
options["--errortimeout"]):
raise_fence_agent(
options, "Operation did not complete before the timeout.")
if "--warntimeout" in options and wait_time > int(
options["--warntimeout"]):
logging.warning("Operation did not complete before the timeout.")
if "--runonwarn" in options:
run_command(options, options["--runonwarn"])
return False
wait_time = wait_time + 1
time.sleep(1)
def ironic_run_command(options, action, timeout=None):
cmd = options["--openstack-path"] + " baremetal"
env = os.environ.copy()
# --username / -l
if "--username" in options and len(options["--username"]) != 0:
env["OS_USERNAME"] = options["--username"]
# --password / -p
if "--password" in options:
env["OS_PASSWORD"] = options["--password"]
# --tenant-name -t
if "--tenant-name" in options:
env["OS_TENANT_NAME"] = options["--tenant-name"]
# --auth-url
if "--auth-url" in options:
env["OS_AUTH_URL"] = options["--auth-url"]
# --action / -o
if action == "status":
cmd += " show %s -c power_state --format value" % (
get_name_or_uuid(options))
elif action in ["on", "off"]:
cmd += " power %s %s" % (action, get_name_or_uuid(options))
elif action == "list":
cmd += " list -c 'Instance UUID' -c Name -c 'Power State' --format csv --quote minimal"
logging.debug("cmd -> %s" % cmd)
return run_command(options, cmd, timeout, env)
def ironic_run_command(options, action, timeout=None):
cmd = options["--openstack-path"] + " baremetal"
env = os.environ.copy()
# --username / -l
if "--username" in options and len(options["--username"]) != 0:
env["OS_USERNAME"] = options["--username"]
# --password / -p
if "--password" in options:
env["OS_PASSWORD"] = options["--password"]
# --tenant-name -t
if "--tenant-name" in options:
env["OS_TENANT_NAME"] = options["--tenant-name"]
# --auth-url
if "--auth-url" in options:
env["OS_AUTH_URL"] = options["--auth-url"]
# --action / -o
if action == "status":
cmd += " show %s -c power_state --format value" % (get_name_or_uuid(options))
elif action in ["on", "off"]:
cmd += " power %s %s" % (action, get_name_or_uuid(options))
elif action == "list":
cmd += " list -c 'Instance UUID' -c Name -c 'Power State' --format csv --quote minimal"
logging.debug("cmd -> %s" % cmd)
return run_command(options, cmd, timeout, env)
def get_msg_timeout(options):
"""Reads the configured sbd message timeout from each device.
Key arguments:
options -- options dictionary
Return Value:
msg_timeout (integer, seconds)
"""
# get the defined msg_timeout
msg_timeout = -1 # default sbd msg timeout
cmd = generate_sbd_command(options, "dump")
(return_code, out, err) = run_command(options, cmd)
for line in out.split("\n"):
if len(line) == 0:
continue
if "msgwait" in line:
tmp_msg_timeout = int(line.split(':')[1])
if -1 != msg_timeout and tmp_msg_timeout != msg_timeout:
logging.warn(\
"sbd message timeouts differ in different devices")
# we only save the highest timeout
if tmp_msg_timeout > msg_timeout:
msg_timeout = tmp_msg_timeout
return msg_timeout
def get_attrd_status(host, options):
(status, pipe_stdout, pipe_stderr) = run_command(options, "attrd_updater -p -n evacuate -Q -N %s" % (host))
fields = pipe_stdout.split('"')
if len(fields) > 6:
return fields[5]
logging.debug("Got %s: o:%s e:%s n:%d" % (status, pipe_stdout, pipe_stderr, len(fields)))
return ""
def get_node_list(conn, options):
"""Returns a list of hostnames, registerd on the sbd device.
Key arguments:
conn -- connection options
options -- options
Return Value:
nodelist -- dictionary wich contains all node names and there status
"""
del conn
nodelist = {}
cmd = generate_sbd_command(options, "list")
(return_code, out, err) = run_command(options, cmd)
for line in out.split("\n"):
if len(line) == 0:
continue
# if we read "unreadable" something went wrong
if "NOT dumped" in line:
return nodelist
words = line.split()
port = words[1]
sbd_status = words[2]
nodelist[port] = (port, translate_status(sbd_status))
return nodelist
def get_attrd_status(host, options):
(status, pipe_stdout, pipe_stderr) = run_command(options, "attrd_updater -p -n evacuate -Q -N %s" % (host))
fields = pipe_stdout.split('"')
if len(fields) > 6:
return fields[5]
logging.debug("Got %s: o:%s e:%s n:%d" % (status, pipe_stdout, pipe_stderr, len(fields)))
return ""
def amt_run_command(options, command, timeout=None):
env = os.environ.copy()
x = quote(options["--password"])
x = x[:-1] if x.endswith("'") else x
x = x[1:] if x.startswith("'") else x
env["AMT_PASSWORD"] = x
return run_command(options, command, timeout, env)
def amt_run_command(options, command, timeout=None):
env = os.environ.copy()
x = quote(options["--password"])
x = x[:-1] if x.endswith("'") else x
x = x[1:] if x.startswith("'") else x
env["AMT_PASSWORD"] = x
return run_command(options, command, timeout, env)
def run_cmd(options, cmd):
ret = {}
if options.has_key("--use-sudo"):
prefix = options["--sudo-path"] + " "
else:
prefix = ""
(ret["err"], ret["out"], _) = run_command(options, prefix + cmd)
ret["out"] = "".join([i for i in ret["out"] if i is not None])
return ret
def run_cmd(options, cmd):
ret = {}
if options.has_key("--use-sudo"):
prefix = options["--sudo-path"] + " "
else:
prefix = ""
(ret["err"], ret["out"], _) = run_command(options, prefix + cmd)
ret["out"] = "".join([i for i in ret["out"] if i is not None])
return ret
def get_power_status(conn, options):
logger.debug("get_power_status(): %s" % options)
ip = options['--crosscableip']
timeout = options['--timeout']
# This returns 'off' if not a single ICMP packet gets answered during the
# whole timeout window. (the ping executable will return 1 in such case and
# 0 if even a single packet gets replied to)
(status, stdout, stderr) = run_command(options, "ping -w%s -n %s" %
(timeout, ip))
logger.debug("get_power_status(): %s - Stdout: %s - Stderr: %s" %
(status, stdout, stderr))
if status == 0:
return "on"
else:
return "off"
def amt_run_command(options, command, timeout=None):
env = os.environ.copy()
x = quote(options["--password"])
x = x[:-1] if x.endswith("'") else x
x = x[1:] if x.startswith("'") else x
env["AMT_PASSWORD"] = x
# This is needed because setting the AMT_PASSWORD env
# variable only works when no pipe is involved. E.g.:
# - Broken:
# $ AMT_PASSWORD='******' echo 'y' | /usr/bin/amttool nuc2 powerdown
# 401 Unauthorized at /usr/bin/amttool line 129.
# - Working:
# $ AMT_PASSWORD='******' sh -c "(echo 'y' | /usr/bin/amttool nuc2 powerdown)"
# execute: powerdown
# result: pt_status: success
newcommand = "sh -c \"(%s)\"" % command
return run_command(options, newcommand, timeout, env)
def amt_run_command(options, command, timeout=None):
env = os.environ.copy()
x = quote(options["--password"])
x = x[:-1] if x.endswith("'") else x
x = x[1:] if x.startswith("'") else x
env["AMT_PASSWORD"] = x
# This is needed because setting the AMT_PASSWORD env
# variable only works when no pipe is involved. E.g.:
# - Broken:
# $ AMT_PASSWORD='******' echo 'y' | /usr/bin/amttool nuc2 powerdown
# 401 Unauthorized at /usr/bin/amttool line 129.
# - Working:
# $ AMT_PASSWORD='******' sh -c "(echo 'y' | /usr/bin/amttool nuc2 powerdown)"
# execute: powerdown
# result: pt_status: success
newcommand = "sh -c \"(%s)\"" % command
return run_command(options, newcommand, timeout, env)
def check_sbd_device(options, device_path):
"""checks that a given sbd device exists and is initialized
Key arguments:
options -- options dictionary
device_path -- device path to check
Return Codes:
1 / DEVICE_INIT if the device exists and is initialized
-1 / PATH_NOT_EXISTS if the path does not exists
-2 / PATH_NOT_BLOCK if the path exists but is not a valid block device
-3 / DEVICE_NOT_INIT if the sbd device is not initialized
"""
# First of all we need to check if the device is valid
if not os.path.exists(device_path):
return PATH_NOT_EXISTS
# We need to check if device path is a symbolic link. If so we resolve that
# link.
if is_link(device_path):
link_target = os.readlink(device_path)
device_path = os.path.join(os.path.dirname(device_path), link_target)
# As second step we make sure it's a valid block device
if not is_block_device(device_path):
return PATH_NOT_BLOCK
cmd = "%s -d %s dump" % (options["--sbd-path"], device_path)
(return_code, out, err) = run_command(options, cmd)
for line in out.split("\n"):
if len(line) == 0:
continue
# If we read "NOT dumped" something went wrong, e.g. the device is not
# initialized.
if "NOT dumped" in line:
return DEVICE_NOT_INIT
return DEVICE_INIT
def send_sbd_message(conn, options, plug, message):
"""Sends a message to all sbd devices.
Key arguments:
conn -- connection structure
options -- options dictionary
plug -- plug to sent the message to
message -- message to send
Return Value:
(return_code, out, err) Tuple containing the error code,
"""
del conn
arguments = "%s %s" % (plug, message)
cmd = generate_sbd_command(options, "message", arguments)
(return_code, out, err) = run_command(options, cmd)
return (return_code, out, err)
def amt_run_command(options, command, timeout = None): env = os.environ.copy() env["AMT_PASSWORD"] = quote(options["--password"]) return run_command(options, command, timeout, env)
def reboot_cycle(_, options): (status, _, _) = run_command(options, create_command(options, "cycle")) return not bool(status)
def run_cmd(options, cmd):
ret = {}
(ret["err"], ret["out"], _) = run_command(options, cmd)
ret["out"] = "".join([i for i in ret["out"] if i is not None])
return ret
def _run_command(options, action):
cmd, log_cmd = create_command(options, action)
return run_command(options, cmd, log_command=log_cmd)
def reboot_diag(_, options):
output = run_command(options, create_command(options, "diag"))
return bool(re.search("chassis power control: diag", str(output).lower()))
def reboot_cycle(_, options):
output = run_command(options, create_command(options, "cycle"))
return bool(re.search("chassis power control: cycle", str(output).lower()))
def set_attrd_status(host, status, options):
logging.debug("Setting fencing status for %s to %s" % (host, status))
run_command(options, "attrd_updater -p -n evacuate -Q -N %s -U %s" % (host, status))
def reboot_cycle(_, options):
output = run_command(options, create_command(options, "cycle"))
return bool(re.search('chassis power control: cycle', str(output).lower()))
def set_power_status(_, options):
run_command(options, create_command(options, options["--action"]))
return
def get_power_status(_, options):
output = run_command(options, create_command(options, "status"))
match = re.search('[Cc]hassis [Pp]ower is [\\s]*([a-zA-Z]{2,3})',
str(output))
status = match.group(1) if match else None
return status
def reboot_diag(_, options):
output = run_command(options, create_command(options, "diag"))
return bool(re.search('chassis power control: diag', str(output).lower()))
def set_power_status(_, options):
run_command(options, create_command(options, options["--action"]))
return
def reboot_cycle(_, options):
(status, _, _) = run_command(options, create_command(options, "cycle"))
return not bool(status)
def run_on_fail(options):
if "--runonfail" in options:
run_command(options, options["--runonfail"])
def set_attrd_status(host, status, options):
logging.debug("Setting fencing status for %s to %s" % (host, status))
run_command(options,
"attrd_updater -p -n evacuate -Q -N %s -U %s" % (host, status))
def get_power_status(_, options):
output = run_command(options, create_command(options, "status"))
match = re.search("[Cc]hassis [Pp]ower is [\\s]*([a-zA-Z]{2,3})", str(output))
status = match.group(1) if match else None
return status
def run_cmd(options, cmd):
ret = {}
(ret["err"], ret["out"], _) = run_command(options, cmd)
ret["out"] = "".join([i for i in ret["out"] if i is not None])
return ret
def _run_command(options, action): cmd, log_cmd = create_command(options, action) return run_command(options, cmd, log_command=log_cmd)
