This file is indexed.

/usr/sbin/fence_sbd is in fence-agents 4.0.22-2.

This file is owned by root:root, with mode 0o755.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
#!/usr/bin/python -tt

import sys, stat
import logging
import os
import atexit
sys.path.append("/usr/share/fence")
from fencing import fail_usage, run_command, fence_action, all_opt
from fencing import atexit_handler, check_input, process_input, show_docs
from fencing import run_delay

#BEGIN_VERSION_GENERATION
RELEASE_VERSION="4.0.22"
BUILD_DATE="(built Sat, 06 Feb 2016 12:34:18 +0100)"
REDHAT_COPYRIGHT="Copyright (C) Red Hat, Inc. 2004-2010 All rights reserved."
#END_VERSION_GENERATION

DEVICE_INIT = 1
DEVICE_NOT_INIT = -3
PATH_NOT_EXISTS = -1
PATH_NOT_BLOCK = -2

def is_block_device(filename):
    """Checks if a given path is a valid block device

    Key arguments:
    filename -- the file to check

    Return codes:
    True if it's a valid block device
    False, otherwise
    """

    try:
        mode = os.lstat(filename).st_mode
    except OSError:
        return False
    else:
        return stat.S_ISBLK(mode)

def is_link(filename):
    """Checks if a given path is a link.

    Key arguments:
    filename -- the file to check

    Return codes:
    True if it's a link
    False, otherwise
    """

    try:
        mode = os.lstat(filename).st_mode
    except OSError:
        return False
    else:
        return stat.S_ISLNK(mode)

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 generate_sbd_command(options, command, arguments=None):
    """Generates a sbd command based on given arguments.

    Return Value:
    generated sbd command (string)
    """
    cmd = options["--sbd-path"]

    # add "-d" for each sbd device
    for device in parse_sbd_devices(options):
        cmd += " -d %s" % device

    cmd += " %s %s" % (command, arguments)

    return cmd

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 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 set_power_status(conn, options):
    """send status to sbd device (poison pill)

    Key arguments:
    conn -- connection structure
    options -- options dictionary

    Return Value:
    return_code -- return code (integer)
    """

    target_status = options["--action"]
    plug = options["--plug"]
    return_code = 99
    out = ""
    err = ""

    # Map fencing actions to sbd messages
    if "on" == target_status:
        (return_code, out, err) = send_sbd_message(conn, options, plug, "clear")
    elif "off" == target_status:
        (return_code, out, err) = send_sbd_message(conn, options, plug, "off")
    elif "reboot" == target_status:
        (return_code, out, err) = send_sbd_message(conn, options, plug, "reset")

    if 0 != return_code:
        logging.error("sending message to sbd device(s) \
                failed with return code %d", return_code)
        logging.error("DETAIL: output on stdout was \"%s\"", out)
        logging.error("DETAIL: output on stderr was \"%s\"", err)

    return return_code

def reboot_cycle(conn, options):
    """" trigger reboot by sbd messages

    Key arguments:
    conn -- connection structure
    options -- options dictionary

    Return Value:
    return_code -- return code (integer)
    """

    plug = options["--plug"]
    return_code = 99
    out = ""
    err = ""

    (return_code, out, err) = send_sbd_message(conn, options, plug, "reset")
    return return_code

def get_power_status(conn, options):
    """Returns the status of a specific node.

    Key arguments:
    conn -- connection structure
    options -- option dictionary

    Return Value:
    status -- status code (string)
    """

    status = "UNKWNOWN"
    plug = options["--plug"]

    nodelist = get_node_list(conn, options)

    # We need to check if the specified plug / node a already a allocated slot
    # on the device.
    if not nodelist.has_key(plug):
        logging.error("node \"%s\" not found in node list", plug)
    else:
        status = nodelist[plug][1]


    return status

def translate_status(sbd_status):
    """Translates the sbd status to fencing status.

    Key arguments:
    sbd_status -- status to translate (string)

    Return Value:
    status -- fencing status (string)
    """

    status = "UNKNOWN"


    # Currently we only accept "clear" to be marked as online. Eventually we
    # should also check against "test"
    online_status = ["clear"]

    offline_status = ["reset", "off"]

    if any(online_status_element in sbd_status \
            for online_status_element in online_status):
        status = "on"

    if any(offline_status_element in sbd_status \
            for offline_status_element in offline_status):
        status = "off"

    return status

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 parse_sbd_devices(options):
    """Returns an array of all sbd devices.

    Key arguments:
    options -- options dictionary

    Return Value:
    devices -- array of device paths
    """

    devices = [str.strip(dev) \
            for dev in str.split(options["--devices"], ",")]

    return devices

def define_new_opts():
    """Defines the all opt list
    """
    all_opt["devices"] = {
        "getopt" : ":",
        "longopt" : "devices",
        "help":"--devices=[device_a,device_b] \
Comma separated list of sbd devices",
        "required" : "1",
        "shortdesc" : "SBD Device",
        "order": 1
        }

    all_opt["sbd_path"] = {
        "getopt" : ":",
        "longopt" : "sbd-path",
        "help" : "--sbd-path=[path]              Path to SBD binary",
        "required" : "0",
        "default" : "/sbin/sbd",
        "order": 200
        }

def main():
    """Main function
    """
    # We need to define "no_password" otherwise we will be ask about it if
    # we don't provide any password.
    device_opt = ["no_password", "devices", "port", "method", "sbd_path"]

    # close stdout if we get interrupted
    atexit.register(atexit_handler)

    define_new_opts()

    all_opt["method"]["default"] = "cycle"
    all_opt["method"]["help"] = "-m, --method=[method]          Method to fence (onoff|cycle) (Default: cycle)"

    options = check_input(device_opt, process_input(device_opt))

    # fill the needed variables to generate metadata and help text output
    docs = {}
    docs["shortdesc"] = "Fence agent for sbd"
    docs["longdesc"] = "fence_sbd is I/O Fencing agent \
which can be used in environments where sbd can be used (shared storage)."
    docs["vendorurl"] = ""
    show_docs(options, docs)

    # We need to check if --devices is given and not empty.
    if not options.has_key("--devices"):
        fail_usage("No SBD devices specified. \
                At least one SBD device is required.")

    run_delay(options)

    # We need to check if the provided sbd_devices exists. We need to do
    # that for every given device.
    for device_path in parse_sbd_devices(options):
        logging.debug("check device \"%s\"", device_path)

        return_code = check_sbd_device(options, device_path)
        if PATH_NOT_EXISTS == return_code:
            logging.error("\"%s\" does not exist", device_path)
        elif PATH_NOT_BLOCK == return_code:
            logging.error("\"%s\" is not a valid block device", device_path)
        elif DEVICE_NOT_INIT == return_code:
            logging.error("\"%s\" is not initialized", device_path)
        elif DEVICE_INIT != return_code:
            logging.error("UNKNOWN error while checking \"%s\"", device_path)

        # If we get any error while checking the device we need to exit at this
        # point.
        if DEVICE_INIT != return_code:
            exit(return_code)

    # we check against the defined timeouts. If the pacemaker timeout is smaller
    # then that defined within sbd we should report this.
    power_timeout = int(options["--power-timeout"])
    sbd_msg_timeout = get_msg_timeout(options)
    if power_timeout <= sbd_msg_timeout:
        logging.warn("power timeout needs to be \
                greater then sbd message timeout")

    result = fence_action(\
                None, \
                options, \
                set_power_status, \
                get_power_status, \
                get_node_list, \
                reboot_cycle)

    sys.exit(result)

if __name__ == "__main__":
    main()