byp4a55 professor6T9

Linux SamCT211 4.4.302+ #86009 SMP Wed Nov 26 18:19:20 CST 2025 x86_64
nginx/1.23.1
192.168.4.211

File Name : logcenter.py

#!/usr/bin/python3

import os
import subprocess
from configparser import ConfigParser
from io import StringIO
import json
import importlib.util
from os.path import dirname, basename, exists

local_sub_gen_spec = importlib.util.spec_from_file_location('local_sub_gen_module', '/usr/syno/lib/synosyslog/subgens/local.py')
local_sub_gen_module = importlib.util.module_from_spec(local_sub_gen_spec)
local_sub_gen_spec.loader.exec_module(local_sub_gen_module)

KEY_LOG_CENTER = 'log-center'
CLIENT_MAX_SIZE = 2

def validate_synolog_conf(synolog_conf):
    if KEY_LOG_CENTER not in synolog_conf.conf:
        return True

return Facility.validate(synolog_conf, KEY_LOG_CENTER)

def generate_syslog_ng_conf(synolog_conf):
    gen_classes = generate_syslog_ng_conf_in_log_center(synolog_conf)
    confs = []
    for gen_class in gen_classes:
        try:
            gen_obj = gen_class(synolog_conf)
            confs.extend(gen_obj.gen())
        except LogCenterError:
            continue

return confs

def generate_syslog_ng_conf_in_log_center(synolog_conf):
    if not synolog_conf.is_key_enabled(KEY_LOG_CENTER):
        return []
    if HCI.is_support():
        return []
    elif not Systemctl.is_unit_up('pkgctl-LogCenter') or not Systemctl.is_unit_up('pkg-LogCenter-syslog'):
        return [Notify]
    if FSDN.is_support():
        return [Notify, ClientToRemote]
    # XXX: remove me after depending on DSM 7.3
    elif not exists('/etc.defaults/syslog-ng/syno.d/base.conf'):
        return [Notify, ClientToRemote, Archive]
    else:
        return [Notify, ClientToRemote, Archive, Receiver]

class LogCenterError(Exception):
    pass

class Setting(object):
    def __init__(self, path, sectionless=False):
        try:
            if not sectionless:
                self._setting = self._load_normal(path)
            else:
                self._setting = self._load_sectionless(path)
        except IOError:
            raise LogCenterError()

def get(self, *args):
        if len(args) == 2:
            section = args[0]
            key = args[1]
            return self._get_normal(section, key)
        if len(args) == 1:
            key = args[0]
            return self._get_sectionless(key)
        raise Exception('never here')

def has(self, *args):
        if len(args) == 2:
            section = args[0]
            key = args[1]
            return self._has_normal(section, key)
        if len(args) == 1:
            key = args[0]
            return self._has_sectionless(key)
        raise Exception('never here')

def sections(self):
        return self._setting.sections()

def _load_normal(self, path):
        setting = ConfigParser()
        with open(path) as f:
            setting.read_file(f)
        return setting

def _load_sectionless(self, path):
        setting = ConfigParser()
        io = StringIO()

with open(path) as f:
            io.write('[{}]\n'.format(Setting.DUMMY_SECTION))
            io.write(f.read())
            io.seek(0, os.SEEK_SET)

setting.read_file(io)

return setting

def _get_normal(self, section, key):
        value = self._setting.get(section, key)
        value = value.strip('"')
        return value

def _get_sectionless(self, key):
        return self._get_normal(Setting.DUMMY_SECTION, key)

def _has_normal(self, section, key):
        return self._setting.has_option(section, key)

def _has_sectionless(self, key):
        return self._has_normal(Setting.DUMMY_SECTION, key)

DUMMY_SECTION = 'dummy_section'

class Base(object):
    def __init__(self, synolog_conf):
        self.synolog_conf = synolog_conf
        self.app_id = synolog_conf.app_id
        self.path = synolog_conf.path
        self.facility = Facility.get(synolog_conf, KEY_LOG_CENTER)

def gen(self):
        raise Exception('not implemented')

class Command(object):
    @staticmethod
    def run(command, stderr=True):
        popen = subprocess.Popen(
            command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        out, err = popen.communicate()
        if not stderr:
            return out.strip()
        return out.strip() + err.strip()

class Systemctl(object):
    @staticmethod
    def is_unit_up(unit_name):
        output = Command.run(
            ['/usr/syno/bin/synosystemctl', 'get-active-status', unit_name]).decode()
        unit_up = output == 'active' or output == 'activating' or output == 'reloading'
        if not unit_up:
            print('INFO: systemd unit "{}" is not up: {}'.format(unit_name, output))
        return unit_up

class Notify(Base):
    def gen(self):
        confs = []

if not Systemctl.is_unit_up('syslog-notify'):
            return confs

setting = Setting(Notify.SETTING_PATH)

# no need to check setting.get('eps', 'notify_enable') for overview log count chart
        if not FSDN.is_support():
            conf = self._gen_eps_conf()
            confs.append(conf)

if setting.get('pri', 'notify_enable') == '1':
            conf = self._gen_pri_conf()
            confs.append(conf)

for pat_idx in ('1', '2', '3'):
            section = 'pat_{}'.format(pat_idx)
            if setting.get(section, 'notify_enable') == '1' and setting.get(section, 'notify_pat') != '':
                conf = self._gen_pat_conf(pat_idx)
                confs.append(conf)

return confs

def _gen_eps_conf(self):
        return [
            {
                'type': 'destination',
                'name': 'd_syno_dest_arch',
                'content': None
            },
        ]

def _gen_pri_conf(self):
        return [
            {
                'type': 'filter',
                'name': 'f_syno_severity',
                'content': None
            },
            {
                'type': 'rewrite',
                'name': 'r_syno_escape_backslash',
                'content': None
            },
            {
                'type': 'rewrite',
                'name': 'r_syno_escape_double_quote',
                'content': None
            },
            {
                'type': 'destination',
                'name': 'd_syno_severity_notification',
                'content': None
            },
        ]

def _gen_pat_conf(self, pat_idx):
        confs = []
        # XXX: remove me after depending on DSM 7.3
        if exists('/etc.defaults/syslog-ng/syno.d/base.conf'):
            confs += [{
                'type': 'filter',
                'name': 'f_syno_info_severity',
                'content': None
            }]
        confs += [
            {
                'type': 'filter',
                'name': 'f_syno_keyword_{}'.format(pat_idx),
                'content': None
            },
            {
                'type': 'rewrite',
                'name': 'r_syno_escape_backslash',
                'content': None
            },
            {
                'type': 'rewrite',
                'name': 'r_syno_escape_double_quote',
                'content': None
            },
            {
                'type': 'destination',
                'name': 'd_syno_keyword_notification_{}'.format(pat_idx),
                'content': None
            },
        ]
        return confs

SETTING_PATH = '/etc/synosyslog/notify.conf'

class ClientToRemote(Base):
    def __init__(self, synolog_conf):
        super().__init__(synolog_conf)
        self.service_name = 'pkg-LogCenter-client'
        self.destination_names = []
        for index in range(0, CLIENT_MAX_SIZE):
            if index == 0:
                path="/var/packages/LogCenter/etc/client.conf"
            else:
                path="/var/packages/LogCenter/etc/client_{}.conf".format(index)
            if os.access(path, os.F_OK):
                self.destination_names.append('d_syno_internet_{}'.format(index))
        self.filter_sev = 'f_syno_client_sev'
        self.filter_fac = 'f_syno_client_fac'
        self.rewrite_rule = []

def gen(self):
        is_pkg = PkgFacility.is_pkg(self.path, self.app_id, self.facility)
        if is_pkg:
            PkgFacility().init(self.app_id)
        return self._gen(is_pkg)

def _gen(self, is_pkg):
        if not Systemctl.is_unit_up(self.service_name):
            return []

conf = [{
            'type': 'filter',
            'name': self.filter_sev,
            'content': None
        }]

if not is_pkg:
            rewrite_args = {
                'facility': self.facility
            }
            conf += [{
                'type': 'rewrite',
                'name': 'r_remote_{}'.format(self.app_id),
                'content': [
                    ClientToRemote.FMT_REWRITE.format(**rewrite_args)
                ]
            }, {
                'type': 'filter',
                'name': self.filter_fac,
                'content': None
            }]
        else:
            fac = PkgFacility()
            if not fac.get(self.app_id):
                return []
            rewrite_args = {
                'facility': Facility.get_rewrite_program_name(self.app_id, self.facility)
            }
            conf.append({
                'type': 'rewrite',
                'name': 'r_remote_{}'.format(self.app_id),
                'content': [
                    ClientToRemote.FMT_REWRITE.format(**rewrite_args)
                ]
            })

conf += self.rewrite_rule

for destination_name in self.destination_names:
            conf += [{
                'type': 'destination',
                'name': destination_name,
                'content': None
            }]

return [conf]

FMT_REWRITE = 'set("{facility}", value("PROGRAM"));'

class Archive(Base):
    def __init__(self, synolog_conf):
        super().__init__(synolog_conf)

def gen(self):
        if not Systemctl.is_unit_up('pkg-LogCenter-localarchive'):
            return []

if not PkgFacility.is_pkg(self.path, self.app_id, self.facility):
            rewrite_args = {
                'facility': self.facility
            }
        else:
            rewrite_args = {
                'facility': Facility.get_rewrite_program_name(self.app_id, self.facility)
            }

rewrite_program_rule = {
            'type': 'rewrite',
            'name': 'r_local_{}_program'.format(self.app_id),
            'content': [
                ClientToRemote.FMT_REWRITE.format(**rewrite_args)
            ]
        }

confs = []
        # XXX: remove me after depending on DSM 7.3
        if exists('/etc.defaults/syslog-ng/syno.d/base.conf'):
            confs += [{
                'type': 'filter',
                'name': 'f_syno_info_severity',
                'content': None
            }]
        confs += [rewrite_program_rule]

results = [
            confs + [
                {
                    'type': 'destination',
                    'name': 'd_syno_local_arch_db',
                    'content': None
                }
            ]
        ]

if self.facility == 'System':
            results.append(confs + [
                {
                    'type': 'rewrite',
                    'name': 'r_local_{}_message'.format(self.app_id),
                    'content': [
                        'set("${SYNOSDATA.event}", value("MESSAGE"));'
                    ]
                },
                {
                    'type': 'destination',
                    'name': 'd_syno_local_general_db',
                    'content': None
                }
            ])
        elif self.facility == 'Connection':
            results.append(confs + [
                {
                    'type': 'destination',
                    'name': 'd_syno_local_connection_db',
                    'content': None
                }
            ])
        elif self.facility == 'Disk':
            # XXX: remove me after depending on DSM 7.3
            if exists('/etc.defaults/syslog-ng/syno.d/base.conf') and local_sub_gen_module.validate_synolog_conf(self.synolog_conf):
                setting = Setting(Archive.SETTING_PATH, True)
                arch_dest = setting.get('arch_dest')
                if arch_dest != '' and exists(arch_dest):
                    log_type, log_abspath, log_fields = local_sub_gen_module._get_render_content_params(
                        self.synolog_conf)
                    log_fields = Utils.fill_host_fields(log_fields)
                    results.append(confs + [
                        {
                            'type': 'parser',
                            'name': 'r_syno_disk_parser',
                            'content':  None
                        },
                        {
                            'type': 'destination',
                            'name': 'd_syno_local_{}_db'.format(self.app_id),
                            'content': [
                                local_sub_gen_module._render_content(
                                    log_type, arch_dest + '/SYNOSYSLOGDB__LOCALARCH_DISK', log_fields)
                            ]
                        }
                    ])
        return results

SETTING_PATH = '/var/packages/LogCenter/etc/server.conf'

class Receiver(Base):
    def __init__(self, synolog_conf):
        super().__init__(synolog_conf)

def gen(self):
        if not Systemctl.is_unit_up('pkg-LogCenter-recvrule'):
            return []

if not self._is_allow_facility():
            return []

if not local_sub_gen_module.validate_synolog_conf(self.synolog_conf):
            return []

log_type, log_abspath, log_fields = local_sub_gen_module._get_render_content_params(
            self.synolog_conf)

if '/var/log/synolog' != dirname(log_abspath):
            return []

return self._gen_conf(log_type, log_abspath, log_fields)

def _gen_conf(self, log_type, log_abspath, log_fields):
        results = []
        parser = [{
            'type': 'parser',
            'name': 'r_syno_{}_parser'.format(self.app_id),
            'content':  None
        }]
        ietf_base_conf = self._gen_common('ietf', log_type, log_abspath, log_fields, parser)
        bsd_base_conf = self._gen_common('bsd', log_type, log_abspath, log_fields, parser)
        setting = Setting(Receiver.SETTING_PATH)
        for section in setting.sections():
            rule_enable = setting.get(section, "enable")
            if rule_enable != "yes":
                continue
            rule_format = setting.get(section, "format")
            if rule_format == "bsd":
                common_conf = bsd_base_conf
            elif rule_format == "ietf":
                common_conf = ietf_base_conf
            else:
                continue
            name = 's_syno_{}_{}'.format(rule_format, section)
            results.append([
                {
                    'type': 'source',
                    'name': name,
                    'content':  None
                },
                {
                    'type': 'source',
                    'name': name + '_6',
                    'content':  None
                },
            ] + common_conf)

return results

def _gen_common(self, log_format, log_type, log_abspath, log_fields, parser = []):
        log_name = basename(log_abspath)
        log_abspath = self._get_dest_path(log_name)

if log_abspath is None:
            return []

if 'sqlite' == log_type:
            log_fields = Utils.fill_host_fields(log_fields)

rewrite_args = {
            'facility': self.facility,
        }
        if log_format == 'bsd':
            confs = [{
                'type': 'filter',
                'name': 'f_syno_{}_remote_{}'.format(log_format, self.app_id),
                'content':  [
                    Receiver.BSD_FMT_FILTER_FACILITY.format(**rewrite_args)
                ]
            }]
        else:
            confs = [{
                'type': 'filter',
                'name': 'f_syno_{}_remote_{}'.format(log_format, self.app_id),
                'content':  [
                    Receiver.IETF_FMT_FILTER_FACILITY.format(**rewrite_args)
                ]
            }, {
                'type': 'rewrite',
                'name': 'r_syno_remote_username',
                'content': None
            },
            {
                'type': 'rewrite',
                'name': 'r_syno_local_msg',
                'content': None
            }]

return confs + parser + self._gen_dest(log_type, log_abspath, log_fields) + [{
            'type': 'flags',
            'name': 'flow_control',
            'content': None
        }]

def _gen_dest(self, log_type, log_abspath, log_fields):
        return [{
                'type': 'destination',
                'name': 'd_syno_remote_{}'.format(self.app_id),
                'content': [
                    local_sub_gen_module._render_content(
                        log_type, log_abspath, log_fields)
                ]
            }]

def _is_allow_facility(self):
        return self.facility == 'Disk'

def _get_dest_path(self, log_name):
        if self.arch_path is not None:
            return self.arch_path

self.arch_path = Setting(Archive.SETTING_PATH, True).get('arch_dest')
        if self.arch_path != '' and not exists(self.arch_path):
            self.arch_path = ''
        else:
            by_device = Setting(Archive.SETTING_PATH, True).get('arch_by_device')
            if by_device == '1':
                self.arch_path += '/${HOST}/SYNOSYSLOGDB_${HOST}_DISK'
            else:
                self.arch_path += '/SYNOSYSLOGDB__ARCH_DISK'

return self.arch_path

arch_path = None
    IETF_FMT_FILTER_FACILITY = 'match(\'^{facility}$\' value(\'.SDATA.synolog@6574.synotype\'));'
    BSD_FMT_FILTER_FACILITY = 'program(\'^{facility}$\')'
    SETTING_PATH = '/var/packages/LogCenter/etc/recvrule.conf'

class Facility(object):
    KEY_FACILITY = 'facility'

@staticmethod
    def validate(synolog_conf, key):
        log_center_conf = synolog_conf.conf[key]

if type(log_center_conf) is not dict:
            return False

if Facility.KEY_FACILITY not in log_center_conf:
            return False
        facility = log_center_conf[Facility.KEY_FACILITY]

if type(facility) is not str:
            return False
        if len(facility) == 0:
            return False

return True

@staticmethod
    def get(synolog_conf, key):
        if key not in synolog_conf.conf:
            return
        if Facility.KEY_FACILITY not in synolog_conf.conf[key]:
            return
        return synolog_conf.conf[key][Facility.KEY_FACILITY]

@staticmethod
    def get_rewrite_program_name(app_id, def_name):
        name = PkgUtil.get_pkg_name(app_id)
        if not name:
            name = def_name
        return name.replace(" ", "_")

class PkgUtil(object):
    _pkg_name = {}

@staticmethod
    def is_pkg_installed(pkg_id):
        return os.path.isdir('/var/packages/{}/target'.format(pkg_id))

@staticmethod
    def is_local_config(path):
        return path.startswith(PkgUtil.PKG_PREFIX)

@staticmethod
    def get_pkg_name(pkg_id):
        if pkg_id in PkgUtil._pkg_name:
            return PkgUtil._pkg_name[pkg_id]

output = Command.run(
            ['/bin/get_key_value', '/var/packages/{}/INFO'.format(pkg_id), "displayname_enu"]).decode()

if output:
            name = PkgUtil._pkg_name[pkg_id] = output
            return name

output = Command.run(
            ['/usr/syno/bin/synowebapi', '--exec-fastwebapi', 'api=SYNO.Core.Package', 'version=1', 'method=get', 'id="{}"'.format(pkg_id), "runner=root"], False).decode()
        try:
            data = json.loads(output)
            if 'data' in data and 'name' in data['data'] and data['data']['name']:
                name = PkgUtil._pkg_name[pkg_id] = data['data']['name']
                return name
        except ValueError:
            pass

PKG_PREFIX = '/usr/local'

class PkgFacility(object):
    _fac_path = '/var/packages/LogCenter/etc/pkg_facility.json'

def get(self, pkg_id):
        data = self._load()
        if pkg_id in data:
            return data[pkg_id]

def init(self, pkg_id):
        data = self._load()
        if not pkg_id in data:
            self._init(data, pkg_id)

def _init(self, data, pkg_id):
        data[pkg_id] = True
        tmp_fac_path = self._fac_path + ".tmp"
        try:
            with open(tmp_fac_path, "w") as f:
                json.dump(data, f)
                f.close()
                os.rename(tmp_fac_path, self._fac_path)
        except IOError as e:
            print('ERROR: failed to save {} facility, {}'.format(pkg_id, e))

def _load(self):
        try:
            with open(self._fac_path) as f:
                return json.load(f)
        except IOError:
            pass
        except ValueError:
            pass
        return {}

@staticmethod
    def is_pkg(conf_path, app_id, facility):
        return app_id == facility and PkgUtil.is_local_config(conf_path) and PkgUtil.is_pkg_installed(app_id)

class HCI(object):
    _supported = None
    _role = None

@staticmethod
    def is_support():
        if HCI._supported is not None:
            return HCI._supported
        HCI._supported = False
        with open('/etc.defaults/synoinfo.conf', 'r') as f:
            data = f.read()
            if 'support_hyper_converged="yes"' in data:
                HCI._supported = True
        return HCI._supported

@staticmethod
    def get_role():
        if HCI._role is not None:
            return HCI._role
        HCI._role = Command.run(
            ['/usr/syno/bin/hcm-sentinel-tool', 'get-role']).decode()
        return HCI._role

class FSDN(object):
    _supported = None
    _online = None
    _is_admin_node = None

@staticmethod
    def is_support():
        if FSDN._supported is not None:
            return FSDN._supported
        FSDN._supported = False
        if exists('/usr/syno/sbin/syno_feature_check.sh') and 0 == subprocess.call(['/usr/syno/sbin/syno_feature_check.sh', 'SYNO_PRODUCT_FSDN']):
            FSDN._supported = True
        return FSDN._supported

@staticmethod
    def is_online():
        if FSDN._online is not None:
            return FSDN._online
        FSDN._online = 0 == subprocess.call(['/usr/syno/bin/aacore', 'is-remote-alive'])
        return FSDN._online

@staticmethod
    def is_admin_node():
        if FSDN._is_admin_node is not None:
            return FSDN._is_admin_node
        FSDN._is_admin_node = 0 == subprocess.call(['/usr/syno/bin/aacore', 'is-admin-node'])
        return FSDN._is_admin_node

class Utils(object):
    @staticmethod
    def fill_host_fields(fields):
        has_host = False
        for field in fields:
            if 'value' not in field:
                continue
            if field['value'] == '$HOST':
                has_host = True
                break
        if not has_host:
            fields.append({
                'column': 'host TEXT DEFAULT NULL',
                'value': '$HOST',
                'index': True
            })
        return fields

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	0/0	0755	2025-11-12 12:12:51
..	dir	-	0/0	0755	2025-09-24 06:24:30
__pycache__	dir	-	0/0	0755	2025-11-12 12:12:51
logcenter.py	text/x-script.python	22.73 KB	0/0	0755	2025-09-24 06:24:30
logcenter_cluster.py	text/x-script.python	7.82 KB	0/0	0755	2025-09-24 06:24:30

Team Anon Force

https://t.me/Professor6T9x