Python logger.log函数代码示例

    def add_community_conf(self, community_name,
                           ipv6=False, source="", oid="", read_only=True,
                           operator="unknown"):
        new_community_conf = {
            "community_name": community_name,
            "ipv6": ipv6,
            "source": source,
            "oid": oid,
            "read_only": read_only,
        }
        new_community_conf = self.community_conf_schema.validate(new_community_conf)

        with self.lock:
            snmp_conf = self._load_conf()
            community_list = snmp_conf["community_list"]

            # check duplicate
            for community_conf in community_list:
                if community_conf["community_name"] == community_name:
                    raise StorLeverError("Community (%s) Already exist" % community_name, 400)

            community_list.append(new_community_conf)

            # save new conf
            self._save_conf(snmp_conf)
            self._sync_to_system_conf(snmp_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "SNMP New Community (%s) is added by operator(%s)" %
                   (community_name, operator))

    def set_selinux_state(self, state, user="unknown"):
        state_str_to_int = {
            "enforcing": 1,
            "permissive": 0,
            "disabled": 0
        }
        param = state_str_to_int.get(state)
        if param is not None:
            old_state = check_output(["/usr/sbin/getenforce"]).lower().strip()
            if old_state != "disabled":
                check_output(["/usr/sbin/setenforce", str(param)])

        if not os.path.exists(SELINUX_CONF_DIR):
            os.makedirs(SELINUX_CONF_DIR)
        conf_path = os.path.join(SELINUX_CONF_DIR, SELINUX_CONF_FILE)
        conf = properties()
        conf.delete("SELINUX")
        conf.apply_to(conf_path)
        with open(conf_path, "r") as f:
            content = f.read()
        if content.endswith("\n") or len(content) == 0:
            content += "SELINUX=%s\n" % state
        else:
            content += "\nSELINUX=%s\n" % state
        with open(conf_path, "w") as f:
            f.write(content)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "selinux state is set to %s by user(%s)" %
                   (state, user))

    def append_export_conf(self, name, path="/", clients=[], operator="unkown"):

        if path != "" and not os.path.exists(path):
             raise StorLeverError("path(%s) does not exists" % (path), 400)

        new_export_point = {
            "name": name,
            "path": path,
            "clients": clients,
        }
        new_export_point = self.export_point_conf_schema.validate(new_export_point)

        with self.lock:
            nfs_conf = self._load_conf()

            # check duplication
            for point in nfs_conf["export_point_list"]:
                if path == point["path"]:
                    raise StorLeverError("export with path(%s) already in nfs export table" % (path), 400)
                if name == point["name"]:
                    raise StorLeverError("export with name(%s) already in nfs export table" % (name), 400)

            nfs_conf["export_point_list"].append(new_export_point)

            # save new conf
            self._save_conf(nfs_conf)
            self._sync_to_system_conf(nfs_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "NFS export with path(%s) config is added by operator(%s)" %
                   (path, operator))

    def delete(self, md_name):
        """
        Destroy a RAID device.

        WARNING This will zero the superblock of all members of the RAID array..

        CLI Example:

        .. code-block:: bash

        salt '*' raid.destroy /dev/md0
        """
        md = MD(md_name, self._lock)

        md_device  = _md_name_to_dev_file(md_name)

        stop_cmd = '/sbin/mdadm --stop {0}'.format(md_device)
        zero_cmd = '/sbin/mdadm --zero-superblock {0}'

        with self._lock:
            check_output(stop_cmd.split())
            for _, member in md.members.iteritems():
                try:
                    check_output(zero_cmd.format(member['device']).split())
                except StorLeverError:
                    logger.log(logging.WARNING, logger.LOG_TYPE_ERROR,
                               "Failed zero superblock of device {0}".format(md_device),
                               exc_info=True)
            self._update_mdadm_conf()
            self.refresh()
        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "MD {0} removed successfully".format(md_device))

 def grow_raid(self, device):
     grow_cmd = '/sbin/mdadm --grow {0} --raid-device={1}'.format(self.dev_file, device)
     with self._lock:
         check_output(grow_cmd.split())
     self.refresh()
     logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                "MD {0} grows successfully with block device {1}".format(self.dev_file, device))

 def add_component(self, device):
     add_cmd = '/sbin/mdadm {0} --add {1}'.format(self.dev_file, device)
     with self._lock:
         check_output(add_cmd.split())
     self.refresh()
     logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                "Block device {0} added to MD {1} successfully".format(device, self.dev_file))

    def set_export_conf(self, name, path=None, clients=None, operator="unkown"):

        if path is not None and path != "" and not os.path.exists(path):
             raise StorLeverError("path(%s) does not exists" % (path), 400)

        with self.lock:
            nfs_conf = self._load_conf()
            for index, point in enumerate(nfs_conf["export_point_list"]):
                if name == point["name"]:
                    break
            else:
                raise StorLeverError("export(%s) not found" % (name), 404)

            if path is not None:
                point["path"] = path
            if clients is not None:
                point["clients"] = clients

            nfs_conf["export_point_list"][index] = self.export_point_conf_schema.validate(point)

            # save new conf
            self._save_conf(nfs_conf)
            self._sync_to_system_conf(nfs_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "NFS export (name:%s) config is updated by operator(%s)" %
                   (name, operator))

    def set_ip_config(self, ip=None, netmask=None, gateway=None, user="unknown"):

        if ip is None:
            ip = self.conf.get("IPADDR", "")
        if netmask is None:
            netmask = self.conf.get("NETMASK", "")
        if gateway is None:
            gateway = self.conf.get("GATEWAY", "")

        self.conf["IPADDR"] = ip
        self.conf["NETMASK"] = netmask
        self.conf["GATEWAY"] = gateway
        self.conf["BOOTPROTO"] = "none"

        # write to config file
        self.conf.apply_to(self.conf_file_path)

        # restart this interface
        if self.ifconfig_interface.is_up():
            check_output([IFDOWN, self.name])
            check_output([IFUP, self.name])

        # log the operation
        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "Network interface (%s) is configured with (IP:%s, Netmask:%s, \
                 Gateway:%s) by user(%s)" %
                   (self.name, ip, netmask, gateway, user))

    def update_community_conf(self, community_name,
                              ipv6=None, source=None, oid=None, read_only=None,
                              operator="unknown"):
        with self.lock:
            snmp_conf = self._load_conf()
            community_list = snmp_conf["community_list"]
            update_comunity_index = 0
            for index, community_conf in enumerate(community_list):
                if community_conf["community_name"] == community_name:
                    update_comunity_index = index
                    break
            else:
                raise StorLeverError("Community (%s) Not Found" % (community_name), 404)

            community_conf = community_list[update_comunity_index]

            if ipv6 is not None:
                community_conf["ipv6"] = ipv6
            if source is not None:
                community_conf["source"] = source
            if oid is not None:
                community_conf["oid"] = oid
            if read_only is not None:
                community_conf["read_only"] = read_only

            community_list[update_comunity_index] = \
                self.community_conf_schema.validate(community_conf)

            # save new conf
            self._save_conf(snmp_conf)
            self._sync_to_system_conf(snmp_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "SNMP Community (%s) config is updated by operator(%s)" %
                   (community_name, operator))

    def set_mail_conf(self, config={}, operator="unkown", *args, **kwargs):
        if not isinstance(config, dict):
            raise StorLeverError("Parameter type error", 500)
        if len(config) == 0 and len(kwargs) == 0:
            return
        config.update(kwargs)

        with self.lock:
            mail_conf = self._load_conf()
            for name, value in config.items():
                if name in mail_conf and value is not None:
                    mail_conf[name] = value

            # check config conflict
            mail_conf = self.mail_conf_schema.validate(mail_conf)
            if mail_conf["smtp_server"] != "":
                if mail_conf["email_addr"] == "":
                    raise StorLeverError("email_addr cannot be empty if smtp_server exists", 400)
                if mail_conf["password"] == "":
                    raise StorLeverError("password cannot be empty if smtp_server exists", 400)

            # save new conf
            self._save_conf(mail_conf)
            self._sync_to_system_conf(mail_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "Mail config is updated by operator(%s)" %
                   (operator))

    def del_fs(self, fs_name, user="unknown"):
        """delete a filesystem from storlever

        the file would be deleted from the storlever's config file and
        would be unmount from linux system

        """
        with self.lock:
            fs_dict = self._load_conf()
            if fs_name not in fs_dict:
                raise StorLeverError("filesystem(%s) does not exist" % fs_name, 400)
            fs_conf = fs_dict[fs_name]
            del fs_dict[fs_name]

             #umount fs first. if it failed, don't delete it in the config
            self._umount_fs(fs_name, fs_conf)

            self._save_conf(fs_dict)
            self._sync_to_fstab(fs_dict)

        try:
            os.rmdir(fs_conf["mount_point"])
        except OSError as e:
            pass


        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "filesystem %s (dev:%s, mount_point:%s, option:%s) "
                   "is deleted by user(%s)" %
                   (fs_name, fs_conf['dev_file'],
                    fs_conf['mount_point'], fs_conf['mount_option'],
                    user))

    def logout(self, operator="unkown"):
        cmd = [ISCSIADM_CMD, "-m", "node","--logout", "-T", self.target, "-p", self.portal]

        outlines = check_output(cmd, input_ret=[2, 6, 7, 21, 22]).splitlines()
        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "iscsi initiator node (%s, %s) is logout by operator(%s)" %
                   (self.target, self.portal, operator))

    def set_agent_conf(self, config={}, operator="unkown", *args, **kwargs):
        if not isinstance(config, dict):
            raise StorLeverError("Parameter type error", 500)
        if len(config) == 0 and len(kwargs) == 0:
            return
        config.update(kwargs)
        not_allow_keys = (
            "active_check_server_list",
            "passive_check_server_list"
        )
        config = filter_dict(config, not_allow_keys, True)

        with self.lock:
            zabbix_agent_conf = self._load_conf()
            for name, value in config.items():
                if name in zabbix_agent_conf and value is not None:
                    zabbix_agent_conf[name] = value

            # check config conflict
            zabbix_agent_conf = self.zabbix_agentd_conf_schema.validate(zabbix_agent_conf)

            # save new conf
            self._save_conf(zabbix_agent_conf)
            self._sync_to_system_conf(zabbix_agent_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "Zabbix agent config is updated by operator(%s)" %
                   (operator))

    def add_monitor_conf(self, monitor_name, expression, option="",
                         operator="unknown"):

        new_monitor_conf = {
            "monitor_name": monitor_name,
            "expression": expression,
            "option": option,
        }
        new_monitor_conf = self.monitor_conf_schema.validate(new_monitor_conf)

        with self.lock:
            snmp_conf = self._load_conf()
            monitor_list = snmp_conf["monitor_list"]

            # check duplicate
            for monitor_conf in monitor_list:
                if monitor_conf["monitor_name"] == monitor_name:
                    raise StorLeverError("monitor_name (%s) Already exist" % monitor_name, 400)

            monitor_list.append(new_monitor_conf)

            # save new conf
            self._save_conf(snmp_conf)
            self._sync_to_system_conf(snmp_conf)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "SNMP New Monitor (%s) is added by operator(%s)" %
                   (monitor_name, operator))

    def quota_group_set(self, group,
                        block_softlimit=0,
                        block_hardlimit=0,
                        inode_softlimit=0,
                        inode_hardlimit=0,
                        operator="unknown"):
        if not self.is_available():
            raise StorLeverError("File system is unavailable", 500)
        setquota_agrs = [
            SETQUOTA_BIN,
            "-g",
            group,
            str(block_softlimit),
            str(block_hardlimit),
            str(inode_softlimit),
            str(inode_hardlimit),
            self.fs_conf["mount_point"]
        ]
        check_output(setquota_agrs)

        logger.log(logging.INFO, logger.LOG_TYPE_CONFIG,
                   "File System(%s) quota for group(%s) is changed to "
                   "(%d,%d,%d,%d)"
                   " by user(%s)" %
                   (self.name, group,
                    block_softlimit, block_hardlimit,
                    inode_softlimit, inode_hardlimit,
                    operator))