Merge ~lucaskanashiro/ubuntu/+source/fence-agents:backport_ibmz_agent_bionic into ubuntu/+source/fence-agents:ubuntu/bionic-devel

[Lucas Kanashiro]

Backport IBM LPAR fence agent (LP: #1889070). The intent of this MP is reviewing the work done so far before sharing a PPA containing the proposed package with IBM for testing. Due to that, the SRU paperwork is not done yet, when we get an approval from IBM I will do that.

PPA:

https://launchpad.net/~lucaskanashiro/+archive/ubuntu/ha-stack-ibm

autopkgtest result:

autopkgtest [12:09:31]: @@@@@@@@@@@@@@@@@@@@ summary
fence-dummy PASS

[Christian Ehrhardt  (paelzer)]

If we disable the test (which is ok) why do we backport and then carry tests/data/metadata/fence_ibmz.xml ?
Maybe not adding this test xml allows you to even not need to skip it?

If we update doc/COPYRIGHT don't we also need to update d/cpyright?
I'm not good on those licensing things, but it comes to mind seeing to touch one but not the other.

Maybe add on the patch header notes for the backport:
- dropped .spec because ...
- dropped test because ...

The rest looks like a good SRU, while it adds new features that should be ok as it is for HW exploitation. And in addition it just adds one other agent not touching (=regressing) the others.

review: Needs Fixing

[Lucas Kanashiro (lucaskanashiro)]

Thanks for the review Christian.

I tried to backport the very same commit from upstream without changes but I believe you are right regarding the test, we can drop it and add a note. About the copyright change, in my opinion, we should keep it and as you mentioned advertise it in d/copyright as well. Does that sound good to you?

[Christian Ehrhardt  (paelzer)]

> I tried to backport the very same commit from upstream without changes but I believe you are right regarding the test, we can drop it and add a note. About the copyright change, in my opinion, we should keep it and as you mentioned advertise it in d/copyright as well. Does that sound good to you?

yes, WFM

[Lucas Kanashiro (lucaskanashiro)]

The package was tested by IBM and it was uploaded:

$ git push pkg upload/4.0.25-2ubuntu1.3
Enumerating objects: 26, done.
Counting objects: 100% (26/26), done.
Delta compression using up to 32 threads
Compressing objects: 100% (19/19), done.
Writing objects: 100% (19/19), 8.28 KiB | 2.07 MiB/s, done.
Total 19 (delta 13), reused 0 (delta 0)
To ssh://git.launchpad.net/ubuntu/+source/fence-agents
 * [new tag] upload/4.0.25-2ubuntu1.3 -> upload/4.0.25-2ubuntu1.3
 dput ubuntu ../fence-agents_4.0.25-2ubuntu1.3_source.changes
Checking signature on .changes
gpg: ../fence-agents_4.0.25-2ubuntu1.3_source.changes: Valid signature from F823A2729883C97C
Checking signature on .dsc
gpg: ../fence-agents_4.0.25-2ubuntu1.3.dsc: Valid signature from F823A2729883C97C
Uploading to ubuntu (via ftp to upload.ubuntu.com):
  Uploading fence-agents_4.0.25-2ubuntu1.3.dsc: done.
  Uploading fence-agents_4.0.25-2ubuntu1.3.debian.tar.xz: done.
  Uploading fence-agents_4.0.25-2ubuntu1.3_source.changes: done.
Successfully uploaded packages.

review: Approve

diff --git a/debian/changelog b/debian/changelog
index 7412a79..568d5d5 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,14 @@
+fence-agents (4.0.25-2ubuntu1.3) bionic; urgency=medium
+
+  * Backport upstream patch to add agent for IBM z LPARs (LP: #1889070).
+    - d/p/0013-Add-fence-agent-for-IBM-z-LPARs.patch
+    - d/copyright: add the IBM z LPARs agent.
+    - d/rules: skip fence_ibmz in dh_auto_test. The test metadata file was
+      removed from the upstream patch and it makes "make check" fail for
+      fence_ibmz.
+
+ -- Lucas Kanashiro <[e-mail]>  Wed, 10 Feb 2021 16:39:54 -0300
+
 fence-agents (4.0.25-2ubuntu1.2) bionic; urgency=medium
 
   * fence_aws backport from Focal (LP: #1894323):
diff --git a/debian/copyright b/debian/copyright
index a70b5d8..ba34532 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -19,6 +19,17 @@ License: GPL-2+
  On Debian systems, the complete text of the GNU General
  Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
  
+License: LGPL-2.1+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+ .
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
 Files: debian/*
 Copyright: 2011 Andres Rodriguez <[e-mail]>
 License: GPL-2+
@@ -53,16 +64,11 @@ License: GPL-2+
 Files: fence/agents/zvm/fence_zvm.*
 Copyright: (C) 2012 Sine Nomine Associates
 License: LGPL-2.1+
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
- .
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Lesser General Public License for more details.
 
 Files: fence/man/fence_ifmib.8
 Copyright: 2008 Ross Vandegrift
 License: GPL-2+
+
+Files: fence/agents/ibmz/fence_ibmz.py
+Copyright: 2020 IBM Corp.
+License: LGPL-2.1+
diff --git a/debian/patches/0013-Add-fence-agent-for-IBM-z-LPARs.patch b/debian/patches/0013-Add-fence-agent-for-IBM-z-LPARs.patch
new file mode 100644
index 0000000..113fa1f
--- /dev/null
+++ b/debian/patches/0013-Add-fence-agent-for-IBM-z-LPARs.patch
@@ -0,0 +1,587 @@
+From: Paulo de Rezende Pinatti <[e-mail]>
+Date: Thu, 16 Jul 2020 21:37:12 +0200
+Subject: Add fence agent for IBM z LPARs
+
+This agent manages IBM z LPARs via the HMC Web Services
+REST API.
+
+Signed-off-by: Paulo de Rezende Pinatti <[e-mail]>
+
+Origin: backport, https://github.com/ClusterLabs/fence-agents/commit/74d415bf
+Bug-Ubuntu: https://bugs.launchpad.net/ubuntu-z-systems/+bug/1889070
+Reviewed-By: Lucas Kanashiro <[e-mail]>
+
+The addition of test/data/metadata/fence_ibmz.xml was dropped because it does
+not work during build time, it tries to connect to non-localhost. The changes
+made to the fence-agensts.spec.in were also removed since here we do not care
+about RPM packages.
+
+---
+ doc/COPYRIGHT                      |   4 +
+ fence/agents/ibmz/fence_ibmz.py    | 542 +++++++++++++++++++++++++++++++++++++
+ 2 files changed, 546 insertions(+)
+ create mode 100644 fence/agents/ibmz/fence_ibmz.py
+
+diff --git a/doc/COPYRIGHT b/doc/COPYRIGHT
+index 8124c53..f1e8353 100644
+--- a/doc/COPYRIGHT
++++ b/doc/COPYRIGHT
+@@ -5,6 +5,10 @@ Copyright (C) 2004-2011 Red Hat, Inc.  All rights reserved.
+ 
+ Exceptions:
+ 
++fence/agents/ibmz/*:
++ Copyright (c) 2020 IBM Corp.
++ Contributed by Paulo de Rezende Pinatti <ppinatti at linux.ibm.com>
++
+ fence/agents/hds_cb/*:
+  Copyright (C) 2012 Matthew Clark.
+  Author: Matthew Clark <mattjclark0407 at hotmail.com>
+diff --git a/fence/agents/ibmz/fence_ibmz.py b/fence/agents/ibmz/fence_ibmz.py
+new file mode 100644
+index 0000000..d3ac550
+--- /dev/null
++++ b/fence/agents/ibmz/fence_ibmz.py
+@@ -0,0 +1,542 @@
++#!@PYTHON@ -tt
++
++# Copyright (c) 2020 IBM Corp.
++#
++# This library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# This library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with this library.  If not, see
++# <http://www.gnu.org/licenses/>.
++
++import atexit
++import logging
++import time
++import sys
++
++import requests
++from requests.packages import urllib3
++
++sys.path.append("@FENCEAGENTSLIBDIR@")
++from fencing import *
++from fencing import fail_usage, run_delay, EC_GENERIC_ERROR
++
++DEFAULT_POWER_TIMEOUT = '300'
++ERROR_NOT_FOUND = ("{obj_type} {obj_name} not found in this HMC. "
++                   "Attention: names are case-sensitive.")
++
++class ApiClientError(Exception):
++    """
++    Base exception for all API Client related errors.
++    """
++
++class ApiClientRequestError(ApiClientError):
++    """
++    Raised when an API request ends in error
++    """
++
++    def __init__(self, req_method, req_uri, status, reason, message):
++        self.req_method = req_method
++        self.req_uri = req_uri
++        self.status = status
++        self.reason = reason
++        self.message = message
++        super(ApiClientRequestError, self).__init__()
++
++    def __str__(self):
++        return (
++            "API request failed, details:\n"
++            "HTTP Request : {req_method} {req_uri}\n"
++            "HTTP Response status: {status}\n"
++            "Error reason: {reason}\n"
++            "Error message: {message}\n".format(
++                req_method=self.req_method, req_uri=self.req_uri,
++                status=self.status, reason=self.reason, message=self.message)
++        )
++
++class APIClient(object):
++    DEFAULT_CONFIG = {
++        # how many connection-related errors to retry on
++        'connect_retries': 3,
++        # how many times to retry on read errors (after request was sent to the
++        # server)
++        'read_retries': 3,
++        # http methods that should be retried
++        'method_whitelist': ['HEAD', 'GET', 'OPTIONS'],
++        # limit of redirects to perform to avoid loops
++        'redirect': 5,
++        # how long to wait while establishing a connection
++        'connect_timeout': 30,
++        # how long to wait for asynchronous operations (jobs) to complete
++        'operation_timeout': 900,
++        # how long to wait between bytes sent by the remote side
++        'read_timeout': 300,
++        # default API port
++        'port': 6794,
++        # validate ssl certificates
++        'ssl_verify': False
++    }
++    LABEL_BY_OP_MODE = {
++        'classic': {
++            'nodes': 'logical-partitions',
++            'state-on': 'operating',
++            'start': 'load',
++            'stop': 'deactivate'
++        },
++        'dpm': {
++            'nodes': 'partitions',
++            'state-on': 'active',
++            'start': 'start',
++            'stop': 'stop'
++        }
++    }
++    def __init__(self, host, user, passwd, config=None):
++        self.host = host
++        if not passwd:
++            raise ValueError('Password cannot be empty')
++        self.passwd = passwd
++        if not user:
++            raise ValueError('Username cannot be empty')
++        self.user = user
++        self._cpc_cache = {}
++        self._session = None
++        self._config = self.DEFAULT_CONFIG.copy()
++        # apply user defined values
++        if config:
++            self._config.update(config)
++
++    def _create_session(self):
++        """
++        Create a new requests session and apply config values
++        """
++        session = requests.Session()
++        retry_obj = urllib3.Retry(
++            # setting a total is necessary to cover SSL related errors
++            total=max(self._config['connect_retries'],
++                      self._config['read_retries']),
++            connect=self._config['connect_retries'],
++            read=self._config['read_retries'],
++            method_whitelist=self._config['method_whitelist'],
++            redirect=self._config['redirect']
++        )
++        session.mount('http://', requests.adapters.HTTPAdapter(
++            max_retries=retry_obj))
++        session.mount('https://', requests.adapters.HTTPAdapter(
++            max_retries=retry_obj))
++        return session
++
++    def _get_mode_labels(self, cpc):
++        """
++        Return the map of labels that corresponds to the cpc operation mode
++        """
++        if self.is_dpm_enabled(cpc):
++            return self.LABEL_BY_OP_MODE['dpm']
++        return self.LABEL_BY_OP_MODE['classic']
++
++    def _partition_switch_power(self, cpc, partition, action):
++        """
++        Perform the API request to start (power on) or stop (power off) the
++        target partition and wait for the job to finish.
++        """
++        # retrieve partition's uri
++        label_map = self._get_mode_labels(cpc)
++        resp = self._request('get', '{}/{}?name={}'.format(
++            self._cpc_cache[cpc]['object-uri'], label_map['nodes'], partition))
++
++        if not resp[label_map['nodes']]:
++            raise ValueError(ERROR_NOT_FOUND.format(
++                obj_type='LPAR/Partition', obj_name=partition))
++
++        part_uri = resp[label_map['nodes']][0]['object-uri']
++
++        # in dpm mode the request must have empty body
++        if self.is_dpm_enabled(cpc):
++            body = None
++        # in classic mode we make sure the operation is executed
++        # even if the partition is already on
++        else:
++            body = {'force': True}
++            # when powering on the partition must be activated first
++            if action == 'start':
++                op_uri = '{}/operations/activate'.format(part_uri)
++                job_resp = self._request(
++                    'post', op_uri, body=body, valid_codes=[202])
++                # always wait for activate otherwise the load (start)
++                # operation will fail
++                if self._config['operation_timeout'] == 0:
++                    timeout = self.DEFAULT_CONFIG['operation_timeout']
++                else:
++                    timeout = self._config['operation_timeout']
++                logging.debug(
++                    'waiting for activate (timeout %s secs)', timeout)
++                self._wait_for_job('post', op_uri, job_resp['job-uri'],
++                                   timeout=timeout)
++
++        # trigger the start job
++        op_uri = '{}/operations/{}'.format(part_uri, label_map[action])
++        job_resp = self._request('post', op_uri, body=body, valid_codes=[202])
++        if self._config['operation_timeout'] == 0:
++            return
++        logging.debug('waiting for %s (timeout %s secs)',
++                      label_map[action], self._config['operation_timeout'])
++        self._wait_for_job('post', op_uri, job_resp['job-uri'],
++                           timeout=self._config['operation_timeout'])
++
++    def _request(self, method, uri, body=None, headers=None, valid_codes=None):
++        """
++        Perform a request to the HMC API
++        """
++        assert method in ('delete', 'head', 'get', 'post', 'put')
++
++        url = 'https://{host}:{port}{uri}'.format(
++            host=self.host, port=self._config['port'], uri=uri)
++        if not headers:
++            headers = {}
++
++        if self._session is None:
++            raise ValueError('You need to log on first')
++        method = getattr(self._session, method)
++        timeout = (
++            self._config['connect_timeout'], self._config['read_timeout'])
++        response = method(url, json=body, headers=headers,
++                          verify=self._config['ssl_verify'], timeout=timeout)
++
++        if valid_codes and response.status_code not in valid_codes:
++            reason = '(no reason)'
++            message = '(no message)'
++            if response.headers.get('content-type') == 'application/json':
++                try:
++                    json_resp = response.json()
++                except ValueError:
++                    pass
++                else:
++                    reason = json_resp.get('reason', reason)
++                    message = json_resp.get('message', message)
++            else:
++                message = '{}...'.format(response.text[:500])
++            raise ApiClientRequestError(
++                response.request.method, response.request.url,
++                response.status_code, reason, message)
++
++        if response.status_code == 204:
++            return dict()
++        try:
++            json_resp = response.json()
++        except ValueError:
++            raise ApiClientRequestError(
++                response.request.method, response.request.url,
++                response.status_code, '(no reason)',
++                'Invalid JSON content in response')
++
++        return json_resp
++
++    def _update_cpc_cache(self, cpc_props):
++        self._cpc_cache[cpc_props['name']] = {
++            'object-uri': cpc_props['object-uri'],
++            'dpm-enabled': cpc_props.get('dpm-enabled', False)
++        }
++
++    def _wait_for_job(self, req_method, req_uri, job_uri, timeout):
++        """
++        Perform API requests to check for job status until it has completed
++        or the specified timeout is reached
++        """
++        op_timeout = time.time() + timeout
++        while time.time() < op_timeout:
++            job_resp = self._request("get", job_uri)
++            if job_resp['status'] == 'complete':
++                if job_resp['job-status-code'] in (200, 201, 204):
++                    return
++                raise ApiClientRequestError(
++                    req_method, req_uri,
++                    job_resp.get('job-status-code', '(no status)'),
++                    job_resp.get('job-reason-code', '(no reason)'),
++                    job_resp.get('job-results', {}).get(
++                        'message', '(no message)')
++                )
++            time.sleep(1)
++        raise ApiClientError('Timed out while waiting for job completion')
++
++    def cpc_list(self):
++        """
++        Return a list of CPCs in the format {'name': 'cpc-name', 'status':
++        'operating'}
++        """
++        list_resp = self._request("get", "/api/cpcs", valid_codes=[200])
++        ret = []
++        for cpc_props in list_resp['cpcs']:
++            self._update_cpc_cache(cpc_props)
++            ret.append({
++                'name': cpc_props['name'], 'status': cpc_props['status']})
++        return ret
++
++    def is_dpm_enabled(self, cpc):
++        """
++        Return True if CPC is in DPM mode, False for classic mode
++        """
++        if cpc in self._cpc_cache:
++            return self._cpc_cache[cpc]['dpm-enabled']
++        list_resp = self._request("get", "/api/cpcs?name={}".format(cpc),
++                                  valid_codes=[200])
++        if not list_resp['cpcs']:
++            raise ValueError(ERROR_NOT_FOUND.format(
++                obj_type='CPC', obj_name=cpc))
++        self._update_cpc_cache(list_resp['cpcs'][0])
++        return self._cpc_cache[cpc]['dpm-enabled']
++
++    def logon(self):
++        """
++        Open a session with the HMC API and store its ID
++        """
++        self._session = self._create_session()
++        logon_body = {"userid": self.user, "password": self.passwd}
++        logon_resp = self._request("post", "/api/sessions", body=logon_body,
++                                   valid_codes=[200, 201])
++        self._session.headers["X-API-Session"] = logon_resp['api-session']
++
++    def logoff(self):
++        """
++        Close/delete the HMC API session
++        """
++        if self._session is None:
++            return
++        self._request("delete", "/api/sessions/this-session",
++                      valid_codes=[204])
++        self._cpc_cache = {}
++        self._session = None
++
++    def partition_list(self, cpc):
++        """
++        Return a list of partitions in the format {'name': 'part-name',
++        'status': 'on'}
++        """
++        label_map = self._get_mode_labels(cpc)
++        list_resp = self._request('get', '{}/{}'.format(
++            self._cpc_cache[cpc]['object-uri'], label_map['nodes']))
++        status_map = {label_map['state-on']: 'on'}
++        return [{'name': part['name'],
++                 'status': status_map.get(part['status'].lower(), 'off')}
++                for part in list_resp[label_map['nodes']]]
++
++    def partition_start(self, cpc, partition):
++        """
++        Power on a partition
++        """
++        self._partition_switch_power(cpc, partition, 'start')
++
++    def partition_status(self, cpc, partition):
++        """
++        Return the current status of a partition (on or off)
++        """
++        label_map = self._get_mode_labels(cpc)
++
++        resp = self._request('get', '{}/{}?name={}'.format(
++            self._cpc_cache[cpc]['object-uri'], label_map['nodes'], partition))
++        if not resp[label_map['nodes']]:
++            raise ValueError(ERROR_NOT_FOUND.format(
++                obj_type='LPAR/Partition', obj_name=partition))
++        part_props = resp[label_map['nodes']][0]
++        if part_props['status'].lower() == label_map['state-on']:
++            return 'on'
++        return 'off'
++
++    def partition_stop(self, cpc, partition):
++        """
++        Power off a partition
++        """
++        self._partition_switch_power(cpc, partition, 'stop')
++
++def parse_plug(options):
++    """
++    Extract cpc and partition from specified plug value
++    """
++    try:
++        cpc, partition = options['--plug'].strip().split('/', 1)
++    except ValueError:
++        fail_usage('Please specify nodename in format cpc/partition')
++    cpc = cpc.strip()
++    if not cpc or not partition:
++        fail_usage('Please specify nodename in format cpc/partition')
++    return cpc, partition
++
++def get_power_status(conn, options):
++    logging.debug('executing get_power_status')
++    status = conn.partition_status(*parse_plug(options))
++    return status
++
++def set_power_status(conn, options):
++    logging.debug('executing set_power_status')
++    if options['--action'] == 'on':
++        conn.partition_start(*parse_plug(options))
++    elif options['--action'] == 'off':
++        conn.partition_stop(*parse_plug(options))
++    else:
++        fail_usage('Invalid action {}'.format(options['--action']))
++
++def get_outlet_list(conn, options):
++    logging.debug('executing get_outlet_list')
++    result = {}
++    for cpc in conn.cpc_list():
++        for part in conn.partition_list(cpc['name']):
++            result['{}/{}'.format(cpc['name'], part['name'])] = (
++                part['name'], part['status'])
++    return result
++
++def disconnect(conn):
++    """
++    Close the API session
++    """
++    try:
++        conn.logoff()
++    except Exception as exc:
++        logging.exception('Logoff failed: ')
++        sys.exit(str(exc))
++
++def set_opts():
++    """
++    Define the options supported by this agent
++    """
++    device_opt = [
++        "ipaddr",
++        "ipport",
++        "login",
++        "passwd",
++        "port",
++        "connect_retries",
++        "connect_timeout",
++        "operation_timeout",
++        "read_retries",
++        "read_timeout",
++        "ssl_secure",
++    ]
++
++    all_opt["ipport"]["default"] = APIClient.DEFAULT_CONFIG['port']
++    all_opt["power_timeout"]["default"] = DEFAULT_POWER_TIMEOUT
++    port_desc = ("Physical plug id in the format cpc-name/partition-name "
++                 "(case-sensitive)")
++    all_opt["port"]["shortdesc"] = port_desc
++    all_opt["port"]["help"] = (
++        "-n, --plug=[id]                {}".format(port_desc))
++    all_opt["connect_retries"] = {
++        "getopt" : ":",
++        "longopt" : "connect-retries",
++        "help" : "--connect-retries=[number]     How many times to "
++                 "retry on connection errors",
++        "default" : APIClient.DEFAULT_CONFIG['connect_retries'],
++        "type" : "integer",
++        "required" : "0",
++        "shortdesc" : "How many times to retry on connection errors",
++        "order" : 2
++    }
++    all_opt["read_retries"] = {
++        "getopt" : ":",
++        "longopt" : "read-retries",
++        "help" : "--read-retries=[number]        How many times to "
++                 "retry on errors related to reading from server",
++        "default" : APIClient.DEFAULT_CONFIG['read_retries'],
++        "type" : "integer",
++        "required" : "0",
++        "shortdesc" : "How many times to retry on read errors",
++        "order" : 2
++    }
++    all_opt["connect_timeout"] = {
++        "getopt" : ":",
++        "longopt" : "connect-timeout",
++        "help" : "--connect-timeout=[seconds]    How long to wait to "
++                 "establish a connection",
++        "default" : APIClient.DEFAULT_CONFIG['connect_timeout'],
++        "type" : "second",
++        "required" : "0",
++        "shortdesc" : "How long to wait to establish a connection",
++        "order" : 2
++    }
++    all_opt["operation_timeout"] = {
++        "getopt" : ":",
++        "longopt" : "operation-timeout",
++        "help" : "--operation-timeout=[seconds]  How long to wait for "
++                 "power operation to complete (0 = do not wait)",
++        "default" : APIClient.DEFAULT_CONFIG['operation_timeout'],
++        "type" : "second",
++        "required" : "0",
++        "shortdesc" : "How long to wait for power operation to complete",
++        "order" : 2
++    }
++    all_opt["read_timeout"] = {
++        "getopt" : ":",
++        "longopt" : "read-timeout",
++        "help" : "--read-timeout=[seconds]       How long to wait "
++                 "to read data from server",
++        "default" : APIClient.DEFAULT_CONFIG['read_timeout'],
++        "type" : "second",
++        "required" : "0",
++        "shortdesc" : "How long to wait for server data",
++        "order" : 2
++    }
++    return device_opt
++
++def main():
++    """
++    Agent entry point
++    """
++    # register exit handler used by pacemaker
++    atexit.register(atexit_handler)
++
++    # prepare accepted options
++    device_opt = set_opts()
++
++    # parse options provided on input
++    options = check_input(device_opt, process_input(device_opt))
++
++    docs = {
++        "shortdesc": "Fence agent for IBM z LPARs",
++        "longdesc": (
++            "fence_ibmz is a power fencing agent which uses the HMC Web "
++            "Services API to fence IBM z LPARs."),
++        "vendorurl": "http://www.ibm.com"
++    }
++    show_docs(options, docs)
++
++    run_delay(options)
++
++    # set underlying library's logging and ssl config according to specified
++    # options
++    requests_log = logging.getLogger("urllib3")
++    requests_log.propagate = True
++    if "--verbose" in options:
++        requests_log.setLevel(logging.DEBUG)
++    if "--ssl-secure" not in options:
++        urllib3.disable_warnings(
++            category=urllib3.exceptions.InsecureRequestWarning)
++
++    hmc_address = options["--ip"]
++    hmc_userid = options["--username"]
++    hmc_password = options["--password"]
++    config = {
++        'connect_retries': int(options['--connect-retries']),
++        'read_retries': int(options['--read-retries']),
++        'operation_timeout': int(options['--operation-timeout']),
++        'connect_timeout': int(options['--connect-timeout']),
++        'read_timeout': int(options['--read-timeout']),
++        'port': int(options['--ipport']),
++        'ssl_verify': bool('--ssl-secure' in options),
++    }
++    try:
++        conn = APIClient(hmc_address, hmc_userid, hmc_password, config)
++        conn.logon()
++        atexit.register(disconnect, conn)
++        result = fence_action(conn, options, set_power_status,
++                              get_power_status, get_outlet_list)
++    except Exception:
++        logging.exception('Exception occurred: ')
++        result = EC_GENERIC_ERROR
++    sys.exit(result)
++
++if __name__ == "__main__":
++    main()
diff --git a/debian/patches/series b/debian/patches/series
index df80fa4..075cb3b 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -10,3 +10,4 @@ lp1865523-05-fence_scsi-fix-python3-encoding.patch
 lp1865523-06-fence_scsi-fixes-around-node-id.patch
 lp1865523-07-fence-metadata-update.xml
 lp1894323-01-fence_aws-new-agent.patch
+0013-Add-fence-agent-for-IBM-z-LPARs.patch
diff --git a/debian/rules b/debian/rules
index 551e252..3d92f95 100755
--- a/debian/rules
+++ b/debian/rules
@@ -47,7 +47,7 @@ override_dh_missing:
 
 override_dh_auto_test:
 	# disable testing for ovh as it tries to access SOAP service on www.ovh.com
-	dh_auto_test -- TEST_TARGET_SKIP=ovh/fence_ovh
+	dh_auto_test -- TEST_TARGET_SKIP="ovh/fence_ovh ibmz/fence_ibmz"
 
 override_dh_python2:
 	dh_python2