def is_running(self, **kwargs):
     service_name = self._get_sysvinit_name(**kwargs)
     arguments = [
                 'chkconfig',
                 service_name,
                 'status'
         ]
     utils.execute_local_command(arguments)

 def on_boot_disable(self, **kwargs):
     service_name = self._get_sysvinit_name(**kwargs)
     arguments = [
                 'chkconfig',
                 service_name,
                 'off'
         ]
     utils.execute_local_command(arguments)

 def restart(self, **kwargs):
     service_name = self._get_sysvinit_name(**kwargs)
     arguments = [
             'service',
             service_name,
             'restart'
         ]
     utils.execute_local_command(arguments)

def zap(dev = None, **kwargs):
    """
    Destroy the partition table and content of a given disk.
    """
    if dev is not None:
        log.warning("Depricated use of function, use kwargs")
    dev = kwargs.get("dev", dev)
    if dev == None:
        raise Error('Cannot find', dev)
    if not os.path.exists(dev):
        raise Error('Cannot find', dev)
    dmode = os.stat(dev).st_mode
    mdl = model.model(**kwargs)
    osdc = osd.osd_ctrl(mdl)
    if not stat.S_ISBLK(dmode) or osdc.is_partition(dev):
        raise Error('not full block device; cannot zap', dev)
    try:
        log.debug('Zapping partition table on %s', dev)

        # try to wipe out any GPT partition table backups.  sgdisk
        # isn't too thorough.
        lba_size = 4096
        size = 33 * lba_size
        with file(dev, 'wb') as dev_file:
            dev_file.seek(-size, os.SEEK_END)
            dev_file.write(size*'\0')

        utils.execute_local_command(
            [
                util_which.which_sgdisk.path,
                '--zap-all',
                '--',
                dev,
            ],
        )
        utils.execute_local_command(
            [
                util_which.which_sgdisk.path,
                '--clear',
                '--mbrtogpt',
                '--',
                dev,
            ],
        )


        _update_partition('-d', dev, 'zapped')
    except subprocess.CalledProcessError as e:
        raise Error(e)
    return True

def _update_partition(action, dev, description):
    # try to make sure the kernel refreshes the table.  note
    # that if this gets ebusy, we are probably racing with
    # udev because it already updated it.. ignore failure here.

    # On RHEL and CentOS distros, calling partprobe forces a reboot of the
    # server. Since we are not resizing partitons so we rely on calling
    # partx

    utils.execute_local_command(
        [
             constants._path_partprobe,
             dev,
        ],
    )

def retrive_osd_details(device_name):
    osd_details = {}
    if device_name is None:
        return None
    try:
        tmpd = tempfile.mkdtemp()
        try:
            out_mnt = utils.execute_local_command(['mount',device_name,tmpd])
            if out_mnt['retcode'] == 0:
                osd_details = _retrive_osd_details_from_dir(tmpd)
        finally:
            utils.execute_local_command(['umount',tmpd])
    finally:
        os.rmdir(tmpd)
    return osd_details

 def _execute(self,arguments):
     prefix = [
         "sudo",
         "-u",
         "ceph"
         ]
     return utils.execute_local_command(prefix + arguments)

    def auth_add(self, keyring_type):
        """
        Authorise keyring
        """
        keyringobj = keyring.keyring_facard(self.model)
        keyringobj.key_type = keyring_type


        if not keyringobj.present():
            raise Error("rgw keyring not found")
        q = mdl_query.mdl_query(self.model)
        if q.mon_is() and q.mon_quorum() is False:
            raise Error("mon daemon is not in quorum")
        arguments = [
                "ceph",
                "auth",
                "import",
                "-i",
                keyringobj.keyring_path_get()
                ]
        output = utils.execute_local_command(arguments)
        if output["retcode"] != 0:
            raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                        " ".join(arguments),
                        output["retcode"],
                        output["stdout"],
                        output["stderr"])
                        )
        return True

 def auth_del(self, **kwargs):
     """
     Remove Authorised keyring
     """
     self.model.kargs_apply(**kwargs)
     u = mdl_updater.model_updater(m)
     u.hostname_refresh()
     if m.cluster_name == None:
         u.defaults_refresh()
     self.cluster_name = m.cluster_name
     u.load_confg(m.cluster_name)
     u.mon_members_refresh()
     q = mdl_query.mdl_query(m)
     if not q.mon_is():
         raise Error("Not ruining a mon daemon")
     u.mon_status()
     if not q.mon_quorum():
         raise Error("mon daemon is not in quorum")
     arguments = [
             "ceph",
             "auth",
             "del",
             self.keyring_name
             ]
     cmd_out = utils.execute_local_command(arguments)
     return True

 def auth_add(self, **kwargs):
     """
     Authorise keyring
     """
     self.model.kargs_apply(**kwargs)
     u = mdl_updater.model_updater(self.model)
     u.hostname_refresh()
     if self.model.cluster_name == None:
         u.defaults_refresh()
     keyring_path = self.get_path_keyring()
     if not os.path.isfile(keyring_path):
         raise Error("rgw keyring not found")
     u.load_confg(self.model.cluster_name)
     u.mon_members_refresh()
     q = mdl_query.mdl_query(self.model)
     if not q.mon_is():
         raise Error("Not ruining a mon daemon")
     u.mon_status()
     if not q.mon_quorum():
         raise Error("mon daemon is not in quorum")
     arguments = [
             "ceph",
             "auth",
             "import",
             "-i",
             keyring_path
             ]
     cmd_out = utils.execute_local_command(arguments)
     return True

    def _pool_adder(self, name, **kwargs):
        pg_num = kwargs.get("pg_num", 8)
        pgp_num = kwargs.get("pgp_num", pg_num)
        pool_type = kwargs.get("pool_type")
        er_profile = kwargs.get("erasure_code_profile")
        crush_ruleset_name = kwargs.get("crush_ruleset")

        arguments = [
            'ceph',
            'osd',
            'pool',
            'create',
            name,
            str(pg_num)
            ]
        if pgp_num != None:
            arguments.append(str(pgp_num))
        if pool_type == "replicated":
            arguments.append("replicated")
        if pool_type == "erasure":
            arguments.append("erasure")
            arguments.append("erasure-code-profile=%s" % (er_profile))
        if crush_ruleset_name != None:
            arguments.append(crush_ruleset_name)
        output = utils.execute_local_command(arguments)
        if output["retcode"] != 0:
            raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                        " ".join(arguments),
                        output["retcode"],
                        output["stdout"],
                        output["stderr"]))

    def _remove_rgw_keyring(self):
        self._set_rgw_path_lib()
        if not os.path.isdir(self.rgw_path_lib):
            return
        rgw_path_keyring = os.path.join(self.rgw_path_lib, 'keyring')

        path_bootstrap_keyring = keyring._get_path_keyring_rgw(self.model.cluster_name)
        arguments = [
            'ceph',
            '--connect-timeout',
            '5',
            '--cluster', self.model.cluster_name,
            '--name', 'client.bootstrap-rgw',
            '--keyring', path_bootstrap_keyring,
            'auth', 'del', 'client.{name}'.format(name=self.rgw_name),
        ]

        output = utils.execute_local_command(arguments)
        if output["retcode"] != 0:
            raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                    " ".join(arguments),
                    output["retcode"],
                    output["stdout"],
                    output["stderr"])
                    )

    def activate_partition(self, partition, **kwargs):
        dmcrypt = kwargs.get("dmcrypt")
        dmcrypt_key_dir = kwargs.get("dmcrypt_key_dir")
        arguments = [
                'ceph-disk',
                '-v',
                'activate',
                '--mark-init',
                self.model.init,
                '--mount',
            ]
        if dmcrypt is not None:
            arguments.append("--dmcrypt")
        if dmcrypt_key_dir is not None:
            arguments.append("--dmcrypt-key-dir")
            arguments.append(dmcrypt_key_dir)
        arguments.append(partition)

        output = utils.execute_local_command(arguments)
        if output["retcode"] != 0:
                raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                    " ".join(arguments),
                    output["retcode"],
                    output["stdout"],
                    output["stderr"])
                    )
        return True

 def unmount_osd(self):
     for part in self.model.partitions_osd:
         disk = self.model.part_pairent.get(part)
         if disk is None:
             continue
         disk_details = self.model.lsblk.get(disk)
         if disk_details is None:
             continue
         all_parts = disk_details.get('PARTITION')
         if all_parts is None:
             continue
         part_details = all_parts.get(part)
         if part_details is None:
             continue
         mountpoint =  part_details.get("MOUNTPOINT")
         if mountpoint is None:
             continue
         arguments = [
             "umount",
             mountpoint
             ]
         output = utils.execute_local_command(arguments)
         if output["retcode"] != 0:
             raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                 " ".join(arguments),
                 output["retcode"],
                 output["stdout"],
                 output["stderr"]
                 ))

 def partition_table_refresh(self):
     for disk_name in self.model.lsblk.keys():
         arguments = [
             'parted',
             disk_name,
             'print'
             ]
         log.debug("Running:%s" % (" ".join(arguments)))
         output = utils.execute_local_command(arguments)
         if output["retcode"] != 0:
             raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                 " ".join(arguments),
                 output["retcode"],
                 output["stdout"],
                 output["stderr"]
                 ))
         part_type = None
         for line in output["stdout"].split('\n'):
             split_line = line.split(':')
             if split_line[0] != 'Partition Table':
                 continue
             part_type = ":".join(split_line[1:]).strip()
         if part_type is None:
             continue
         self.model.lsblk[disk_name]["PARTTABLE"] = part_type

 def ceph_version_refresh(self):
     arguments = [
         "ceph",
         "--version"
         ]
     output = utils.execute_local_command(arguments)
     if output["retcode"] != 0:
         raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                     " ".join(arguments),
                     output["retcode"],
                     output["stdout"],
                     output["stderr"]))
     version_raw = output["stdout"].strip()
     version_raw_split = shlex.split(version_raw)
     if len(version_raw_split) != 4:
         raise Error("ceph returned an invalid version:'%s' " % (version_raw))
     if version_raw_split[0] != "ceph":
         raise Error("ceph returned an invalid version first value is not ceph:'%s' " % (version_raw))
     if version_raw_split[1] != "version":
         raise Error("ceph returned an invalid version second value is not 'version':'%s' " % (version_raw))
     version_public_raw = version_raw_split[2]
     version_git_raw = version_raw_split[2]
     version_public = version_public_raw.split(".")
     if len(version_public) < 3:
         raise Error("ceph returned an invalid version second value is not 'version':'%s' " % (version_raw))
     self.model.ceph_version.major = int(version_public[0])
     self.model.ceph_version.minor = int(version_public[1])
     self.model.ceph_version.revision = ".".join(version_public[2:])
     self.model.ceph_version.uuid = version_raw_split[3].strip("()")

    def status_refresh(self):
        """
        Get the cluster status

        This is not normally needed as connect method has updated this information
        """
        prefix_arguments = [
            constants._path_ceph
        ]
        postfix_arguments = [
            "-f",
            "json-pretty",
            "status"
        ]
        connection_arguments = self.connection_arguments_get()
        arguments = prefix_arguments + connection_arguments + postfix_arguments
        output = utils.execute_local_command(arguments)

        if output["retcode"] != 0:
            raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                        " ".join(arguments),
                        output["retcode"],
                        output["stdout"],
                        output["stderr"])
                        )
        self.model.cluster_status = json.loads(output["stdout"].strip())

 def lsblk_version_refresh(self):
     """
     Get lsblk version as this is older on RHEL 7.2
     """
     arguments = [ constants._path_lsblk, "--version" ]
     output = utils.execute_local_command(arguments)
     if output["retcode"] != 0:
         raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
             " ".join(arguments),
             output["retcode"],
             output["stdout"],
             output["stderr"]
             ))
     version_str = output["stdout"].strip()
     version_list = shlex.split(version_str)
     if len(version_list) < 4:
         raise Error("Failed processing lsblk version string '%s'" % (version_str))
     version_split = version_list[3].split(".")
     self.model.lsblk_version.major = int(version_split[0])
     if len(version_split) > 1:
         self.model.lsblk_version.minor = int(version_split[1])
     if len(version_split) > 2:
         self.model.lsblk_version.revision = int(version_split[2])
     else:
         self.model.lsblk_version.revision = 0

 def _pool_adder(self, name, **kwargs):
     pg_num = kwargs.get("pg_num", 8)
     pgp_num = kwargs.get("pgp_num", pg_num)
     pool_type = kwargs.get("pool_type")
     er_profile = kwargs.get("erasure_code_profile")
     crush_ruleset_name = kwargs.get("crush_ruleset")
     prefix_arguments = [
         constants._path_ceph
     ]
     postfix_arguments = [
         'osd',
         'pool',
         'create',
         name,
         str(pg_num)
         ]
     connection_arguments = self.connection_arguments_get()
     arguments = prefix_arguments + connection_arguments + postfix_arguments
     if pgp_num is not None:
         arguments.append(str(pgp_num))
     if pool_type == "replicated":
         arguments.append("replicated")
     if pool_type == "erasure":
         arguments.append("erasure")
         arguments.append("erasure-code-profile=%s" % (er_profile))
     if crush_ruleset_name is not None:
         arguments.append(crush_ruleset_name)
     output = utils.execute_local_command(arguments)
     if output["retcode"] != 0:
         raise Error("Failed executing '%s' Error rc=%s, stdout=%s stderr=%s" % (
                     " ".join(arguments),
                     output["retcode"],
                     output["stdout"],
                     output["stderr"]))

 def connect(self):
     keyring_obj = keyring.keyring_facard(self.model)
     for keytype in ["admin", "osd", "mds", "rgw", "mon"]:
         log.debug("Trying keyring:%s" % (keytype))
         keyring_obj.key_type = keytype
         keyring_path = keyring_obj.keyring_path_get()
         if not os.path.isfile(keyring_path):
             log.debug("Skipping keyring %s" % (keyring_path))
             continue
         keyring_identity = keyring_obj.keyring_identity_get()
         arguments = [
             constants._path_ceph,
             '--connect-timeout',
             '5',
             "--keyring",
             keyring_path,
             "--name",
             keyring_identity,
             "-f",
             "json-pretty",
             "status"
         ]
         output = utils.execute_local_command(arguments)
         if output["retcode"] != 0:
             continue
         self.model.cluster_status = json.loads(output["stdout"].strip())
         self.keyring_type = keytype
         self.keyring_path = keyring_path
         self.keyring_identity = keyring_identity
         return True
     return False