├── .github
    ├── make-release.sh
    └── workflows
    │   ├── docs.yml
    │   └── obs.yml
├── .gitignore
├── .mailmap
├── AUTHORS
├── CHANGELOG.md
├── CONTRIBUTING.md
├── COPYING
├── HOWTO
├── Makefile.am
├── NEWS
├── README
├── README.md
├── SPECS
├── TECHNICAL
├── apps
    ├── .gitignore
    ├── cluster_tools
    │   └── cluster_tools.py.in
    ├── libexec
    │   ├── .gitignore
    │   ├── ascii.py
    │   ├── bash
    │   │   ├── inc.sh
    │   │   └── syscheck.proc.sh
    │   ├── check.py.in
    │   ├── containerhealth.py.in
    │   ├── db.py.in
    │   ├── ecmd.py
    │   ├── helpfiles
    │   │   ├── log.push.txt
    │   │   ├── node.tree.txt
    │   │   ├── query.ls.txt
    │   │   ├── query.lsq.txt
    │   │   ├── sshkey.fetch.txt
    │   │   ├── sshkey.push.txt
    │   │   ├── sysconf.check.txt
    │   │   └── sysconf.ramdisk.txt
    │   ├── id.py
    │   ├── log.py.in
    │   ├── merlinkey.py.in
    │   ├── modules
    │   │   ├── compound_config.py
    │   │   ├── coredump.py
    │   │   ├── merlin_apps_utils.py
    │   │   ├── merlin_conf.py.in
    │   │   ├── merlin_db.py
    │   │   ├── merlin_qh.py
    │   │   ├── merlin_status.py
    │   │   ├── merlin_test_utils.py
    │   │   ├── nagios_command.py
    │   │   ├── nagios_plugin.py
    │   │   ├── nagios_qh.py
    │   │   ├── pytap
    │   │   │   ├── pytap.py
    │   │   │   └── ttest.py
    │   │   ├── qhcheck.py
    │   │   └── test
    │   │   │   └── test_nagios_qh.py
    │   ├── node.py
    │   ├── node.tree.php
    │   ├── oconf.py.in
    │   ├── qh.py
    │   ├── query.ls.sh.in
    │   ├── query.lsq.sh.in
    │   ├── reportdata.py.in
    │   ├── restart.sh.in
    │   ├── slim-poller.py.in
    │   ├── sshkey.fetch.sh.in
    │   ├── sshkey.push.sh.in
    │   ├── start.sh
    │   ├── status.py
    │   ├── stop.sh
    │   ├── syscheck
    │   │   ├── .gitignore
    │   │   ├── db_mysql_check.sh
    │   │   ├── fs_ext_state.sh
    │   │   ├── fs_free_inodes.sh
    │   │   ├── fs_free_space.sh
    │   │   ├── fs_mount_opts.sh
    │   │   ├── license.sh
    │   │   ├── proc_collector.sh
    │   │   ├── proc_crond.sh
    │   │   ├── proc_httpd.sh
    │   │   ├── proc_merlind.sh.in
    │   │   ├── proc_monitor_core.sh
    │   │   ├── proc_monitor_worker.sh
    │   │   ├── proc_mysqld.sh
    │   │   ├── proc_npcd.sh
    │   │   ├── proc_ntpd.sh
    │   │   ├── proc_op5config.sh
    │   │   ├── proc_op5kad.sh
    │   │   ├── proc_pgsql_postmaster.sh
    │   │   ├── proc_processor.sh
    │   │   ├── proc_rrdcached.sh
    │   │   ├── proc_smsd.sh
    │   │   ├── proc_synergy.sh
    │   │   └── proc_syslog_ng.sh
    │   ├── sysconf.check.sh
    │   ├── sysconf.ramdisk.sh
    │   ├── test.py
    │   └── tests
    │   │   └── test_merlin_qh.py
    ├── mon.py.in
    └── tests
    │   └── oconf-poller-fix
    │       ├── fixed-config.cfg
    │       ├── merlin.conf
    │       ├── test-config.cfg
    │       └── test.sh
├── autogen.sh
├── compat
    ├── asprintf.c
    └── memrchr.c
├── configure.ac
├── daemon
    ├── daemon.c
    ├── daemonize.c
    ├── daemonize.h
    ├── db_updater.c
    ├── db_updater.h
    ├── db_wrap.c
    ├── db_wrap.h
    ├── db_wrap_dbi.c
    ├── db_wrap_dbi.h
    ├── merlind.c
    ├── sql.c
    ├── sql.h
    ├── state.c
    ├── state.h
    ├── string_utils.c
    └── string_utils.h
├── data
    ├── .gitignore
    ├── kad.conf.in
    ├── merlin.cfg.in
    ├── merlin.conf.in
    ├── merlin.in
    └── merlind.in
├── docs
    ├── .gitignore
    ├── Makefile
    ├── _templates
    │   └── layout.html
    ├── changelog.md
    ├── clustering.rst
    ├── conf.py
    ├── configuration.rst
    ├── container-poller.md
    ├── encryption.rst
    ├── index.rst
    ├── install.rst
    └── merlin.conf.sample
├── features
    ├── active_checks.feature
    ├── binlog.feature
    ├── check_result_output.feature
    ├── check_results_propagation.feature
    ├── cluster_update.feature
    ├── config_split_poller.feature
    ├── config_sync_passive_poller.feature
    ├── config_sync_peer.feature
    ├── config_sync_poller.feature
    ├── connection.feature
    ├── csync_unsynced_masters.feature
    ├── data
    │   ├── README
    │   ├── module.my-peer.binlog.meta
    │   └── module.my-peer.binlog.save
    ├── event_handler_execution.feature
    ├── execute_host_checks.feature
    ├── hostgroup_split.feature
    ├── ipc_nodeinfo_version.feature
    ├── livestatus.feature
    ├── notification_contact_propagation.feature
    ├── notification_host_execution.feature
    ├── notification_persistence.feature
    ├── notification_propagation.feature
    ├── notification_service_execution.feature
    ├── passive_check_results.feature
    ├── peer_nodeinfo_version.feature
    ├── report_data_host_active.feature
    ├── report_data_service_active.feature
    ├── retention_data_oconf_hash.feature
    ├── runcmd.feature
    ├── scheduled_downtime.feature
    ├── startup.feature
    ├── step_definitions
    │   ├── cukemerlin.wire
    │   ├── database.rb
    │   ├── delay.rb
    │   ├── livestatus.rb
    │   ├── merlin.rb
    │   ├── merlin_node_config.rb
    │   ├── naemon.rb
    │   ├── naemon_object_config.rb
    │   ├── naemon_system_config.rb
    │   ├── network_setup.rb
    │   ├── repeat.rb
    │   ├── service_startup.rb
    │   └── systemd_merlind.rb
    └── support
    │   ├── database_config.rb
    │   ├── env.rb
    │   ├── merlin_node_config.rb
    │   ├── merlin_packet_defaults.rb
    │   ├── naemon_object_config.rb
    │   └── naemon_system_config.rb
├── generate_version_number.sh
├── install-merlin.sh.in
├── logs
    ├── beta.log
    ├── no-lf-terminator.log
    ├── nuls.log
    └── single-read.log
├── m4
    └── acinclude.m4
├── merlin_logo.svg
├── merlind.service.in
├── module
    ├── hooks.c
    ├── hooks.h
    ├── misc.c
    ├── misc.h
    ├── module.c
    ├── module.h
    ├── net.c
    ├── net.h
    ├── oconfsplit.c
    ├── oconfsplit.h
    ├── queries.c
    ├── queries.h
    ├── runcmd.c
    ├── runcmd.h
    ├── script-helpers.c
    ├── script-helpers.h
    ├── sha1.c
    ├── sha1.h
    ├── testif_qh.c
    └── testif_qh.h
├── nrpe-merlin.cfg
├── obs
    └── rpm
    │   └── merlin.spec
├── op5build
    ├── ci_config.yml
    ├── merlin.spec
    └── nacoma_hook.py
├── shared
    ├── binlog.c
    ├── binlog.h
    ├── cfgfile.c
    ├── cfgfile.h
    ├── codec.c
    ├── codec.h
    ├── compat.h
    ├── configuration.c
    ├── configuration.h
    ├── dlist.c
    ├── dlist.h
    ├── encryption.c
    ├── encryption.h
    ├── io.c
    ├── io.h
    ├── ipc.c
    ├── ipc.h
    ├── logging.c
    ├── logging.h
    ├── node.c
    ├── node.h
    ├── pgroup.c
    ├── pgroup.h
    ├── shared.c
    └── shared.h
├── sort-merge_logs.sh
├── sql
    ├── mysql
    │   ├── drop_indexes.sql
    │   ├── merlin.sql
    │   ├── notification-indexes.sql
    │   └── perfdata-indexes.sql
    ├── update-db-1to2.sql
    └── update-db-2to3.sql
├── sudo
    └── merlin.in
├── test_protocol
    ├── dotest.py
    ├── merlinnet.py
    └── merlinpkt.py
├── tests
    ├── bltest.c
    ├── codectest.c
    ├── cukemerlin
    │   ├── base
    │   │   ├── cukemerlin.c
    │   │   ├── cukesocket.c
    │   │   ├── cukesocket.h
    │   │   ├── json.c
    │   │   ├── json.h
    │   │   ├── jsonsocket.c
    │   │   ├── jsonsocket.h
    │   │   ├── jsonx.c
    │   │   └── jsonx.h
    │   └── steps
    │   │   ├── steps.c
    │   │   ├── steps.h
    │   │   ├── steps_config.c
    │   │   ├── steps_config.h
    │   │   ├── steps_daemons.c
    │   │   ├── steps_daemons.h
    │   │   ├── steps_livestatus.c
    │   │   ├── steps_livestatus.h
    │   │   ├── steps_merlin.c
    │   │   ├── steps_merlin.h
    │   │   ├── steps_queryhandler.c
    │   │   ├── steps_queryhandler.h
    │   │   ├── steps_test.c
    │   │   └── steps_test.h
    ├── importlog_naemon.log
    ├── merlincat
    │   ├── client_gsource.c
    │   ├── client_gsource.h
    │   ├── conn_info.c
    │   ├── conn_info.h
    │   ├── console.c
    │   ├── console.h
    │   ├── event_packer.c
    │   ├── event_packer.h
    │   ├── generate-nebev2kvvec.py
    │   ├── merlincat.c
    │   ├── merlincat_codec.c
    │   ├── merlincat_codec.h
    │   ├── merlincat_encryption.c
    │   ├── merlincat_encryption.h
    │   ├── merlinreader.c
    │   ├── merlinreader.h
    │   ├── server_gsource.c
    │   └── server_gsource.h
    ├── pyunit
    │   ├── test_log.py
    │   └── test_oconf.py
    ├── showlog_test.log
    ├── showlog_test_monitor_and_not_monitor1_svc.log
    ├── showlog_test_monitoronly.log
    ├── showlog_test_not_monitor1_svc_only.log
    ├── singlenode.conf
    ├── sltest.c
    ├── test-csync.c
    ├── test-dbwrap.c
    ├── test-hooks.c
    ├── test-importlog.c
    ├── test-lparse.c
    ├── test-showlog.c
    ├── test-stringutils.c
    └── twopeers.conf
└── tools
    ├── auth.c
    ├── auth.h
    ├── colors.h
    ├── import.c
    ├── keygen.c
    ├── logutils.c
    ├── logutils.h
    ├── lparse.c
    ├── lparse.h
    ├── oconf.c
    ├── rename.c
    ├── showlog.c
    ├── slist.c
    ├── slist.h
    ├── test_utils.c
    └── test_utils.h


/.github/make-release.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Check for OBS_TOKEN
 4 | if [ -z "${OBS_PROJECT}" ] ; then
 5 |     echo "Enviorment variable OBS_PROJECT must be set"
 6 |     exit 1
 7 | fi
 8 | if [ -z "${OBS_PACKAGE}" ] ; then
 9 |     echo "Enviorment variable OBS_PACKAGE must be set"
10 |     exit 1
11 | fi
12 | if [ -z "${MERLIN_VERSION}" ] ; then
13 |     echo "Enviorment variable MERLIN_VERSION must be set"
14 |     exit 1
15 | fi
16 | 
17 | # TODO: automate getting platforms from OBS
18 | PLATFORMS=(CentOS_8_Stream CentOS_7)
19 | EXPECTED_PACKAGES=${#PLATFORMS[@]}
20 | 
21 | # Trigger the OBS build
22 | osc api -X POST "/source/$OBS_PROJECT/$OBS_PACKAGE?cmd=runservice"
23 | 
24 | echo "Waiting for builds to finish"
25 | 
26 | # list of possible OBS errors
27 | errors=(broken unresolvable failed)
28 | 
29 | # loop until we built all packages or we get an error or max timeout (2hours)
30 | end=$((SECONDS+7200))
31 | failed=true
32 | while [ $SECONDS -lt $end ]
33 | do
34 |     sleep 60
35 |     obs_status=$(osc r $OBS_PROJECT $OBS_PACKAGE)
36 |     published_count=$(echo $obs_status | grep -o "succeeded" | wc -l)
37 |     if [ $published_count -ge $EXPECTED_PACKAGES ]
38 |     then
39 |         failed=false
40 |         break
41 |     fi
42 |     # check for possible errors
43 |     for error in ${errors[*]}
44 |     do
45 |         error_count=$(echo $obs_status | grep -o "$error" | wc -l)
46 |         if [ $error_count -ge 1 ]
47 |         then
48 |             echo "OBS build failed"
49 |             echo $obs_status
50 |             exit 1;
51 |         fi
52 |     done
53 | done
54 | 
55 | # check if everything worked OK
56 | if $failed; then
57 |     echo "Timeout"
58 |     exit 1
59 | fi
60 | 
61 | # get rpms for each release, tar them and cleanup
62 | mkdir -p release_archives
63 | for platform in ${PLATFORMS[*]}
64 | do
65 |     echo $platform
66 |     osc getbinaries $OBS_PROJECT $OBS_PACKAGE $platform x86_64 -d ./$platform
67 |     # get rid of metadata files
68 |     rm -f ./$platform/_*
69 |     # Get slim packages and delete them
70 |     tar cfJ release_archives/merlin-slim-$MERLIN_VERSION-$platform.tar.xz ./$platform/*slim*
71 |     rm ./$platform/*slim*
72 |     # get the normal packages
73 |     tar cfJ release_archives/merlin-$MERLIN_VERSION-$platform.tar.xz ./$platform/*
74 |     # clean up
75 |     rm -rf ./$platform/
76 | done
77 | 


--------------------------------------------------------------------------------
/.github/workflows/docs.yml:
--------------------------------------------------------------------------------
 1 | name: Github Pages
 2 | 
 3 | on:
 4 |   workflow_dispatch:
 5 | 
 6 | 
 7 | 
 8 | jobs:
 9 |   deploy:
10 |     runs-on: ubuntu-20.04
11 |     concurrency:
12 |       group: ${{ github.workflow }}-${{ github.ref }}
13 |     steps:
14 |       - uses: actions/checkout@v2
15 |       - name: Install doc dependencies
16 |         run: |
17 |           sudo apt-get -y update
18 |           sudo apt-get -y install python3-sphinx python3-sphinx-rtd-theme python3-pip
19 |           sudo pip install myst-parser
20 |       - name: Make docs
21 |         run: cd docs && make html
22 |       - name: test
23 |         run: ls -la && ls -la ./docs
24 |       - name: Deploy
25 |         uses: peaceiris/actions-gh-pages@v3
26 |         with:
27 |           github_token: ${{ secrets.GITHUB_TOKEN }}
28 |           publish_dir: ./docs/_build/html
29 |           user_name: 'github-actions[bot]'
30 |           user_email: 'github-actions[bot]@users.noreply.github.com'
31 | 


--------------------------------------------------------------------------------
/.github/workflows/obs.yml:
--------------------------------------------------------------------------------
 1 | name: Build and Release
 2 | 
 3 | on:
 4 |   workflow_dispatch:
 5 | 
 6 | jobs:
 7 |   build_obs:
 8 |     runs-on: ubuntu-latest
 9 |     steps:
10 |       - uses: actions/checkout@v2
11 |       - name: install OBS tools
12 |         env:
13 |           OBS_USERNAME: ${{ secrets.OBS_USERNAME }}
14 |           OBS_PASSWORD: ${{ secrets.OBS_PASSWORD }}
15 |         run: |
16 |           curl -s "https://build.opensuse.org/projects/openSUSE:Tools/public_key" | sudo apt-key add -
17 |           sudo sh -c 'echo "deb http://download.opensuse.org/repositories/openSUSE:/Tools/xUbuntu_$(lsb_release -rs)/ ./" >> /etc/apt/sources.list.d/openSUSE-tools.list'
18 |           sudo apt-get -y update
19 |           sudo apt-get -y install osc
20 |           mkdir -p ~/.config/osc
21 |           cat > ~/.config/osc/oscrc << EOL
22 |           [general]
23 |           apiurl = https://api.opensuse.org
24 |           [https://api.opensuse.org]
25 |           user=$OBS_USERNAME
26 |           pass=$OBS_PASSWORD
27 |           credentials_mgr_class=osc.credentials.PlaintextConfigFileCredentialsManager
28 |           EOL
29 |       - name: Get tag
30 |         id: tag
31 |         uses: dawidd6/action-get-tag@v1
32 |       - name: Build and fetch binaries on OBS
33 |         env:
34 |           OBS_PROJECT: ${{ secrets.OBS_PROJECT }}
35 |           OBS_PACKAGE: ${{ secrets.OBS_PACKAGE }}
36 |           MERLIN_VERSION: ${{ steps.tag.outputs.tag }}
37 |         run: .github/make-release.sh
38 |       - uses: actions/upload-artifact@v2
39 |         with:
40 |           name: obs-binaries
41 |           path: release_archives/*.tar.xz
42 |   make_release:
43 |     runs-on: ubuntu-latest
44 |     needs:
45 |       - build_obs
46 |     steps:
47 |       - name: Checkout
48 |         uses: actions/checkout@v2
49 |       - uses: actions/download-artifact@v2
50 |         with:
51 |           name: obs-binaries
52 |       - name: Extract release notes
53 |         id: extract-release-notes
54 |         uses: ffurrer2/extract-release-notes@v1
55 |       - name: Release
56 |         uses: softprops/action-gh-release@v1
57 |         with:
58 |           body: ${{ steps.extract-release-notes.outputs.release_notes }}
59 |       - name: Upload release binaries
60 |         uses: alexellis/upload-assets@0.2.2
61 |         env:
62 |           GITHUB_TOKEN: ${{ github.token }}
63 |         with:
64 |           asset_paths: '["./*.tar.xz"]'
65 | 
66 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.o
 2 | *.so
 3 | *.lo
 4 | *.la
 5 | .deps
 6 | .libs
 7 | .dirstamp
 8 | core.[0-9]*
 9 | core
10 | mod.log
11 | junk
12 | monitor
13 | test
14 | blread
15 | endpoint
16 | *.log
17 | *.bin
18 | merlind
19 | *test
20 | version.c
21 | mtest
22 | check_latency
23 | start.sh
24 | postgres.sh
25 | funused.sh
26 | test-hash
27 | test-csync
28 | bltest
29 | sltest
30 | test-lparse
31 | import
32 | showlog
33 | keygen
34 | *.pyc
35 | oconf
36 | test-dbwrap
37 | ocimp
38 | entries.sh
39 | ca-debug.py
40 | data/merlin.conf
41 | .lock*
42 | rename
43 | install-merlin.sh
44 | apps/op5
45 | *.swp
46 | *~
47 | TAGS
48 | INSTALL
49 | Makefile.in
50 | Makefile
51 | /autom4te.cache
52 | /aclocal.m4
53 | /compile
54 | /configure
55 | /depcomp
56 | /install-sh
57 | /missing
58 | /stamp-h1
59 | libtool
60 | ltmain.sh
61 | py-compile
62 | test-driver
63 | config.guess
64 | config.h
65 | config.h.in
66 | config.status
67 | config.sub
68 | merlincat$
69 | /tests/merlincat/nebev-col2key.gperf
70 | /tests/merlincat/nebev-col2key.[ch]
71 | /tests/merlincat/nebev2kvvec.[ch]
72 | /tests/merlincat/kvvec2nebev.[ch]
73 | /*.trs
74 | 
75 | /cukemerlin
76 | /merlincat
77 | /apps/libexec/restart.sh
78 | apps/tests/oconf-poller-fix/fixme.cfg
79 | apps/tests/oconf-poller-fix/fixed-config.cfg-first
80 | m4/*.m4
81 | sudo/merlin
82 | .DS_Store
83 | .pydevproject
84 | merlind.service
85 | apps/cluster_tools/cluster_tools.py
86 | apps/cluster_tools/merlin_cluster_tools
87 | !docs/Makefile
88 | docs/_build/
89 | 


--------------------------------------------------------------------------------
/.mailmap:
--------------------------------------------------------------------------------
1 | Per Åsberg <per.asberg@op5.se> <perasb@op5.se>
2 | Oleksandr Lepetyukh <olepetyukh@op5.com>
3 | Mattias Ryrlén <mattiasr@op5.com> <mattias.ryrlen@op5.com>
4 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | This file is populated automatically by make dist.
2 | 
3 | To view authors sorted by contributions, use 'git shortlog -ns'
4 | 


--------------------------------------------------------------------------------
/NEWS:
--------------------------------------------------------------------------------
1 | See https://support.itrsgroup.com/hc/en-us/articles/360020292133-Distributed-Merlin-Introduction for places
2 | to find out more about merlin news.
3 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | README.md


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ![merlin logo](merlin_logo.svg)
 2 | 
 3 | # Welcome to Merlin #
 4 | [![GitHub release (latest by date)](https://img.shields.io/github/v/release/itrs-group/monitor-merlin?display_name=release)](https://github.com/ITRS-Group/monitor-merlin/releases)
 5 | [![GitHub](https://img.shields.io/github/license/itrs-group/monitor-merlin)](https://github.com/ITRS-Group/monitor-merlin/blob/master/COPYING)
 6 | 
 7 | The Merlin project, or Module for Effortless Redundancy and Loadbalancing In
 8 | [Naemon](https://naemon.org), is a Naemon module built to create an easy way to
 9 | set up distributed Naemon installations, allowing Naemon processes to exchange
10 | information. This allows Naemon to scale past a single installation to handle
11 | a bigger monitoring workload.
12 | 
13 | Merlin can also save state changes to a database, which can be
14 | used for reporting purposes.
15 | 
16 | ## Documentation ##
17 | 
18 | Full documentation including installation and usage guides can be found
19 | at [Github Pages](https://itrs-group.github.io/monitor-merlin/).
20 | 
21 | ## Contributing to Merlin
22 | 
23 | Contributions are always welcome. Please see [CONTRIBUTING.md](CONTRIBUTING.md)
24 | for the full details.
25 | 


--------------------------------------------------------------------------------
/apps/.gitignore:
--------------------------------------------------------------------------------
1 | mon.py
2 | 


--------------------------------------------------------------------------------
/apps/libexec/.gitignore:
--------------------------------------------------------------------------------
 1 | oconf.py
 2 | oconf.fetch.sh
 3 | merlinkey.py
 4 | check.py
 5 | query.ls.sh
 6 | query.lsq.sh
 7 | reportdata.py
 8 | slim-poller.py
 9 | db.py
10 | log.py
11 | sshkey.push.sh
12 | sshkey.fetch.sh
13 | containerhealth.py
14 | modules/merlin_conf.py
15 | 


--------------------------------------------------------------------------------
/apps/libexec/bash/inc.sh:
--------------------------------------------------------------------------------
  1 | # SNTX: msgdie <exit code> <text>
  2 | # DESC: Prints specified text and exits with given exit code.
  3 | msgdie()
  4 | {
  5 |   printf '%s\n' "$2"
  6 |   exit $1
  7 | }
  8 | 
  9 | # SNTX: dieplug <exit code> <exit text without exit state prefix>
 10 | # DESC: Prints the final status text and prepends the exit state prefix
 11 | #       depending on which exit code it was called with.
 12 | dieplug()
 13 | {
 14 |   local code text prefix
 15 |   code="$1"
 16 | 
 17 |   case "$code" in
 18 |     '0')
 19 |       text='OK'
 20 |       ;;
 21 |     '1')
 22 |       text='WARNING'
 23 |       ;;
 24 |     '2')
 25 |       text='CRITICAL'
 26 |       ;;
 27 |     '3')
 28 |       text='UNKNOWN'
 29 |       ;;
 30 |     *)
 31 |       text="INVALID exit code ($code)"
 32 |       code='3'
 33 |       ;;
 34 |   esac
 35 | 
 36 |   # append any additional text if specified
 37 |   [ -n "$2" ] && text+=": $2"
 38 | 
 39 |   # print text to stdout
 40 |   msgdie "$code" "$text"
 41 | }
 42 | 
 43 | # SNTX: depchk <dep1> [depN]..
 44 | # DESC: Exits in case any given dependencies are missing.
 45 | depchk()
 46 | {
 47 |   local arg miss
 48 | 
 49 |   miss=''
 50 |   for arg; do
 51 |     hash -- "$arg" &> /dev/null || miss+=" $arg"
 52 |   done
 53 | 
 54 |   [ -n "$miss" ] || return 0
 55 | 
 56 |   msgdie '3' "Missing dependencies:$miss"
 57 | }
 58 | 
 59 | 
 60 | # SNTX: cmd_exec <command> [arg1] [argN]..
 61 | # DESC: Executes given command line, which if it fails, exits with debug output.
 62 | cmd_exec()
 63 | {
 64 |   OUT="$("$@" 2>&1)"
 65 |   RET="$?"
 66 | 
 67 |   [ "$RET" == '0' ] || \
 68 |     msgdie '3' "$(cmd_debug_output "$@")"
 69 | 
 70 |   return 0
 71 | }
 72 | 
 73 | # SNTX: [OUT=<text>] [RET=<$?>] cmd_debug_output <command> [arg1] [argN]..
 74 | # DESC: Verbosely describes the given command line and possible results.
 75 | cmd_debug_output()
 76 | {
 77 |   local args
 78 |   args="$(for arg; do printf '(%s)\n' "$arg"; done)"
 79 | 
 80 |   printf 'Executed command failed unexpectedly.\n'
 81 |   cmd_debug_section 'CMD LINE' "$*"
 82 |   cmd_debug_section 'ARGUMENTS' "$args"
 83 |   [ -n "$RET" ] && cmd_debug_section 'RETURN CODE' "$RET"
 84 |   [ -n "$OUT" ] && cmd_debug_section 'OUTPUT' "$OUT"
 85 | }
 86 | 
 87 | # SNTX: cmd_debug_section <tag> <text>
 88 | # DESC: Encapsulates given text with tagged header and footer.
 89 | cmd_debug_section()
 90 | {
 91 |   printf '\n'
 92 |   printf '==%s:START==\n' "$1"
 93 |   printf '%s\n' "$2"
 94 |   printf '==%s:END==\n' "$1"
 95 | }
 96 | 
 97 | 
 98 | # SNTX: is_rhel
 99 | # DESC: Basic check if this is a RHEL system.
100 | is_rhel()
101 | {
102 |   test -f /etc/rc.d/init.d/functions
103 |   return $?
104 | }
105 | 
106 | # SNTX: is_sles
107 | # DESC: Basic check if this is a SLES system.
108 | is_sles()
109 | {
110 |   test -f /etc/rc.status
111 |   return $?
112 | }
113 | 


--------------------------------------------------------------------------------
/apps/libexec/db.py.in:
--------------------------------------------------------------------------------
 1 | import os.path, glob, sys
 2 | try:
 3 | 	from hashlib import sha1
 4 | except ImportError:
 5 | 	from sha import sha as sha1
 6 | 
 7 | import merlin_db
 8 | 
 9 | log_file = '/tmp/merlin-sql-upgrade.log'
10 | 
11 | def cmd_fixindexes(args):
12 | 	"""
13 | 	Fixes indexes on merlin tables containing historical data.
14 | 	"""
15 | 	print('Adding indexes...')
16 | 	print('(if this takes forever, aborting this and running')
17 | 	print('\tmon log import --truncate-db')
18 | 	print('might be quicker, but could permanently remove some old logs)')
19 | 	conn = merlin_db.connect(mconf)
20 | 	cursor = conn.cursor()
21 | 	log = []
22 | 	for table in glob.glob('@datarootdir@/merlin/sql/mysql/*-indexes.sql'):
23 | 		queries = open(table)
24 | 		try:
25 | 			cursor.execute(queries.read())
26 | 		except Exception as ex:
27 | 			log.append(f'%s: %s' % (os.path.basename(table), ex))
28 | 		queries.close()
29 | 	conn.commit()
30 | 	conn.close()
31 | 	if not log:
32 | 		print('Indexes installed successfully')
33 | 	else:
34 | 		print('\nThere were problems. This is normal if the indexes already', end=' ')
35 | 		print('(partially) exist,\nbut could also indicate a problem.')
36 | 		print('\nMessages:')
37 | 		for msg in log:
38 | 			print('  %s' % msg)
39 | 
40 | def module_init(args):
41 | 	return args
42 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/log.push.txt:
--------------------------------------------------------------------------------
1 | [--push-all|--since <time>]
2 | Pushes logs to other nodes. Used by log fetch.
3 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/node.tree.txt:
--------------------------------------------------------------------------------
1 | 
2 | Prints an ascii map of the node network.
3 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/query.ls.txt:
--------------------------------------------------------------------------------
1 | [--help|[<table> [OPTION|FILTER]..]
2 | 
3 | All available tables will be listed if no arguments are seen.
4 | 
5 | The first argument is always the table name. The table is
6 | described if this is the one and only argument given.
7 | 
8 | See --help for more information.
9 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/query.lsq.txt:
--------------------------------------------------------------------------------
1 | [query]
2 | 
3 | A raw livestatus query is expected at stdin or as the first argument.
4 | 
5 | The query needs not a trailing newline, but either way works.
6 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/sshkey.fetch.txt:
--------------------------------------------------------------------------------
 1 | [--outfile=<outfile>] [--all|--type=<peer|poller|master>] [source]..
 2 | Fetch public ssh keys from specified remote node(s) (sources).
 3 | 
 4 | The keys will be written to the specified outfile, or if not
 5 | specified, default to: ~/.ssh/authorized_keys
 6 | 
 7 | If no key exists on any of the specified remote nodes, a new key
 8 | will be generated automatically.
 9 | 
10 | A combination of different node types as well as specific nodes
11 | can be specified at the same time.
12 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/sshkey.push.txt:
--------------------------------------------------------------------------------
 1 | [--key=<keyfile>] [--all|--type=<peer|poller|master>] [destination]..
 2 | Push public ssh key to specified remote node(s) (destinations).
 3 | 
 4 | The key will be read from specified keyfile, or if not
 5 | specified, default to: ~/.ssh/id_rsa.pub
 6 | 
 7 | If no key exists, a new key will be generated automatically.
 8 | 
 9 | A combination of different node types as well as specific nodes
10 | can be specified at the same time.
11 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/sysconf.check.txt:
--------------------------------------------------------------------------------
 1 | [OPTION].. [HANDLER]..
 2 | Executes one or more sysconf check handlers.
 3 | 
 4 | If no handler names given, all available handlers will be run.
 5 | 
 6 |  -c, --complete  Output all check results, regardless of state.
 7 |  -h, --help      This syntax text.
 8 |  -l, --list      List all available handlers.
 9 |  -v, --verbose   Output full multi line check results.
10 | 


--------------------------------------------------------------------------------
/apps/libexec/helpfiles/sysconf.ramdisk.txt:
--------------------------------------------------------------------------------
1 | <enable>
2 | Configure the Monitor system to use ramdisk (tmpfs) for temporary
3 | performance data files.
4 | 
5 | NOTE: This operation is potentially dangerous in case the system
6 | has a limited amount of RAM. Due to this the changes will not take
7 | effect until the command is run with the "enable" argument.
8 | 
9 | 


--------------------------------------------------------------------------------
/apps/libexec/id.py:
--------------------------------------------------------------------------------
1 | import uuid
2 | 
3 | def cmd_generate(args):
4 | 	"""
5 | 	Prints a UUID4 to be used when Merlin is in UUID identification mode.
6 | 	"""
7 | 
8 | 	print(str(uuid.uuid4()))
9 | 


--------------------------------------------------------------------------------
/apps/libexec/merlinkey.py.in:
--------------------------------------------------------------------------------
 1 | import os, sys
 2 | import time
 3 | import pwd
 4 | import grp
 5 | import subprocess as sp
 6 | 
 7 | merlin_conf_dir = "@pkgconfdir@"
 8 | 
 9 | def initchildproc():
10 | 	os.umask(0o377)
11 | 
12 | def cmd_generate(args):
13 | 	""" --path=</path/to/save/keys>
14 | 	Generates secure keys for encrypting Merlin communication
15 | 
16 | 	By default the keys are placed in /@pkgconfdir@.
17 | 	"""
18 | 
19 | 	path = merlin_conf_dir
20 | 	write_to_file = False
21 | 	for arg in args:
22 | 		if arg.startswith('--path'):
23 | 			path = arg.split('=', 1)[1]
24 | 		if arg.startswith('--write'):
25 | 			write_to_file = True
26 | 
27 | 	has_pub_key = os.path.isfile(path + '/key.pub')
28 | 	has_priv_key = os.path.isfile(path + '/key.priv')
29 | 
30 | 	if has_pub_key and has_priv_key:
31 | 		print('File already exists. Keys will not be generated.')
32 | 		sys.exit(0)
33 | 
34 | 	if has_pub_key or has_priv_key:
35 | 		print('One of the encryption keys already exists. Remove and try again')
36 | 		sys.exit(1)
37 | 
38 | 	if write_to_file:
39 | 		with open(merlin_conf_dir + "/merlin.conf", 'r') as fh:
40 | 			for line in fh:
41 | 				if "ipc_privatekey" in line:
42 | 					print("Conflict, private key location already specified: " + line.strip())
43 | 					sys.exit(1)
44 | 
45 | 	p = sp.Popen(['@libdir@/merlin/keygen', "-p", path], stdout=sp.PIPE,
46 | 			stderr=sp.PIPE, preexec_fn=initchildproc)
47 | 	p.wait()
48 | 	if p.returncode != 0:
49 | 		print('Key generation failed')
50 | 		sys.exit(1)
51 | 
52 | 	if write_to_file:
53 | 		with open(merlin_conf_dir + "/merlin.conf", 'a') as fh:
54 | 			fh.write("ipc_privatekey = {}".format(path + "/key.priv"))
55 | 			fh.write('\n')
56 | 
57 | 	uid = pwd.getpwnam("@naemon_user@").pw_uid
58 | 	# -1 means we leave group unchanged
59 | 	os.chown(path + "/key.priv", uid, -1)
60 | 	os.chown(path + "/key.pub", uid, -1)
61 | 	print('Key generated and saved at ' + path)
62 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/merlin_apps_utils.py:
--------------------------------------------------------------------------------
  1 | import sys, os, time, errno
  2 | 
  3 | class ansi_color:
  4 | 	_color_names = "grey red green brown blue magenta cyan white"
  5 | 	_attr_names = "none bold faint italic underline blink fast reverse concealed"
  6 | 	esc = '%s[' % chr(27)
  7 | 	def __init__(self, f=sys.stdout.fileno()):
  8 | 		if not os.isatty(f):
  9 | 			self.bright = ''
 10 | 			self.reset = ''
 11 | 			for attr in self._color_names.split():
 12 | 				setattr(self, attr, '')
 13 | 			for attr in self._attr_names.split():
 14 | 				setattr(self, attr, '')
 15 | 		else:
 16 | 			self.bright = '\033m\033[1m'
 17 | 			self.reset = '%s0m' % self.esc
 18 | 			i = 0
 19 | 			for name in self._color_names.split():
 20 | 				setattr(self, name, '%s0;3%dm' % (self.esc, i))
 21 | 				i += 1
 22 | 			i = 0
 23 | 			for name in self._attr_names.split():
 24 | 				setattr(self, name, '%s0;4%dm' % (self.esc, i))
 25 | 				i += 1
 26 | 
 27 | 		for name in self._color_names.split():
 28 | 			col = getattr(self, name)
 29 | 			setattr(self, 'bright_%s' % name, '%s%s' % (col, self.bright))
 30 | 		self.yellow = self.bright_brown
 31 | 		self.grey = self.bright_grey
 32 | 
 33 | 	def print_colors(self):
 34 | 		for name in self._color_names.split():
 35 | 			col = getattr(self, name)
 36 | 			print("%s%s\t%sbright_%s%s" % (col, name, self.bright, name, self.reset))
 37 | 		print("%syellow%s" % (self.yellow, self.reset))
 38 | 
 39 | 
 40 | color = ansi_color()
 41 | 
 42 | 
 43 | def time_delta(then, now=time.time()):
 44 | 	dvals = [('w', 604800), ('d', 86400), ('h', 3600), ('m', 60)]
 45 | 	ret = ''
 46 | 	seconds = now - then
 47 | 	if (seconds < 0):
 48 | 		seconds = then - now
 49 | 
 50 | 	for unit, div in dvals:
 51 | 		if seconds > div:
 52 | 			ret += "%d%s " % ((seconds / div), unit)
 53 | 			seconds %= div
 54 | 
 55 | 	ret += '%ds' % seconds
 56 | 	return ret
 57 | 
 58 | 
 59 | def strtobool(str):
 60 | 	str = str.lower()
 61 | 	if str == 'yes' or str == 'true' or str == 'on':
 62 | 		return True
 63 | 
 64 | 	if str.isdigit():
 65 | 		return int(str) != 0
 66 | 
 67 | 	return False
 68 | 
 69 | 
 70 | def mkdir_p(dirname, mode=0o777):
 71 | 	try:
 72 | 		os.makedirs(dirname, mode)
 73 | 	except OSError as exc:
 74 | 		if exc.errno == errno.EEXIST:
 75 | 			pass
 76 | 		else:
 77 | 			raise
 78 | 
 79 | def str_to_seconds(str):
 80 | 	multipliers = {'m': 60, 'h': 3600, 'd': 86400, 'w': 86400 * 7}
 81 | 	if str.isdigit():
 82 | 		return int(str)
 83 | 	suffix = str[-1].tolower()
 84 | 	multiplier = multipliers.get(suffix.tolower(), None)
 85 | 	if not str[:-1].isdigit() or multiplier == None:
 86 | 		return None
 87 | 	return int(str[:-1]) * multiplier
 88 | 
 89 | def find_in_path(basename):
 90 | 	path_ary = os.getenv(PATH).split(':')
 91 | 	for p in path_ary:
 92 | 		path = "%s/%s" % (p, basename)
 93 | 		if os.access(path, os.X_OK) and os.isfile(path):
 94 | 			return path
 95 | 
 96 | 	return False
 97 | 
 98 | def prettyprint_docstring(cmd, str, extra=False):
 99 | 	hlp = str.replace('\n\t', '\n').rstrip()
100 | 	hlp = hlp.replace('\n', '\n   ')
101 | 	print(" %s%s%s %s\n" % (color.green, cmd, color.reset, hlp))
102 | 	if extra != False:
103 | 		print("%s%s*** %s%s" % (color.yellow, color.bright, extra, color.reset))
104 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/merlin_db.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | conn = False
 4 | 
 5 | def connect(mconf, reuse_conn=True):
 6 | 	"""
 7 | 	Connects to the merlin database configured by the 'mconf'
 8 | 	object passed as its only argument and returns a connection handle
 9 | 	suitable for running queries against that database.
10 | 	"""
11 | 	global conn
12 | 
13 | 	if conn and reuse_conn:
14 | 		return conn
15 | 
16 | 	dbopts = getattr(mconf, 'dbopt', False)
17 | 	if dbopts == False:
18 | 		dbopts = mconf
19 | 
20 | 	db_host = mconf.dbopt.get('host', 'localhost')
21 | 	db_name = mconf.dbopt.get('name', 'merlin')
22 | 	db_user = mconf.dbopt.get('user', 'merlin')
23 | 	db_pass = mconf.dbopt.get('pass', 'merlin')
24 | 	db_type = mconf.dbopt.get('type', 'mysql')
25 | 	db_port = mconf.dbopt.get('port', False)
26 | 	db_conn_str = mconf.dbopt.get('conn_str', False)
27 | 
28 | 	# now we load whatever database driver is appropriate
29 | 	if db_type == 'mysql':
30 | 		try:
31 | 			import MySQLdb as db
32 | 		except ImportError:
33 | 			try:
34 | 				import pymysql as db
35 | 			except ImportError:
36 | 				print("Failed to import MySQLdb or PyMySQL")
37 | 				print("Install PyMySQL to make this command work")
38 | 				sys.exit(1)
39 | 		if db_pass == False:
40 | 			conn = db.connect(host=db_host, user=db_user, db=db_name)
41 | 		else:
42 | 			conn = db.connect(host=db_host, user=db_user, passwd=db_pass, db=db_name)
43 | 
44 | 	elif db_type in ['postgres', 'psql', 'pgsql']:
45 | 		try:
46 | 			import pgdb as db
47 | 		except:
48 | 			print("Failed to import pgdb")
49 | 			print("Install postgresql-python to make this command work")
50 | 			sys.exit(1)
51 | 		conn = db.connect(user=db_user, password=db_pass, host=db_host, database=db_name)
52 | 	else:
53 | 		print("Invalid database type selected: %s" % db_type)
54 | 		print("Cannot continue")
55 | 		sys.exit(1)
56 | 
57 | 	#print("Connecting to %s on %s with %s:%s as user:pass" %
58 | 	#	(db_name, db_host, db_user, db_pass))
59 | 	if not conn:
60 | 		conn = db.connect(host=db_host, user=db_user, passwd=db_pass, db=db_name)
61 | 
62 | 	return conn
63 | 
64 | def disconnect():
65 | 	global conn
66 | 	ret = conn.close()
67 | 	conn = False
68 | 	return ret
69 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/merlin_qh.py:
--------------------------------------------------------------------------------
 1 | import nagios_qh
 2 | from functools import cmp_to_key
 3 | 
 4 | def get_merlin_nodeinfo(query_handler):
 5 | 	def nodeinfo_sorter(a, b):
 6 | 		if a['name'] > b['name']:
 7 | 			return 1
 8 | 		if b['name'] > a['name']:
 9 | 			return -1
10 | 		return 0
11 | 	qh = nagios_qh.nagios_qh(query_handler)
12 | 	ninfo = []
13 | 	for info in qh.get('#merlin nodeinfo\0'):
14 | 		ninfo.append(info)
15 | 	ninfo.sort(key=cmp_to_key(nodeinfo_sorter))
16 | 	return ninfo
17 | 
18 | def get_expired(query_handler):
19 | 	def expired_cmp(a, b):
20 | 		res = (a['responsible'] > b['responsible']) - (a['responsible'] < b['responsible'])
21 | 		if res:
22 | 			return res
23 | 		if not a.get('service_description'):
24 | 			return -1
25 | 		if not b.get('service_description'):
26 | 			return 1
27 | 		return (a['service_description'] > b['service_description']) - (a['service_description'] < b['service_description'])
28 | 	qh = nagios_qh.nagios_qh(query_handler)
29 | 	expired = []
30 | 	for info in qh.get('#merlin expired\0'):
31 | 		expired.append(info)
32 | 	expired.sort(key=cmp_to_key(expired_cmp))
33 | 	return expired
34 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/merlin_status.py:
--------------------------------------------------------------------------------
 1 | import sys, os
 2 | 
 3 | import merlin_conf as mconf
 4 | from merlin_qh import get_merlin_nodeinfo
 5 | 
 6 | class merlin_status:
 7 | 	lsc = False
 8 | 	ni = False
 9 | 
10 | 	def __init__(self, lsc, qh):
11 | 		self.lsc = lsc
12 | 		nodes = get_merlin_nodeinfo(qh)
13 | 		if list(nodes)[0] == -1:
14 | 			sys.exit(1)
15 | 		self.ni = dict([(x['name'], x) for x in nodes])
16 | 
17 | 	def min_avg_max(self, table, col, filter=None):
18 | 		"""
19 | 		Fetch min, average and max from 'table',
20 | 		optionally filtering on instance_id, passed as 'iid'
21 | 		"""
22 | 		
23 | 		query = 'GET %ss\n' % table
24 | 		if filter:
25 | 			query += filter
26 | 		query += 'Stats: min %s\nStats: avg %s\nStats: max %s\n' % ((col,) * 3)
27 | 		row = self.lsc.query_row(query)
28 | 		ret = {'min': row[0], 'avg': row[1], 'max': row[2]}
29 | 		return ret
30 | 
31 | 	def sum_global(self, key):
32 | 		return sum([int(x.get(key)) for x in list(self.ni.values()) if x.get('type') in ('peer', 'local')])
33 | 
34 | 	def num_entries(self, table):
35 | 		"""
36 | 		Fetch the number of entries in 'table', optionally
37 | 		filtering on instance_id, passed as 'iid'	
38 | 		"""
39 | 		return self.sum_global(table+'_checks_handled')
40 | 
41 | 	def global_status(self):
42 | 		ret = {
43 | 			'checks_run': {
44 | 				'host': self.sum_global('host_checks_executed'),
45 | 				'service': self.sum_global('service_checks_executed'),
46 | 			},
47 | 			'latency': self.sum_global('latency')
48 | 		}
49 | 		return ret
50 | 
51 | 	def status(self, node_name=None):
52 | 		nodes = []
53 | 		for name, row in list(self.ni.items()):
54 | 			if node_name and node_name != row['instance_name']:
55 | 				continue
56 | 			if row['state'] == 'STATE_NONE':
57 | 				continue
58 | 			nodes.append(row)
59 | 			node = mconf.configured_nodes.get(name, False)
60 | 			# we read ourselves, or an unconfigured node
61 | 			if not node:
62 | 				nodes[-1]['in_config'] = False
63 | 		return nodes
64 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/nagios_plugin.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | STATE_OK = 0
 4 | OK = STATE_OK
 5 | STATE_WARNING = 1
 6 | WARNING = STATE_WARNING
 7 | STATE_CRITICAL = 2
 8 | CRITICAL = STATE_CRITICAL
 9 | STATE_UNKNOWN = 3
10 | UNKNOWN = STATE_UNKNOWN
11 | 
12 | def worst_state(a, b):
13 | 	if a == CRITICAL or b == CRITICAL:
14 | 		return CRITICAL
15 | 	if a == WARNING or b == WARNING:
16 | 		return WARNING
17 | 	return max(a, b)
18 | 
19 | 
20 | def best_state(a, b):
21 | 	val = worst_state(a, b)
22 | 	if val == a:
23 | 		return b
24 | 	return a
25 | 
26 | 
27 | def state_name(state):
28 | 	if state == OK:
29 | 		return "OK"
30 | 	if state == CRITICAL:
31 | 		return "CRITICAL"
32 | 	if state == WARNING:
33 | 		return "WARNING"
34 | 	if state == UNKNOWN:
35 | 		return "UNKNOWN"
36 | 	return "Unknown status %d" % state
37 | 
38 | 
39 | def state_code(state_name):
40 | 	str = state_name.lower()
41 | 	if str.startswith('c'):
42 | 		return CRITICAL
43 | 	if str.startswith('w'):
44 | 		return WARNING
45 | 	if str.startswith('o'):
46 | 		return OK
47 | 
48 | 	return UNKNOWN
49 | 
50 | 
51 | def unknown(msg):
52 | 	die(UNKNOWN, msg)
53 | 
54 | 
55 | def ok(msg):
56 | 	die(OK, msg)
57 | 
58 | 
59 | def die(state, msg):
60 | 	print("%s: %s" % (state_name(state), msg))
61 | 	sys.exit(state)
62 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/nagios_qh.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | import socket
 3 | 
 4 | class nagios_qh:
 5 | 	__slots__ = ['query_handler', 'socket', 'read_size']
 6 | 
 7 | 	def __init__(self, query_handler=None):
 8 | 		self.read_size = 4096
 9 | 		self.socket = False
10 | 		if not query_handler:
11 | 			self.query_handler = False
12 | 		else:
13 | 			self.query_handler = query_handler
14 | 
15 | 	def query(self, query):
16 | 		"""Ask a raw query to nagios' query handler socket, return the raw
17 | 		response as a lazily generated sequence."""
18 | 		if not query:
19 | 			print("Missing query argument")
20 | 			return
21 | 		try:
22 | 			self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
23 | 			self.socket.connect(self.query_handler)
24 | 
25 | 			self.socket.send(str(query + '\0').encode())
26 | 			while True:
27 | 				try:
28 | 					out = self.socket.recv(self.read_size)
29 | 					if not out:
30 | 						break
31 | 					yield out.decode()
32 | 				except KeyboardInterrupt:
33 | 					print("Good bye.")
34 | 					break
35 | 			self.socket.close()
36 | 		except socket.error as e:
37 | 			print("Couldn't connect to nagios socket %s: %s" % (self.query_handler, str(e)))
38 | 
39 | 	def format(self, data, rowsep='\n', pairsep=';', kvsep='='):
40 | 		"""Lazily format a response into a sequence of dicts"""
41 | 		for row in [_f for _f in ''.join(data).split(rowsep) if _f]:
42 | 			if row == "404: merlin: No such handler":
43 | 				print("ERROR: Could not get nodeinfo. See /var/log/op5/merlin/neb.log for more information")
44 | 				yield -1
45 | 				break
46 | 			else:
47 | 				yield dict(x.split(kvsep, 1) for x in row.split(pairsep))
48 | 
49 | 	def get(self, query, rowsep='\n', pairsep=';', kvsep='='):
50 | 		"""Ask a query to nagios' query handler socket, and return an object
51 | 		representing a "standard" nagios qh response"""
52 | 		resp = self.query(query)
53 | 		return self.format(resp, rowsep, pairsep, kvsep)
54 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/pytap/ttest.py:
--------------------------------------------------------------------------------
 1 | from pytap import *
 2 | #import pytapunit
 3 | 
 4 | def run(tap):
 5 | 	tap.print_header('pytap sub example')
 6 | 	tap.ok(True, "Passing test")
 7 | 	tap.ok(False, "Failing test")
 8 | 	tap.ok(False, "Failing test with string type diag output")
 9 | 	tap.diag("This is a diagnostics string")
10 | 	tap.ok_eq(1, False, "Passing test with bool type diag output")
11 | 	tap.diag({'multi': {'dimensional': {'python array': 'with value'}}})
12 | 	tap.diag(False)
13 | 	tap.ok(False, "Known breakage", tap.TODO)
14 | 	tap.ok(False, "A single (failed) skipped test", tap.SKIP)
15 | 	tap.ok(True, "'fixed' test", tap.TODO)
16 | 	tap.ok(9, "Buggy test")
17 | 	tap.ok(9 != False, "No longer buggy test")
18 | 	tap.ok_type({}, {'nisse': True}, 'An array is an array')
19 | 	tap.ok(1 == 1, "1 and 1 are equal")
20 | 	tap.ok(1 == "nisse", "A failed test")
21 | 	tap.ok_eq(1, "nisse", "knowingly failed test", tap.TODO)
22 | 	tap.skip_start()
23 | 	tap.ok(True, "Skipping OK test")
24 | 	tap.ok_eq(1, "nisse", "Skipping failed test")
25 | 	tap.ok_eq(1, "nisse", "Skipping todo test", tap.TODO)
26 | 	tap.skip_end()
27 | 	tap.skip_start('Skipping 1 test with a reason', 1)
28 | 	tap.ok_eq(1, "nisse", "This output should be hidden")
29 | 	return tap.done()
30 | 
31 | tap = pytap("Basic tests")
32 | tap.verbose = 1
33 | sub = tap.sub_init()
34 | run(sub)
35 | tap.ok_eq(1, 1, "1 and 1 are equal")
36 | tap.ok_eq(1, 0, "1 and 0 aren't equal")
37 | #tap.show_colors()
38 | sub = tap.sub_init('fully ok subsuite')
39 | for i in range(1, 15):
40 | 	sub.ok(i == i, "%d == %d" % (i, i))
41 | sub.done()
42 | sub = tap.sub_init('mostly fixed subsuite')
43 | for i in range(1, 5):
44 | 	sub.ok(i == i & 3, "i = %d; Handling up to 3 with a bitmask of 3" % i, tap.TODO)
45 | sub.done()
46 | tap.verbose = 2
47 | tap.ok_eq(1, 0, "Skipped failed test, (tap.verbose = 2)", tap.SKIP)
48 | tap.done()
49 | sys.exit(0)
50 | 


--------------------------------------------------------------------------------
/apps/libexec/modules/test/test_nagios_qh.py:
--------------------------------------------------------------------------------
 1 | from modules.nagios_qh import nagios_qh
 2 | 
 3 | 
 4 | def test_format_one_block_one_row_one_value():
 5 |     n = nagios_qh(None)
 6 |     result = list(n.format(["test=1"]))
 7 |     assert result == [{"test": "1"}], "Unexpected result %s" % result
 8 | 
 9 | 
10 | def test_format_one_block_one_row_two_values():
11 |     n = nagios_qh(None)
12 |     result = list(n.format(["test=1;test2=13"]))
13 |     assert result == [{"test": "1", "test2": "13"}], "Unexpected result %s" % result
14 | 
15 | 
16 | def test_format_no_block():
17 |     n = nagios_qh(None)
18 |     result = list(n.format([]))
19 |     assert result == [], "Unexpected result %s" % result
20 | 
21 | 
22 | def test_format_one_block_two_rows_two_values():
23 |     n = nagios_qh(None)
24 |     result = list(n.format(["test=1\ntest2=13"]))
25 |     assert result == [{"test": "1"}, {"test2": "13"}], "Unexpected result %s" % result
26 | 
27 | 
28 | def test_format_one_block_two_rows_three_values():
29 |     n = nagios_qh(None)
30 |     result = list(n.format(["test=1\ntest2=13;test3=42"]))
31 |     assert result == [{"test": "1"}, {"test2": "13", "test3": "42"}], "Unexpected result %s" % result
32 | 
33 | 
34 | def test_format_one_block_three_rows_two_values():
35 |     n = nagios_qh(None)
36 |     result = list(n.format(["test=1\n\ntest2=13"]))
37 |     assert result == [{"test": "1"}, {"test2": "13"}], "Unexpected result %s" % result
38 | 
39 | 
40 | def test_format_two_blocks_one_row_one_value():
41 |     n = nagios_qh(None)
42 |     result = list(n.format(["test", "=1"]))
43 |     assert result == [{"test": "1"}], "Unexpected result %s" % result
44 | 
45 | 
46 | def test_format_two_blocks_one_row_two_values():
47 |     n = nagios_qh(None)
48 |     result = list(n.format(["test", "=1", ";test2=2"]))
49 |     assert result == [{"test": "1", "test2": "2"}], "Unexpected result %s" % result
50 | 
51 | 
52 | def test_format_two_blocks_two_rows_two_values():
53 |     n = nagios_qh(None)
54 |     result = list(n.format(["test=1", "\ntest2=2"]))
55 |     assert result == [{"test": "1"}, {"test2": "2"}], "Unexpected result %s" % result
56 | 


--------------------------------------------------------------------------------
/apps/libexec/qh.py:
--------------------------------------------------------------------------------
 1 | import os, sys
 2 | import compound_config as cconf
 3 | 
 4 | from nagios_qh import nagios_qh
 5 | from merlin_apps_utils import *
 6 | 
 7 | qh = False
 8 | single = False
 9 | 
10 | def module_init(args):
11 | 	global qh
12 | 	global single
13 | 	rem_args = []
14 | 	comp = cconf.parse_conf(nagios_cfg)
15 | 	for v in comp.params:
16 | 		if v[0] == 'query_socket':
17 | 			qh = v[1]
18 | 			break
19 | 	for arg in args:
20 | 		if arg.startswith('--socket='):
21 | 			qh = arg.split('=', 1)[1]
22 | 			continue
23 | 		if arg == '--single':
24 | 			single = True
25 | 			continue
26 | 		rem_args.append(arg)
27 | 
28 | 	if not qh:
29 | 		if os.access(nagios_cfg, os.R_OK):
30 | 			comp = cconf.parse_nagios_cfg(nagios_cfg)
31 | 			qh = comp.query_socket
32 | 		else:
33 | 			print("ERROR: Unable to find Naemon query socket")
34 | 			return 1
35 | 
36 | 	return rem_args
37 | 
38 | 
39 | def args_to_query(args):
40 | 	if not len(args):
41 | 		return False
42 | 
43 | 	# one-shot queries are default
44 | 	if args[0][0] != '#' and args[0][0] != '@':
45 | 		args[0] = '#' + args[0]
46 | 
47 | 	return ' '.join(args)
48 | 
49 | 
50 | def cmd_query(args):
51 | 	"""--socket=</path/to/query-socket> --single <query>
52 | 	Runs an arbitrary query with the nagios query handler and prints its
53 | 	raw output. Queries need not include the trailing nulbyte or leading
54 | 	hash- or at-sign.
55 | 	"""
56 | 	handler = nagios_qh(qh)
57 | 	query = args_to_query(args)
58 | 	if not query:
59 | 		prettyprint_docstring('query', cmd_query.__doc__, 'Not enough arguments')
60 | 		return
61 | 	for block in handler.query(query):
62 | 		print(block, end=' ')
63 | 		sys.stdout.flush()
64 | 		if single:
65 | 			return
66 | 
67 | def cmd_get(args):
68 | 	"""--socket=</path/to/query-socket> <query>
69 | 	Runs an arbitrary query with the nagios query handler and pretty-prints
70 | 	the output. Queries need not include the trailing nulbyte or leading
71 | 	hash- or at-sign.
72 | 	"""
73 | 	handler = nagios_qh(qh)
74 | 	query = args_to_query(args)
75 | 	if not query:
76 | 		prettyprint_docstring('get', cmd_get.__doc__, 'Not enough arguments')
77 | 		return
78 | 	resp = handler.query(query)
79 | 	try:
80 | 		for row in handler.format(resp):
81 | 			for pair in list(row.items()):
82 | 				print("%-25s %s" % pair)
83 | 			print("")
84 | 	except ValueError as v:
85 | 		print("WARNING: Couldn't format response, printing raw response:\n")
86 | 		cmd_query(args)
87 | 


--------------------------------------------------------------------------------
/apps/libexec/query.lsq.sh.in:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -n "$LS_SOCK" ] || LS_SOCK='@ls_socket@'
 4 | 
 5 | if [ -n "$1" ]; then
 6 |   printf '%s\n' "$1" | unixcat "$LS_SOCK"
 7 | else
 8 |   unixcat "$LS_SOCK"
 9 | fi
10 | 


--------------------------------------------------------------------------------
/apps/libexec/reportdata.py.in:
--------------------------------------------------------------------------------
 1 | import os, sys
 2 | import time
 3 | import subprocess
 4 | import merlin_db
 5 | 
 6 | LS_SOCK='@ls_socket@'
 7 | 
 8 | def cmd_check_consistency(args):
 9 | 	"""
10 | 	Check for consistency errors in report_data.
11 | 
12 | 	This command outputs any consistency errors if the latest entry for a
13 | 	host/service in the report_data table does not match the current
14 | 	livestatus state.
15 | 	"""
16 | 
17 | 	dbc = merlin_db.connect(mconf).cursor()
18 | 
19 | 	dbc.execute("SELECT A.ID, A.timestamp, A.host_name, A.service_description, state \
20 | 			FROM report_data A\
21 | 			INNER JOIN (SELECT max(timestamp) TS, host_name, service_description\
22 | 				FROM report_data\
23 | 				GROUP BY host_name, service_description) B\
24 | 			ON A.timestamp = B.TS\
25 | 			AND A.host_name = B.host_name\
26 | 			AND A.service_description = B.service_description\
27 | 			WHERE event_type NOT IN (1000,1001,1103,1104,100,103)")
28 | 
29 | 	rows = dbc.fetchall()
30 | 
31 | 	errors=0
32 | 	for row in rows:
33 | 		id=row[0]
34 | 		timestamp=row[1]
35 | 		host_name=row[2]
36 | 		service_description=row[3]
37 | 		state=row[4]
38 | 		QRES=""
39 | 		try:
40 | 			if service_description:
41 | 				ls_query="GET services\nColumns: last_hard_state\nFilter: host_name = " + host_name + "\nFilter: description = " + service_description
42 | 				ls_state=subprocess.Popen("echo \"" + ls_query + "\" | unixcat " + LS_SOCK, shell=True, stdout=subprocess.PIPE, text=True).stdout.read()
43 | 				if (int(state) != int(ls_state)):
44 | 					print("ERROR: " + host_name + ";" + service_description + " : db_state=" + str(state) + " ls_state: " + ls_state.rstrip())
45 | 					errors=errors+1
46 | 			elif host_name:
47 | 				ls_query="GET hosts\nColumns: last_hard_state\nFilter: host_name = " + host_name
48 | 				ls_state=subprocess.Popen("echo \"" + ls_query + "\" | unixcat " + LS_SOCK, shell=True, stdout=subprocess.PIPE, text=True).stdout.read()
49 | 				if (int(state) != int(ls_state)):
50 | 					print("ERROR: " + host_name + " : db_state=" + str(state) + " ls_state: " + ls_state.rstrip())
51 | 					errors=errors+1
52 | 		# probably means state or ls_state is not an int, so we just continue
53 | 		except ValueError as e:
54 | 			continue
55 | 
56 | 	merlin_db.disconnect()
57 | 	if (errors == 0):
58 | 		print("OK")
59 | 		return True
60 | 	else:
61 | 		print("Errors: {}".format(errors))
62 | 		return False
63 | 


--------------------------------------------------------------------------------
/apps/libexec/restart.sh.in:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Fix object config (does nothing if we're not a poller)
 4 | mon oconf poller-fix
 5 | 
 6 | # Check if we are running systemd first
 7 | if [[ -x /run/systemd/system ]]; then
 8 |     # This script might be called from a Naemon worker process.
 9 |     # As a result, if we do a stop and start of naemon seperatly, it might happen
10 |     # that this script is killed before we issue the start command. Hence monitor
11 |     # ends up in a stopped state. Calling restart fixes this issue.
12 |     # However for some reason the service restart command does not exists until
13 |     # we have called service stop of either merlin or naemon. Therefore we first
14 |     # restart merlin with seperate commands, and thereafter restart naemon.
15 |     /bin/systemctl stop merlind && /bin/systemctl start merlind
16 |     /bin/systemctl restart naemon
17 |     if systemctl list-units --full -all | grep -Fq "op5-monitor.service"; then
18 |         /bin/systemctl start op5-monitor
19 |     fi
20 | else
21 |     # If not running in systemd send a SIGHUP to the oldest naemon proc
22 |     pkill --signal SIGHUP -o -f /usr/bin/naemon
23 | fi
24 | 


--------------------------------------------------------------------------------
/apps/libexec/sshkey.fetch.sh.in:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | 
  3 | naemon_user='@naemon_user@'
  4 | naemon_user_home=$(eval echo ~$naemon_user)
  5 | 
  6 | get_val ()
  7 | {
  8 | 	expr "z$1" : 'z[^=]*=\(.*\)'
  9 | }
 10 | 
 11 | grab_key() {
 12 | 	ssh "$1" -C '
 13 | dir=$HOME/.ssh
 14 | test -d $dir || mkdir -m 700 $dir
 15 | for f in id_rsa id_dsa identity; do
 16 | 	if test -f $dir/$f; then
 17 | 		keyfile=$dir/$f.pub
 18 | 		break
 19 | 	fi
 20 | done
 21 | 
 22 | if ! test -f "$keyfile"; then
 23 | 	keyfile=$dir/id_rsa
 24 | 	ssh-keygen -q -f $keyfile -t rsa -b 2048 -N "" > /dev/null
 25 | 	keyfile=$keyfile.pub
 26 | fi
 27 | 
 28 | cat $keyfile
 29 | '
 30 | }
 31 | 
 32 | usage()
 33 | {
 34 | 	cat << END_OF_HELP
 35 | [--outfile=<outfile>] [--all|--type=<peer|poller|master>] [source]..
 36 | Fetches public SSH keys from specified remote node(s) (sources).
 37 | 
 38 | The keys will be written to the specified outfile, or if not
 39 | specified, default to: ~/.ssh/authorized_keys
 40 | 
 41 | If no key exists on any of the specified remote nodes, a new key
 42 | will be generated automatically.
 43 | 
 44 | A combination of different node types as well as specific nodes
 45 | can be specified at the same time.
 46 | 
 47 | END_OF_HELP
 48 | 
 49 | 	exit # since the script wont need to do anything more
 50 | }
 51 | 
 52 | outfile= destinations=
 53 | while test "$#" -ne 0; do
 54 | 	case "$1" in
 55 | 	--outfile=*|-o=)
 56 | 		outfile=$(get_val "$1")
 57 | 	;;
 58 | 	--outfile|-o)
 59 | 		shift
 60 | 		outfile="$1"
 61 | 	;;
 62 | 	--help|-h)
 63 | 		usage
 64 | 	;;
 65 | 	--all)
 66 | 		more_dest=$(mon node show | sed -n 's/^ADDRESS=//p')
 67 | 		destinations="$destinations $more_dest"
 68 | 	;;
 69 | 	--type=*)
 70 | 		more_dest=$(mon node show "$1" | sed -n 's/^ADDRESS=//p')
 71 | 		destinations="$destinations $more_dest"
 72 | 	;;
 73 | 	*)
 74 | 		destinations="$destinations $1"
 75 | 	;;
 76 | 	esac
 77 | 	shift
 78 | done
 79 | 
 80 | if test -z "$outfile"; then
 81 | 	outfile=~/.ssh/authorized_keys
 82 | fi
 83 | if ! test -w "$outfile"; then
 84 | 	mkdir -p -m 700 "$outfile"
 85 | 	rm -rf $outfile
 86 | 	chmod 700 $(dirname "$outfile")
 87 | fi
 88 | 
 89 | test "$destinations" || usage
 90 | 
 91 | add_key_locally()
 92 | {
 93 | 	src="$1"
 94 | 	key=$(grab_key $src)
 95 | 	if grep -q "$key" "$outfile"; then
 96 | 		echo "We already have that key in $outfile"
 97 | 	else
 98 | 		echo "Successfully fetched key from $src to $outfile"
 99 | 		echo "$key" >> "$outfile"
100 | 	fi
101 | }
102 | 
103 | add_key_for_all()
104 | {
105 | 	# if we're root, we should setup
106 | 	# root->root, root->naemon_user, naemon_user->naemon_user
107 | 	# without doing naemon_user->root
108 | 	if [ "`whoami`" == "root" ]; then
109 | 		export -f add_key_locally grab_key
110 | 		su $naemon_user --session-command "export outfile=$naemon_user_home/.ssh/authorized_keys; add_key_locally $1"
111 | 		su $naemon_user --session-command "export outfile=$naemon_user_home/.ssh/authorized_keys; add_key_locally root@$1"
112 | 	fi
113 | 	add_key_locally $1
114 | }
115 | 
116 | for dest in $destinations; do
117 | 	echo "Fetching public key from $dest"
118 | 	case "$dest" in
119 | 	*@*)
120 | 		add_key_locally "$dest"
121 | 	;;
122 | 	*)
123 | 		add_key_for_all "$dest"
124 | 	;;
125 | 	esac
126 | done
127 | 
128 | chmod 600 "$outfile"
129 | 


--------------------------------------------------------------------------------
/apps/libexec/start.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Fix object config (does nothing if we're not a poller)
 4 | mon oconf poller-fix
 5 | 
 6 | /bin/systemctl start merlind
 7 | /bin/systemctl start naemon
 8 | if systemctl list-units --full -all | grep -Fq "op5-monitor.service"; then
 9 |     /bin/systemctl start op5-monitor
10 | fi
11 | 


--------------------------------------------------------------------------------
/apps/libexec/status.py:
--------------------------------------------------------------------------------
 1 | import os, sys
 2 | import time
 3 | 
 4 | import merlin_db
 5 | 
 6 | def cmd_install_time(args):
 7 | 	"""
 8 | 	Print the time the system first recorded an event, as a unix timestamp.
 9 | 
10 | 	If no event is recorded, assume an event will happen quite soon, so print
11 | 	the current tiemstamp instead
12 | 	"""
13 | 	starttime = int(time.time())
14 | 
15 | 	dbc = merlin_db.connect(mconf).cursor()
16 | 
17 | 	dbc.execute('SELECT MIN(timestamp) FROM report_data')
18 | 	for (tstamp,) in dbc:
19 | 		if tstamp:
20 | 			starttime = tstamp
21 | 
22 | 	merlin_db.disconnect()
23 | 
24 | 	print(starttime)
25 | 


--------------------------------------------------------------------------------
/apps/libexec/stop.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | /bin/systemctl stop naemon
4 | /bin/systemctl stop merlind
5 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/.gitignore:
--------------------------------------------------------------------------------
1 | proc_merlind.sh
2 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/db_mysql_check.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Detects errors in the merlin and nacoma database using mysqlcheck.'
 2 | handler_exec()
 3 | {
 4 |   depchk grep mysqlcheck
 5 |   # Sourced cmd_exec() will execute the given command line and store the output
 6 |   # text in $OUT. Should the command not return zero, the script will exit.
 7 |   cmd_exec mysqlcheck -q -s --databases merlin nacoma
 8 | 
 9 |   errors="$(printf '%s\n' "$OUT" | grep -Ei -B1 '^error[[:space:]]*:')"
10 | 
11 |   if [ -z "$errors" ]; then
12 |     ret='0'
13 |     msg='No errors detected.'
14 |   else
15 |     ret='2'
16 |     msg='Error(s) detected.'
17 |     msg+=$'\n'"$OUT"
18 |   fi
19 | 
20 |   dieplug "$ret" "$msg"
21 | }
22 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/fs_ext_state.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks if any mounted ext-based filesystems are non-clean.'
 2 | handler_exec()
 3 | {
 4 |   depchk cut grep tune2fs
 5 | 
 6 |   msg=''
 7 |   while read -r dev mnt fs opts _; do
 8 |     [[ $fs =~ ^ext[234]$ ]] || continue
 9 | 
10 |     read -r state < \
11 |       <(tune2fs -l "$dev" 2>&1 | grep '^Filesystem state:' | cut -d: -f2)
12 | 
13 |     [ "$state" == 'clean' ] || \
14 |       msg+=", $dev is not clean"
15 | 
16 |   done < /proc/mounts
17 | 
18 |   if [ -n "$msg" ]; then
19 |     dieplug '2' "${msg:2}" # Strip first two characters of msg (, ).
20 |   else
21 |     dieplug '0' "No problems detected."
22 |   fi
23 | }
24 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/fs_free_inodes.sh:
--------------------------------------------------------------------------------
1 | handler_desc='Checks all locally mounted filesystems for low amounts of free inodes.'
2 | handler_exec()
3 | {
4 |   PATH="/opt/plugins:$PATH"
5 |   depchk check_disk
6 | 
7 |   check_disk -W 10% -K 5% -L -A -v
8 | }
9 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/fs_free_space.sh:
--------------------------------------------------------------------------------
1 | handler_desc='Checks all locally mounted filesystems for low amounts of free space.'
2 | handler_exec()
3 | {
4 |   PATH="/opt/plugins:$PATH"
5 |   depchk check_disk
6 | 
7 |   check_disk -w 10% -c 5% -L -A -v
8 | }
9 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/fs_mount_opts.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks for possibly invalidly mounted filesystems.'
 2 | handler_exec()
 3 | {
 4 |   msg=''
 5 |   while read -r dev mnt fs opts _; do
 6 |     [[ $fs =~ ^(ext[234]|tmpfs|xfs)$ ]] || continue
 7 | 
 8 |     bad=''
 9 |     while read -d, -r opt; do
10 |       [[ $opt =~ ^noexec|nosuid|ro$ ]] || continue
11 |       bad+=" $opt"
12 |     done <<< "$opts,"
13 | 
14 |     [ -n "$bad" ] && \
15 |       msg+=$'\n'"$dev ($fs) at $mnt (opts:$bad)"
16 |   done < /proc/mounts
17 | 
18 |   if [ -n "$msg" ]; then
19 |     dieplug '2' "Mount problems detected.$msg"
20 |   else
21 |     dieplug '0' "No problems detected."
22 |   fi
23 | }
24 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/license.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Verifies that the OP5 license file is installed and valid for more than 14 days.'
 2 | handler_exec()
 3 | {
 4 |   /opt/plugins/check_op5_license -T d -w 14 -c 14 &> /dev/null
 5 |   if [ $? -eq 0 ]; then
 6 |     dieplug '0' 'OP5 license check reports license valid for >14 days.'
 7 |   else
 8 |     dieplug '2' 'OP5 license check reports license invalid, or valid for less than 14 days!'
 9 |   fi
10 | }
11 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_collector.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Trapper collector daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/opt/trapper/bin/collector -On -c /opt/trapper/etc/collector.conf -A -Lsd -p /opt/trapper/var/run/collector.run'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/opt/trapper/var/run/collector.run'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_crond.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the cron daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='crond'
 5 |   cmdline_sles='/usr/sbin/cron'
 6 |   lockfile_rhel='/var/run/crond.pid'
 7 |   lockfile_sles='/var/run/cron.pid'
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_httpd.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the Apache HTTP server processes.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/sbin/httpd'
 5 |   cmdline_sles='/usr/sbin/httpd2-prefork -f /etc/apache2/httpd.conf -DSSL'
 6 |   lockfile_rhel='/var/run/httpd/httpd.pid'
 7 |   lockfile_sles='/var/run/httpd2.pid'
 8 |   max='50'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_merlind.sh.in:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Merlin daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/merlind -c /opt/monitor/op5/merlin/merlin.conf'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='@pkgrundir@/merlin.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_monitor_core.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Monitor core daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/opt/monitor/bin/monitor -d /opt/monitor/etc/nagios.cfg'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/opt/monitor/var/nagios.lock'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='2'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_monitor_worker.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Monitor core worker daemons'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/opt/monitor/bin/monitor --worker /opt/monitor/var/rw/nagios.qh'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel=''
 7 |   lockfile_sles=''
 8 |   max='100'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_mysqld.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the MySQL daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/libexec/mysqld --basedir=/usr --datadir=/var/lib/mysql --user=mysql --log-error=/var/log/mysqld.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/lib/mysql/mysql.sock'
 5 |   cmdline_sles='/usr/sbin/mysqld --basedir=/usr --datadir=/var/lib/mysql --user=mysql --pid-file=/var/lib/mysql/mysqld.pid --skip-external-locking --port=3306 --socket=/var/lib/mysql/mysql.sock'
 6 |   lockfile_rhel='/var/run/mysqld/mysqld.pid'
 7 |   lockfile_sles='/var/lib/mysql/mysqld.pid'
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_npcd.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the performance data processing daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/opt/monitor/bin/npcd -d -f /opt/monitor/etc/pnp/npcd.cfg'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/var/run/npcd.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_ntpd.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the Network Time Protocol daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='ntpd -u ntp:ntp -p /var/run/ntpd.pid -g'
 5 |   cmdline_sles='/usr/sbin/ntpd -p /var/run/ntp/ntpd.pid -g -u ntp:ntp -i /var/lib/ntp -c /etc/ntp.conf'
 6 |   lockfile_rhel='/var/run/ntpd.pid'
 7 |   lockfile_sles='/var/run/ntp/ntpd.pid'
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_op5config.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Portal configuration daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/php -q /opt/op5sys/bin/config-daemon.php -p /var/run/op5config.pid -d'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/var/run/op5config.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_op5kad.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Keepalive daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/python /usr/bin/op5kad -c /etc/op5kad/kad.conf'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/var/run/op5kad.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_pgsql_postmaster.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the PostgreSQL database server.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/postmaster -p 5432 -D /var/lib/pgsql/data'
 5 |   cmdline_sles='/usr/lib/postgresql84/bin/postgres -D /var/lib/pgsql/data'
 6 |   lockfile_rhel='/var/run/postmaster.5432.pid'
 7 |   lockfile_sles='/var/lib/pgsql/data/postmaster.pid'
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_processor.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Trapper processor daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/processor -c /etc/processor/processor.conf'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/opt/trapper/var/run/processor.run'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_rrdcached.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the RRD caching daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/rrdcached -p /opt/monitor/var/rrdtool/rrdcached/rrdcached.pid -m 0777 -l unix:/opt/monitor/var/rrdtool/rrdcached/rrdcached.sock -b /opt/monitor/var/rrdtool/rrdcached -P FLUSH,PENDING -z 1800 -w 1800 -s root -j /opt/monitor/var/rrdtool/rrdcached/spool -p /opt/monitor/var/rrdtool/rrdcached/rrdcached.pid'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/opt/monitor/var/rrdtool/rrdcached/rrdcached.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_smsd.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the SMS gateway daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/sbin/smsd'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/var/run/smsd/smsd.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='2'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_synergy.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the op5 Business Services daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/usr/bin/lua /opt/synergy/bin/synergy --monitor'
 5 |   cmdline_sles='/usr/bin/lua5.1 /opt/synergy/bin/synergy --monitor'
 6 |   lockfile_rhel='/opt/synergy/var/run/processor.run'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/syscheck/proc_syslog_ng.sh:
--------------------------------------------------------------------------------
 1 | handler_desc='Checks the process state of the syslog-ng daemon.'
 2 | handler_exec()
 3 | {
 4 |   cmdline_rhel='/sbin/syslog-ng -p /var/run/syslog-ng.pid'
 5 |   cmdline_sles="$cmdline_rhel"
 6 |   lockfile_rhel='/var/run/syslog-ng.pid'
 7 |   lockfile_sles="$lockfile_rhel"
 8 |   max='1'
 9 | 
10 |   # continue processing by sourcing the generic proc script
11 |   . "$base_dir/bash/syscheck.proc.sh"
12 | }
13 | 


--------------------------------------------------------------------------------
/apps/libexec/tests/test_merlin_qh.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import os
 4 | import sys
 5 | import unittest
 6 | from unittest.mock import patch
 7 | from unittest.mock import MagicMock
 8 | 
 9 | sys.path.append('modules')
10 | 
11 | from modules.merlin_qh import get_expired 
12 | 
13 | class merlin_qh_test(unittest.TestCase):
14 |     @patch('nagios_qh.nagios_qh')  
15 |     def test_get_expired(self, mock_nagios_qh):
16 |         # Configure the mock to return a specific value if needed
17 |         mock_nagios_qh.return_value = MagicMock()
18 |         mock_nagios_qh.return_value.get.return_value = [
19 |             {
20 |                 'host_name': 'example_host',
21 |                 'service_description': 'example_service02',
22 |                 'added': 'example_date',
23 |                 'responsible': 'peer02'
24 |             },
25 |             {
26 |                 'host_name': 'example_host',
27 |                 'service_description': 'example_service01',
28 |                 'added': 'example_date',
29 |                 'responsible': 'peer02'
30 |             },
31 |             {
32 |                 'host_name': 'example_host',
33 |                 'added': 'example_date',
34 |                 'responsible': 'peer02'
35 |             },
36 |             {
37 |                 'host_name': 'example_host',
38 |                 'added': 'example_date',
39 |                 'responsible': 'peer01'
40 |             },
41 |             {
42 |                 'host_name': 'example_host',
43 |                 'service_description': 'example_service03',
44 |                 'added': 'example_date',
45 |                 'responsible': 'peer01'
46 |             },
47 |         ]
48 | 
49 |         expected = [
50 |             {
51 |                 'host_name': 'example_host',
52 |                 'added': 'example_date',
53 |                 'responsible': 'peer01'
54 |             },
55 |             {
56 |                 'host_name': 'example_host',
57 |                 'service_description': 'example_service03',
58 |                 'added': 'example_date',
59 |                 'responsible': 'peer01'
60 |             },
61 |             {
62 |                 'host_name': 'example_host',
63 |                 'added': 'example_date',
64 |                 'responsible': 'peer02'
65 |             },
66 |             {
67 |                 'host_name': 'example_host',
68 |                 'service_description': 'example_service01',
69 |                 'added': 'example_date',
70 |                 'responsible': 'peer02'
71 |             },
72 |             {
73 |                 'host_name': 'example_host',
74 |                 'service_description': 'example_service02',
75 |                 'added': 'example_date',
76 |                 'responsible': 'peer02'
77 |             },
78 |         ]
79 | 
80 |         # Call the function you're testing
81 |         result = get_expired("mockedvalue")
82 | 
83 |         # Assert that nagios_qh.nagios_qh was called with the expected arguments
84 |         mock_nagios_qh.assert_called_once_with('mockedvalue')  # Replace with the actual argument
85 | 
86 |         # Further assertions depending on what my_function does and what you expect
87 |         self.assertEqual(result, expected)
88 | 
89 | if __name__ == '__main__':
90 |     unittest.main()
91 | 


--------------------------------------------------------------------------------
/apps/tests/oconf-poller-fix/test.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | self_path=${0%/*}
 4 | test $self_path = "test.sh" && self_path=.
 5 | 
 6 | mon=$self_path/../../mon.py
 7 | libexecdir=${mon%/*}/libexec
 8 | 
 9 | cwd=$(pwd)
10 | echo "self_path=$self_path"
11 | echo "cwd=$cwd"
12 | cp $self_path/test-config.cfg $self_path/fixme.cfg
13 | # Running this command twice should still result in the same output file
14 | cmd="python3.9 $mon
15 | 	--libexecdir=$libexecdir
16 | 	--merlin-cfg=$self_path/merlin.conf
17 | 	--nagios-conf=$self_path/fixme.cfg
18 | 	oconf poller-fix $self_path/fixme.cfg"
19 | 
20 | $cmd || exit 1
21 | diff -u $self_path/fixme.cfg $self_path/fixed-config.cfg
22 | result1=$?
23 | 
24 | cp $self_path/fixed-config.cfg $self_path/fixed-config.cfg-first
25 | $cmd || exit 1
26 | diff -u $self_path/fixed-config.cfg-first $self_path/fixed-config.cfg
27 | result2=$?
28 | 
29 | if test $result1 -ne 0; then
30 | 	echo "fail: Files differ" >&2
31 | 	exit 1
32 | fi
33 | if test $result2 -ne 0; then
34 | 	echo "fail: Files differ after second pass" >&2
35 | 	exit 1
36 | fi
37 | 


--------------------------------------------------------------------------------
/autogen.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | autoreconf -si
4 | ./configure --enable-silent-rules "$@"
5 | 


--------------------------------------------------------------------------------
/daemon/daemonize.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_daemonize_h__
 2 | #define INCLUDE_daemonize_h__
 3 | 
 4 | #define DMNZ_NOFORK  1
 5 | #define DMNZ_CHROOT (1 << 1)
 6 | #define DMNZ_SIGS   (1 << 2)
 7 | 
 8 | extern int kill_daemon(const char *pidfile);
 9 | extern int daemon_status(const char *pidfile);
10 | extern int daemonize(const char *runas, const char *jail,
11 |                      const char *pidfile, int flags);
12 | extern void daemon_shutdown(void);
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/daemon/db_updater.h:
--------------------------------------------------------------------------------
1 | #ifndef INCLUDE_db_updater_h__
2 | #define INCLUDE_db_updater_h__
3 | #include "node.h"
4 | 
5 | int mrm_db_update(merlin_node *node, merlin_event *pkt);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/daemon/db_wrap_dbi.h:
--------------------------------------------------------------------------------
 1 | #if !defined(_MERLIN_DB_WRAP_DBI_H_INCLUDED)
 2 | #define _MERLIN_DB_WRAP_DBI_H_INCLUDED 1
 3 | 
 4 | #include "db_wrap.h"
 5 | #include <dbi/dbi.h>
 6 | /*
 7 |   typedef void * dbi_conn;
 8 |   typedef void * dbi_result;
 9 | */
10 | 
11 | /**
12 |    Initializes a db_wrap object using a libdbi backend.
13 | 
14 |    conn must be an initalized libdbi connection object.  On success,
15 |    ownership of that connection object is passed to the returned
16 |    object, and it will be closed when the returned object is
17 |    finalized.
18 | 
19 |    param must be non-null and must contain connection parameters for
20 |    the given connection object. tgt must be non-null and *tgt must
21 |    point to NULL.
22 | 
23 |    On success 0 is returned, *tgt is assigned to the wrapper object,
24 |    which now owns conn and which the caller must eventually free by
25 |    calling (*tgt)->api->finalize(*tgt).
26 | 
27 |    The connection is not opened by this function: call
28 |    tgt->api->connect(tgt) to do that.
29 | */
30 | int db_wrap_dbi_init(dbi_conn conn, db_wrap_conn_params const * param, db_wrap ** tgt);
31 | 
32 | /**
33 |    Functionally identical to db_wrap_dbi_init(), but it takes a libdbi
34 |    driver name as the first argument. e.g. "mysql" or "sqlite3".
35 | 
36 |    Returns 0 on success.
37 | */
38 | int db_wrap_dbi_init2(char const * driver, db_wrap_conn_params const * param, db_wrap ** tgt);
39 | 
40 | /**
41 |    A temporary function for use only while porting the dbi-using bits
42 |    to db_wrap. If db was created by the DBI-based driver then its
43 |    dbi-native handle is returned. That object is owned by the
44 |    db_wrap_result object and MUST NOT be destroyed by the caller.
45 | 
46 |    This function will go away once the port is complete.
47 | */
48 | dbi_conn db_wrap_dbi_conn(db_wrap * db);
49 | 
50 | 
51 | /**
52 |    A temporary function for use only while porting the dbi-using bits
53 |    to db_wrap. If db was created by the DBI-based driver then its
54 |    dbi-native result is returned. That object is owned by the
55 |    db_wrap_result object and MUST NOT be destroyed by the caller.
56 | 
57 |    This function will go away once the port is complete.
58 | */
59 | dbi_result db_wrap_dbi_result(db_wrap_result * db);
60 | 
61 | #endif /* _MERLIN_DB_WRAP_DBI_H_INCLUDED */
62 | 


--------------------------------------------------------------------------------
/daemon/merlind.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * This file is a silly wrapper which enables us to write tests
 3 |  * for daemon-specific functionality without having the
 4 |  * 'main' functions clash horribly.
 5 |  */
 6 | extern int merlind_main(int argc, char **argv);
 7 | 
 8 | int main(int argc, char **argv)
 9 | {
10 | 	return merlind_main(argc, argv);
11 | }
12 | 


--------------------------------------------------------------------------------
/daemon/sql.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_sql_h__
 2 | #define INCLUDE_sql_h__
 3 | 
 4 | #include <stdarg.h>
 5 | #include "db_wrap.h"
 6 | 
 7 | extern char *host_perf_table;
 8 | extern char *service_perf_table;
 9 | extern unsigned long total_queries;
10 | extern int sql_table_crashed;
11 | 
12 | /*typedef dbi_result SQL_RESULT;*/
13 | 
14 | extern int sql_config(const char *key, const char *value);
15 | extern int sql_is_connected(int reconnect);
16 | extern int sql_repair_table(const char *table);
17 | extern int sql_init(void);
18 | extern int sql_close(void);
19 | extern int sql_reinit(void);
20 | extern void sql_quote(const char *src, /*@out@*/char **dst);
21 | extern int sql_error(const char **msg);
22 | extern const char *sql_error_msg(void);
23 | extern void sql_free_result(void);
24 | extern int sql_query(const char *fmt, ...)
25 | 	__attribute__((__format__(__printf__, 1, 2)));
26 | extern int sql_vquery(const char *fmt, va_list ap);
27 | extern db_wrap_result * sql_get_result(void);
28 | extern void sql_try_commit(int query);
29 | extern const char *sql_table_name(void);
30 | extern const char *sql_db_name(void);
31 | extern const char *sql_db_user(void);
32 | extern const char *sql_db_pass(void);
33 | extern const char *sql_db_host(void);
34 | extern unsigned int sql_db_port(void);
35 | extern const char *sql_db_type(void);
36 | extern const char *sql_db_conn_str(void);
37 | extern int sql_table_exists(const char *tablename);
38 | #endif
39 | 


--------------------------------------------------------------------------------
/daemon/state.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | #include <string.h>
 3 | #include "state.h"
 4 | #include "logging.h"
 5 | #include <glib.h>
 6 | #include <naemon/naemon.h>
 7 | 
 8 | static GHashTable *host_states, *svc_states;
 9 | 
10 | int state_init(void)
11 | {
12 | 	host_states = g_hash_table_new_full(g_str_hash, g_str_equal,
13 | 			free, free);
14 | 	svc_states = g_hash_table_new_full(nm_service_hash, nm_service_equal,
15 | 			(GDestroyNotify) nm_service_key_destroy, free);
16 | 	return 0;
17 | }
18 | 
19 | void state_deinit(void)
20 | {
21 | 	g_hash_table_destroy(host_states);
22 | 	g_hash_table_destroy(svc_states);
23 | 	host_states = NULL;
24 | 	svc_states = NULL;
25 | }
26 | 
27 | static inline int has_state_change(int *old, int state, int type)
28 | {
29 | 	/*
30 | 	 * A state change is considered to consist of a change
31 | 	 * to either state_type or state, so we OR the two
32 | 	 * together to form a complete state. This will make
33 | 	 * the module log as follows:
34 | 	 *    service foo;poo is HARD OK initially
35 | 	 *    service foo;poo goes to SOFT WARN, attempt 1   (logged)
36 | 	 *    service foo;poo goes to SOFT WARN, attempt 2   (not logged)
37 | 	 *    service foo;poo goes to HARD WARN              (logged)
38 | 	 */
39 | 	state = CAT_STATE(state, type);
40 | 
41 | 	if (*old == state)
42 | 		return 0;
43 | 
44 | 	*old = state;
45 | 	return 1;
46 | }
47 | 
48 | int host_has_new_state(char *host, int state, int type)
49 | {
50 | 	int *old_state;
51 | 
52 | 	if (!host) {
53 | 		lerr("host_has_new_state() called with NULL host");
54 | 		return 0;
55 | 	}
56 | 	old_state = g_hash_table_lookup(host_states, host);
57 | 	if (!old_state) {
58 | 		int *cur_state;
59 | 
60 | 		cur_state = malloc(sizeof(*cur_state));
61 | 		*cur_state = CAT_STATE(state, type);
62 | 		g_hash_table_insert(host_states, strdup(host), cur_state);
63 | 		return 1;
64 | 	}
65 | 
66 | 	return has_state_change(old_state, state, type);
67 | }
68 | 
69 | int service_has_new_state(char *host, char *desc, int state, int type)
70 | {
71 | 	int *old_state;
72 | 
73 | 	if (!host) {
74 | 		lerr("service_has_new_state() called with NULL host");
75 | 		return 0;
76 | 	}
77 | 	if (!desc) {
78 | 		lerr("service_has_new_state() called with NULL desc");
79 | 		return 0;
80 | 	}
81 | 	old_state = g_hash_table_lookup(svc_states, &((nm_service_key){host, desc}));
82 | 	if (!old_state) {
83 | 		int *cur_state;
84 | 
85 | 		cur_state = malloc(sizeof(*cur_state));
86 | 		*cur_state = CAT_STATE(state, type);
87 | 		g_hash_table_insert(svc_states, nm_service_key_create(host, desc), cur_state);
88 | 		return 1;
89 | 	}
90 | 
91 | 	return has_state_change(old_state, state, type);
92 | }
93 | 


--------------------------------------------------------------------------------
/daemon/state.h:
--------------------------------------------------------------------------------
1 | #ifndef INCLUDE_state_h__
2 | #define INCLUDE_state_h__
3 | extern int state_init(void);
4 | extern void state_deinit(void);
5 | extern int host_has_new_state(char *host, int state, int type);
6 | extern int service_has_new_state(char *host, char *desc, int state, int type);
7 | #define CAT_STATE(__state, __type) ((__state | (__type << 8)))
8 | #endif
9 | 


--------------------------------------------------------------------------------
/daemon/string_utils.c:
--------------------------------------------------------------------------------
 1 | #include <stddef.h>
 2 | 
 3 | int unescape_newlines(char *dest, const char *src, size_t n) {
 4 | 	size_t i = 0, j = 0;
 5 | 	while (i < n) {
 6 | 		if (i == n - 1) {
 7 | 			/* last byte is \, next invalid read contains n -> don't read the n */
 8 | 			dest[j] = src[i];
 9 | 		}
10 | 		else if (src[i] == '\\' && src[i+1] == 'n' ) {
11 | 			++i;
12 | 			dest[j] = '\n';
13 | 		}
14 | 		else if (src[i] == '\\' && src[i+1] == '\\') {
15 | 			dest[j] = src[++i];
16 | 		}
17 | 		else {
18 | 			dest[j] = src[i];
19 | 		}
20 | 		++j;
21 | 		++i;
22 | 	}
23 | 	return j;
24 | }
25 | 


--------------------------------------------------------------------------------
/daemon/string_utils.h:
--------------------------------------------------------------------------------
 1 | #include <stddef.h>
 2 | 
 3 | /**
 4 |  * Copies at most n bytes from buffer src to destination dest, while
 5 |  * unescaping any escaped newlines. This is a binary method - if you want
 6 |  * the output to be NULL terminated, make sure the input is (and that n is
 7 |  * large enough to include it).
 8 |  *
 9 |  * Returns the length of dest, which can be shorter than src, but never longer.
10 |  */
11 | int unescape_newlines(char *dest, const char *src, size_t n);
12 | 


--------------------------------------------------------------------------------
/data/.gitignore:
--------------------------------------------------------------------------------
1 | merlin
2 | merlin.cfg
3 | 


--------------------------------------------------------------------------------
/data/kad.conf.in:
--------------------------------------------------------------------------------
1 | name = merlind
2 | pidfile = @pkgrundir@/merlin.pid
3 | 


--------------------------------------------------------------------------------
/data/merlin.cfg.in:
--------------------------------------------------------------------------------
1 | # Naemon config
2 | broker_module=@libdir@/merlin/merlin.so @merlin_cfgdir@/merlin.conf
3 | event_broker_options=-1
4 | 


--------------------------------------------------------------------------------
/data/merlin.conf.in:
--------------------------------------------------------------------------------
 1 | #
 2 | # Sample configuration file for merlin
 3 | #
 4 | # Default options have been commented out
 5 | #
 6 | ipc_socket = @localstatedir@/lib/merlin/ipc.sock;
 7 | 
 8 | log_level = info;
 9 | use_syslog = 1;
10 | 
11 | # module-specific configuration options.
12 | module {
13 | 	# textual log of normal hum-drum events
14 | 	log_file = @logdir@/neb.log;
15 | }
16 | 
17 | # daemon-specific config options
18 | daemon {
19 | 	pidfile = @pkgrundir@/merlin.pid;
20 | 
21 | 	# same as the "module" section above
22 | 	log_file = @logdir@/daemon.log;
23 | 
24 | 	# address to listen to. 0.0.0.0 is default
25 | 	#address = 0.0.0.0;
26 | 
27 | 	# port to listen to. 15551 is default. This is a daemon
28 | 	# specific config setting, as the module never listens to
29 | 	# the network
30 | 	port = 15551;
31 | 	database {
32 | 		# change to no to disable database completely
33 | 		# enabled = yes;
34 | 
35 | 		# write data necessary for creating availability reports
36 | 		# into report_data
37 | 		# log_report_data = yes;
38 | 
39 | 		# log contact notifications to the 'notifications' table
40 | 		# log_notifications = yes;
41 | 
42 | 		# Change this to yes to track current status (host, service etc
43 | 		# tables).
44 | 		# track_current = no;
45 | 
46 | 		# server location and authentication variables
47 | 		name = @db_name@;
48 | 		user = @db_user@;
49 | 		pass = @db_pass@;
50 | 		host = localhost;
51 | 		type = @db_type@;
52 | 	}
53 | 
54 | 	# this section describes how we handle config synchronization
55 | 	# It can also be configured on a per-node basis to override the
56 | 	# globals set here.
57 | 	# "push" and "fetch" point to a command supposed to be run when we
58 | 	# want to push configuration to any or all nodes in the network.
59 | 	# They're invoked with the following arguments:
60 | 	# --merlin-cfg=/path/to/merlin.conf
61 | 	object_config {
62 | 		# a "push" happens for peers and pollers that we know have an
63 | 		# older configuration than we do. This is what one would
64 | 		# normally want to happen, since it originates from the node
65 | 		# that already has all the information
66 | 		push = mon oconf push
67 | 
68 | 		# a "fetch" happens for peers and masters that we know
69 | 		# have a newer configuration than we do. One won't normally
70 | 		# configure this (and it currently lacks scripting support),
71 | 		# but it's available for advanced users who know what they're
72 | 		# doing
73 | 		#fetch = mon oconf fetch
74 | 	}
75 | }
76 | 


--------------------------------------------------------------------------------
/data/merlin.in:
--------------------------------------------------------------------------------
 1 | @logdir@/*log {
 2 | 	create 644 @naemon_user@ @naemon_group@
 3 | 	weekly
 4 | 	rotate 4
 5 | 	sharedscripts
 6 | 	missingok
 7 | 	postrotate
 8 | 		if command -v systemctl &>/dev/null; then
 9 | 			systemctl try-restart merlind > /dev/null 2>&1
10 | 			systemctl try-restart naemon > /dev/null 2>&1
11 | 		else
12 | 			service naemon status
13 | 			mon_running=$?
14 | 			service merlind status
15 | 			merlin_running=$?
16 | 			service naemon stop
17 | 			service merlind stop
18 | 			sleep 1
19 | 			test $merlin_running -eq 0 && nice -n 0 service merlind start || :
20 | 			test $mon_running -eq 0 && nice -n 0 service naemon start || :
21 | 		fi
22 | 	endscript
23 | }
24 | 


--------------------------------------------------------------------------------
/data/merlind.in:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #
 3 | # Start / stop the Merlin daemon
 4 | #
 5 | # chkconfig: 235 90 10
 6 | #
 7 | ### BEGIN INIT INFO
 8 | # Provides: merlin
 9 | # Required-Start: $local_fs $network $remote_fs
10 | # Required-Stop: $local_fs $network $remote_fs
11 | # Default-Start:  2 3 5
12 | # Default-Stop: 0 1 6
13 | # Short-Description: start and stop the merlin daemon
14 | # Description: Merlin is an event-distribution system for Nagios
15 | ### END INIT INFO
16 | 
17 | if [ -e /etc/rc.d/init.d/functions ]; then
18 |   . /etc/rc.d/init.d/functions
19 | fi
20 | 
21 | prefix=@prefix@
22 | exec_prefix=@exec_prefix@
23 | sysconfdir=@sysconfdir@
24 | 
25 | prog=merlind
26 | BINDIR=@bindir@
27 | CONFIG_FILE=@pkgconfdir@/merlin.conf
28 | user=@naemon_user@
29 | pidfile=@pkgrundir@/merlin.pid
30 | 
31 | start ()
32 | {
33 | 	echo -n "Starting $prog: "
34 | 	if type start-stop-daemon >/dev/null 2>&1; then
35 | 		start-stop-daemon --start --user $user --name $prog --pidfile $pidfile --exec "$BINDIR/$prog" -- -c "$CONFIG_FILE"
36 | 	else
37 | 		daemon --user=$user "$BINDIR/$prog" -c "$CONFIG_FILE"
38 | 	fi
39 | 	echo
40 | }
41 | 
42 | stop ()
43 | {
44 | 	echo -n "Stopping $prog: "
45 | 	"$BINDIR/$prog" -c "$CONFIG_FILE" -k
46 | 	echo
47 | }
48 | 
49 | status ()
50 | {
51 | 	"$BINDIR/$prog" -c "$CONFIG_FILE" -s
52 | }
53 | 
54 | case "$1" in
55 | 	start)
56 | 		start
57 | 		;;
58 | 	stop)
59 | 		stop
60 | 		;;
61 | 	status)
62 | 		status
63 | 		;;
64 | 	reload|restart)
65 | 		stop
66 | 		start
67 | 		;;
68 | 	*)
69 | 		echo "Usage: $0 start|stop|restart|reload"
70 | 		exit 1
71 | 		;;
72 | esac
73 | 


--------------------------------------------------------------------------------
/docs/.gitignore:
--------------------------------------------------------------------------------
1 | container-poller-readme.md
2 | 


--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
 1 | # Minimal makefile for Sphinx documentation
 2 | #
 3 | 
 4 | # You can set these variables from the command line.
 5 | SPHINXOPTS    =
 6 | SPHINXBUILD   = sphinx-build
 7 | SPHINXPROJ    = Merlin
 8 | SOURCEDIR     = .
 9 | BUILDDIR      = _build
10 | RELEASE	      =
11 | 
12 | # Put it first so that "make" without argument is like "make help".
13 | help:
14 | 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
15 | 
16 | .PHONY: help Makefile
17 | 
18 | # Grabs the readme directly from the Merlin container poller repo, so we can
19 | # use it directly in the docs.
20 | container-poller-readme.md:
21 | 	curl https://raw.githubusercontent.com/ITRS-Group/merlin-container-poller/master/README.md -o container-poller-readme.md
22 | 
23 | # Catch-all target: route all unknown targets to Sphinx using the new
24 | # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
25 | %: Makefile container-poller-readme.md
26 | 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) -D release=$(RELEASE) $(O)
27 | 


--------------------------------------------------------------------------------
/docs/_templates/layout.html:
--------------------------------------------------------------------------------
1 | {% extends '!layout.html' %}
2 | {% block document %}
3 | {{super()}}
4 |     <a href="https://github.com/ITRS-Group/monitor-merlin/" class="github-corner" aria-label="View source on GitHub"><svg width="80" height="80" viewBox="0 0 250 250" style="fill:#70B7FD; color:#fff; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true"><path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a><style>.github-corner:hover .octo-arm{animation:octocat-wave 560ms ease-in-out}@keyframes octocat-wave{0%,100%{transform:rotate(0)}20%,60%{transform:rotate(-25deg)}40%,80%{transform:rotate(10deg)}}@media (max-width:500px){.github-corner:hover .octo-arm{animation:none}.github-corner .octo-arm{animation:octocat-wave 560ms ease-in-out}}</style>
5 | {% endblock %}
6 | 


--------------------------------------------------------------------------------
/docs/changelog.md:
--------------------------------------------------------------------------------
1 | ```{include} ../CHANGELOG.md
2 | ```
3 | 


--------------------------------------------------------------------------------
/docs/configuration.rst:
--------------------------------------------------------------------------------
 1 | Configuration
 2 | ==============
 3 | 
 4 | Configuration file format
 5 | --------------------------
 6 | 
 7 | The syntax is made up of a key without spaces and a value containing arbitrary
 8 | characters (although no semi-colons). A configuration statement is terminated
 9 | either by a newline or a semi-colon. A configuration statement starting with a
10 | hash-character (#) is considered a comment. Thus,
11 | 
12 | .. code-block:: none
13 | 
14 |     key = value; # comment
15 | 
16 | makes "key" the key, "value" the value, terminated by the semi-colon, and "#
17 | comment" all of the comment. Leading and trailing whitespace is ignored.
18 | 
19 | Merlins configuration consists of several sections. A section scope are started
20 | by ``{`` and ended by ``}``. 
21 | 
22 | Sample config
23 | --------------
24 | 
25 | The sample configuration below contains a description of all notable
26 | configuration settings.
27 | 
28 | .. literalinclude:: merlin.conf.sample
29 |     :language: none
30 | 
31 | .. toctree::
32 |    :maxdepth: 1 
33 | 


--------------------------------------------------------------------------------
/docs/container-poller.md:
--------------------------------------------------------------------------------
1 | ```{include} container-poller-readme.md
2 | ```
3 | 


--------------------------------------------------------------------------------
/docs/encryption.rst:
--------------------------------------------------------------------------------
 1 | Encrypted communication
 2 | ========================
 3 | 
 4 | Merlin supports encrypting the packets transmitted over the Merlin TCP protocol.
 5 | Merlin uses libsodiums crypo_box. For more information on the encryption please
 6 | refer to their `documentation
 7 | <https://doc.libsodium.org/public-key_cryptography/authenticated_encryption>`_.
 8 | 
 9 | Note that the Merlin packets body is encrypted, the header remain unencrypted.
10 | 
11 | 
12 | Configuring encryption
13 | -----------------------
14 | 
15 | In this example we'll set up encryption between two peers, *peer01*, and *peer02*.
16 | 
17 | Generating encryption keys
18 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
19 | 
20 | To setup encryption, we first need to generate a encryption key pair consisting
21 | of a private key and a public key.
22 | 
23 | To do so we can make use of the ``mon merlinkey`` command.
24 | 
25 | .. code-block:: none
26 | 
27 |    [root@peer01 ~]# mon merlinkey generate --write
28 |    [root@peer02 ~]# mon merlinkey generate --write
29 | 
30 | The above command does the following:
31 | 
32 | 1. Generates an encryption key pair and saves it at ``/etc/merlin/`` by default
33 | 2. Adds the ``ipc_privatekey`` setting to ``merlin.conf``
34 | 
35 | You can omit ``--write`` flag if you do not write the change to ``merlin.conf``.
36 | 
37 | We now need to copy the public keys, to the other node. Note the private key
38 | should never be shared! We can use ``scp`` to copy the relevant public key.
39 | 
40 | .. code-block:: none
41 | 
42 |    [root@peer01 ~]# scp /etc/merlin/key.pub peer02:/etc/merlin/peer01.pub
43 |    [root@peer02 ~]# scp -a /etc/merlin/key.pub peer01:/etc/merlin/peer02.pub
44 | 
45 | 
46 | Adjusting configuration
47 | ^^^^^^^^^^^^^^^^^^^^^^^^
48 | 
49 | To enable encryption, we must adjust the node configuration in ``merlin.conf``,
50 | on both *peer01* and *peer02*. Below is an example of how the node config
51 | should look on the two nodes.
52 | 
53 | ``merlin.conf`` on *peer01*
54 | 
55 | .. code-block:: none
56 | 
57 |    peer peer02 {
58 |         address = IP_ADDR
59 |         port = 15551
60 |         encrypted = 1
61 |         publickey = /etc/merlin/peer02.pub
62 |    }
63 | 
64 | ``merlin.conf`` on *peer02*
65 | 
66 | .. code-block:: none
67 | 
68 |    peer peer01 {
69 |         address = IP_ADDR
70 |         port = 15551
71 |         encrypted = 1
72 |         publickey = /etc/merlin/peer01.pub
73 |    }
74 | 
75 | .. toctree::
76 |    :maxdepth: 1 
77 | 


--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
 1 | .. Merlin documentation master file, created by
 2 |    sphinx-quickstart on Sun Oct 31 10:51:03 2021.
 3 |    You can adapt this file completely to your liking, but it should at least
 4 |    contain the root `toctree` directive.
 5 | 
 6 | Introduction
 7 | =============
 8 | 
 9 | The Merlin project, or Module for Effortless Redundancy and Loadbalancing In
10 | Naemon, is a Naemon module built to create an easy way to set up distributed
11 | Naemon installations, allowing Naemon processes to exchange information. This
12 | allows Naemon to scale past a single installation to handle a bigger monitoring
13 | workload.
14 | 
15 | Merlin can also save state changes to a database, which can be
16 | used for reporting purposes.
17 | 
18 | Brief description of the Merlin project
19 | ========================================
20 | 
21 | Merlin consists of:
22 | 
23 | **merlin-mod:** Responsible for jacking into the NEBCALLBACK_* calls and send them
24 | to a socket (remote Merlin and merlind). If the socket is not available the
25 | events are written to a backlog and sent when the socket is available again.
26 | 
27 | **merlind:** The Merlin deamon listens to the socket that merlin-mod writes to and
28 | sends all state changes to a database of your choice (using libdbi).
29 | 
30 | **merlin database:** This is a database that contains state changes.
31 | 
32 | **mon scripts:** A bunch of utility scripts utilized to add new nodes to the system,
33 | and other useful things.
34 | 
35 | Table of Contents
36 | ------------------
37 | 
38 | .. toctree::
39 |    :maxdepth: 1
40 |    :caption: About
41 | 
42 |    self
43 |    changelog.md
44 | 
45 | .. toctree::
46 |    :caption: Using merlin
47 |    :maxdepth: 1
48 | 
49 |    install
50 |    clustering
51 |    configuration
52 |    encryption
53 |    container-poller
54 | 


--------------------------------------------------------------------------------
/features/check_result_output.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler @livestatus
 2 | Feature: Running active checks locally which returns multi-line output
 3 | 	should store the output within the object in naemon. Meaning that that first
 4 | 	line of the output should be stored in the plugin_output parameter and the
 5 | 	remaining lines in the long_plugin_output parameter.
 6 | 
 7 | 	The same goes for when receiving a check result over merlin. Multi-line
 8 | 	output in the received check result object should be stored in the same
 9 | 	way it would be done locally which is first line in plugin_output and the
10 | 	rest in long_plugin_output.
11 | 
12 | 	Background: Set up naemon configuration
13 | 		Given I have naemon hostgroup objects
14 | 			| hostgroup_name | alias |
15 | 			| pollergroup    | PG    |
16 | 			| emptygroup     | EG    |
17 | 		And I have naemon host objects
18 | 			| use          | host_name | address   | contacts  | max_check_attempts | hostgroups  | active_checks_enabled | check_interval | check_command     |
19 | 			| default-host | hostA     | 127.0.0.1 | myContact | 2                  | pollergroup |                     1 |              1 | check_long_output |
20 | 			| default-host | hostB     | 127.0.0.2 | myContact | 2                  | pollergroup |                     1 |              1 | check_long_output |
21 | 		And I have naemon service objects
22 | 			| use             | host_name | description | active_checks_enabled | check_interval | check_command     |
23 | 			| default-service | hostA     | PING        |                     1 |              1 | check_long_output |
24 | 			| default-service | hostB     | PONG        |                     1 |              1 | check_long_output |
25 | 		And I have naemon contact objects
26 | 			| use             | contact_name |
27 | 			| default-contact | myContact    |
28 | 		And I have naemon command objects
29 | 			| command_name | command_line |
30 | 			| echo_this    | asdf         |
31 | 		And I have naemon config interval_length set to 3
32 | 		And I have naemon config cached_host_check_horizon set to 0
33 | 		And I have naemon config cached_service_check_horizon set to 0
34 | 
35 | 	Scenario: Receiving a service check result with a multi-line output should
36 | 		set plugin_output of the service to the first line and
37 | 		long_plugin_output to the remaining lines.
38 | 
39 | 		Given I start naemon with merlin nodes connected
40 | 			| type   | name       | port |
41 | 			| peer   | the_peer   | 4001 |
42 | 
43 | 		When the_peer sends event SERVICE_CHECK
44 | 			| state.current_state      | 0                    |
45 | 			| state.plugin_output      | Plugin output        |
46 | 			| state.long_plugin_output | Long\nplugin\noutput |
47 | 			| state.perf_data          | Performance data     |
48 | 			| host_name                | hostA                |
49 | 			| service_description      | PING                 |
50 | 
51 | 		Then plugin_output of service PING on host hostA should be Plugin output
52 | 		And long_plugin_output of service PING on host hostA should be Long\\nplugin\\noutput
53 | 		And perf_data of service PING on host hostA should be Performance data
54 | 


--------------------------------------------------------------------------------
/features/cluster_update.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler
 2 | Feature: The cluster_update functionality allows to configure a specific script
 3 | 	to be run when a node has an incompatible cluster configuration.
 4 | 
 5 | 	Background: I some default configuration in naemon
 6 | 		Given I have naemon hostgroup objects
 7 | 			| hostgroup_name | alias |
 8 | 			| pollergroup    | PG    |
 9 | 		And I have naemon host objects
10 | 			| use          | host_name | address   | hostgroups  |
11 | 			| default-host | something | 127.0.0.1 | pollergroup |
12 | 		And I have naemon service objects
13 | 			| use             | host_name | description |
14 | 			| default-service | something | PING        |
15 | 
16 | 	Scenario: Master sends CTRL_INVALID_CLUSTER then the poller should
17 | 		execute the cluster_update command
18 | 		Given I start naemon with merlin nodes connected
19 | 			| type   | name    | port |
20 | 			| master | master1 | 4001 |
21 | 		And master1 sends event CTRL_INVALID_CLUSTER
22 | 			| version | 1 |
23 | 
24 | 		And I wait for 3 second
25 | 		Then file merlin.log matches Cluster update finished successfully
26 | 
27 | 	Scenario: If poller connects with wrong number of peers it should
28 | 		disconnect.
29 | 		Given I start naemon with merlin nodes connected
30 | 			| type   | name    | port | hostgroups  |
31 | 			| poller | poller1 | 4001 | pollergroup |
32 | 		And poller1 sends event CTRL_ACTIVE
33 | 			| configured_peers    | 1 |
34 | 			| configured_masters  | 2 |
35 | 
36 | 		And I wait for 1 second
37 | 		Then poller1 should appear disconnected
38 | 


--------------------------------------------------------------------------------
/features/config_split_poller.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler @livestatus
 2 | Feature: Merlin splits the configuration so that pollers only gets the configuration they need
 3 | 
 4 |     Background: Set up naemon configuration
 5 |         Given I have naemon hostgroup objects
 6 |             | hostgroup_name | alias |
 7 |             | pollergroup    | PG    |
 8 |             | emptygroup     | EG    |
 9 |         And I have naemon host objects
10 |             | use          | host_name | address   | contacts  | hostgroups  |
11 |             | default-host | hostA     | 127.0.0.1 | myContact | pollergroup |
12 |             | default-host | hostB     | 127.0.0.2 | myContact | pollergroup |
13 |         And I have naemon service objects
14 |             | use             | host_name | description |
15 |             | default-service | hostA     | PING        |
16 |             | default-service | hostA     | PONG        |
17 |             | default-service | hostB     | PING        |
18 |             | default-service | hostB     | PONG        |
19 |         And I have naemon contact objects
20 |             | use             | contact_name |
21 |             | default-contact | myContact    |
22 | 
23 |     Scenario Outline: Splitting a servicegroup should always result in an
24 |         ordered member list in the poller configuration. The order should
25 |         always be the same if the members are the same, regardsless of the
26 |         order in the masters configuration so that masters cannot generate
27 |         servicegroup members in arbitrary order. Having multiple servicegroups
28 |         should also not affect the output of the configuration split.
29 |         Given I have naemon servicegroup objects
30 |             | servicegroup_name | alias | members   |
31 |             | sg1               | sg1   | <members> |
32 |             | sg2               | sg2   | <members> |
33 |         And I start naemon with merlin nodes connected
34 |             | type   | name        | port | hostgroup   |
35 |             | poller | poller_one  | 4001 | pollergroup |
36 |             | poller | poller_two  | 4002 | pollergroup |
37 |         Then file poller_one.cfg has 1 occurence of define servicegroup \{\s*servicegroup_name\ssg1\s*alias\ssg1\s*members\s<output>\s*\}
38 |         And file poller_one.cfg has 1 occurence of define servicegroup \{\s*servicegroup_name\ssg2\s*alias\ssg2\s*members\s<output>\s*\}
39 |         And files poller_one.cfg and poller_two.cfg are identical
40 |         
41 |         Examples:
42 |             | members                                     | output                                      |
43 |             | hostA,PING,hostA,PONG,hostB,PING,hostB,PONG | hostA,PING,hostA,PONG,hostB,PING,hostB,PONG |
44 |             | hostB,PONG,hostB,PING,hostA,PONG,hostA,PING | hostA,PING,hostA,PONG,hostB,PING,hostB,PONG |
45 |             | hostB,PING,hostA,PING,hostB,PONG,hostA,PONG | hostA,PING,hostA,PONG,hostB,PING,hostB,PONG |
46 | 


--------------------------------------------------------------------------------
/features/config_sync_passive_poller.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler
 2 | Feature: Module should handle conf sync with poller
 3 | 	When a module realizes that another node has a config out of sync, the
 4 | 	module should start configuration sync, according to the config sync
 5 | 	directive in the merlin.conf
 6 | 
 7 | 	Background: I some default configuration in naemon
 8 | 		Given I have naemon host objects
 9 | 			| use          | host_name   | address   |
10 | 			| default-host | something   | 127.0.0.1 |
11 | 			| default-host | pollerthing | 127.0.0.1 |
12 | 		And I have naemon hostgroup objects
13 | 			| hostgroup_name | alias | members     |
14 | 			| poller-group   | PG    | pollerthing |
15 | 		And I have naemon service objects
16 | 			| use             | host_name   | description |
17 | 			| default-service | something   | PING        |
18 | 			| default-service | pollerthing | PING        |
19 | 		And I have merlin configured for port 7000
20 | 			| type   | name   | port | fetch                  |
21 | 			| master | master | 4001 | mon oconf fetch master |
22 | 
23 | 		When I start naemon
24 | 		Then node ipc have info hash ipc_info_hash at 1000
25 | 		And node ipc have expected hash ipc_expected_hash at 2000
26 | 		And node master have info hash poller_info_hash at 3000
27 | 		And node master have expected hash poller_expected_hash at 4000
28 | 
29 | 	Scenario: Same config and same timestamp should be accepted
30 | 		Given master connect to merlin at port 7000 from port 11001
31 | 		And master sends event CTRL_ACTIVE
32 | 			| configured_masters |                    1 |
33 | 			| last_cfg_change    |                 4000 |
34 | 		When I wait for 1 second
35 | 		Then master is connected to merlin
36 | 		And master received event CTRL_ACTIVE
37 | 			| last_cfg_change    |                 1000 |
38 | 		And file config_sync.log does not match ^push
39 | 		And file merlin.log does not match fetch triggered
40 | 
41 | 	Scenario: Different config and lower timestamp should be denied, poller should fetch if configured
42 | 		Given master connect to merlin at port 7000 from port 11001
43 | 		And master sends event CTRL_ACTIVE
44 | 			| configured_masters |                    1 |
45 | 			| last_cfg_change    |                 3900 |
46 | 		When I wait for 1 second
47 | 		Then master is not connected to merlin
48 | 		And file merlin.log matches fetch triggered
49 | 		And file config_sync.log does not match ^push
50 | 
51 | 	Scenario: Different config and higher timestamp should be denied, poller should fetch if configured
52 | 		Given master connect to merlin at port 7000 from port 11001
53 | 		And master sends event CTRL_ACTIVE
54 | 			| configured_masters |                    1 |
55 | 			| last_cfg_change    |                 4100 |
56 | 		When I wait for 1 second
57 | 		Then master is not connected to merlin
58 | 		And file merlin.log matches fetch triggered
59 | 		And file config_sync.log does not match ^push
60 | 
61 | 	Scenario: poller should fetch if master sends CTRL_FETCH
62 | 		Given master connect to merlin at port 7000 from port 11001
63 | 		And master sends event CTRL_FETCH
64 | 			| configured_masters |                    1 |
65 | 		When I wait for 1 second
66 | 		Then file merlin.log matches fetch triggered
67 | 


--------------------------------------------------------------------------------
/features/data/README:
--------------------------------------------------------------------------------
 1 | The two binary files in this directory are used for testing binlog persitence.
 2 | The binlog contains the following events:
 3 | 
 4 | * EXTERNAL_COMMAND
 5 | 	type = 1400
 6 | 	command_type = 87
 7 | 	command_string = PROCESS_HOST_CHECK_RESULT
 8 | 	command_args = hostA;1;Fromtest
 9 | * HOST_CHECK
10 | 	state.initial_state = 0
11 | 	state.check_type = 1
12 | 	state.current_state = 1
13 | 	state.last_state = 0
14 | 	state.last_hard_state = 0	
15 | 	state.state_type = 1
16 | 	state.current_attempt = 1
17 | 	state.notifications_enabled = 1
18 | 	state.last_notification = 0
19 | 	state.next_notification = 0
20 | 	state.last_state_change = 1613558292
21 | 	state.last_hard_state_change = 1613558292
22 | 	state.plugin_output = Fromtest
23 | 	name = hostA
24 | * NOTIFICATION
25 | 	type = 601
26 | 	notification_type = 0
27 | 	start_time = 0.000000
28 | 	end_time = 0.000000
29 | 	host_name = hostA
30 | 	reason_type = 0
31 | 	state = 1
32 | 	output = Fromtest
33 | 	escalated = 0
34 | 	contacts_notified = 0
35 | * EXTERNAL_COMMAND
36 | 	type = 1400
37 | 	command_type = 8
38 | 	command_string = SHUTDOWN_PROGRAM
39 | 	command_args =
40 | 


--------------------------------------------------------------------------------
/features/data/module.my-peer.binlog.meta:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITRS-Group/monitor-merlin/216309152a44617ea74abb6ea58870d110a91b9f/features/data/module.my-peer.binlog.meta


--------------------------------------------------------------------------------
/features/data/module.my-peer.binlog.save:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITRS-Group/monitor-merlin/216309152a44617ea74abb6ea58870d110a91b9f/features/data/module.my-peer.binlog.save


--------------------------------------------------------------------------------
/features/execute_host_checks.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler @livestatus
 2 | Feature: Module should handle execute_host_checks sync with peer
 3 | 	When a module notices that execute_host_checks has changed value
 4 | 	the module should notify its peers with the new value
 5 | 
 6 | 	Scenario: Disabling active checks should propagate to peer
 7 | 		Given I have naemon config execute_host_checks set to 1
 8 | 		And I start naemon with merlin nodes connected
 9 | 			| type | name      | port |
10 | 			| peer | the_peer  | 4001 |
11 | 			| peer | the_peer2 | 4002 |
12 | 		And naemon status execute_host_checks should be set to 1
13 | 		When I send naemon command STOP_EXECUTING_HOST_CHECKS
14 | 		Then naemon status execute_host_checks should be set to 0
15 | 
16 | 		And the_peer received event EXTERNAL_COMMAND
17 | 			| command_type   | 89                         |
18 | 			| command_string | STOP_EXECUTING_HOST_CHECKS |
19 | 		And the_peer2 received event EXTERNAL_COMMAND
20 | 			| command_type   | 89                         |
21 | 			| command_string | STOP_EXECUTING_HOST_CHECKS |
22 | 
23 | 	Scenario: Receiving an external command through merlin
24 | 		If a command is received through merlin, it shouldn't
25 | 		propagate to other nodes, so loops doesn't occur, where
26 | 		node A sends to B, sends to C and back to A.
27 | 
28 | 		However, the command should be executed by the node.
29 | 
30 | 		Given I have naemon config execute_host_checks set to 1
31 | 		And I start naemon with merlin nodes connected
32 | 			| type | name      | port |
33 | 			| peer | the_peer  | 4001 |
34 | 			| peer | the_peer2 | 4002 |
35 | 		And naemon status execute_host_checks should be set to 1
36 | 		When the_peer sends event EXTERNAL_COMMAND
37 | 			| command_type   | 89                         |
38 | 			| command_string | STOP_EXECUTING_HOST_CHECKS |
39 | 		Then the_peer should not receive EXTERNAL_COMMAND
40 | 			| command_type   | 89                         |
41 | 			| command_string | STOP_EXECUTING_HOST_CHECKS |
42 | 		And the_peer2 should not receive EXTERNAL_COMMAND
43 | 			| command_type   | 89                         |
44 | 			| command_string | STOP_EXECUTING_HOST_CHECKS |
45 | 		And naemon status execute_host_checks should be set to 0
46 | 


--------------------------------------------------------------------------------
/features/ipc_nodeinfo_version.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin
 2 | Feature: Version compatibility over IPC
 3 | 	If merlin daemon and merlin module is of different versions, they shouldn't be able to talk to each other. The module and daemon comes in pairs.
 4 | 
 5 | 	It's up to a future version to handle backward compatibility, so let the future version to disconnect if we're to old.
 6 | 
 7 | 	Background: I have a local active daemon
 8 | 		Given I have merlin configured for port 7000
 9 | 			| type | name | port | connect |
10 | 
11 | 		And I start merlin
12 | 		And I wait for 1 second
13 | 
14 | 	Scenario: Same version should be accepted
15 | 		Given ipc connect to merlin at socket test_ipc.sock
16 | 		And ipc sends event CTRL_ACTIVE
17 | 			| version | 1 |
18 | 		And I wait for 1 second
19 | 		Then ipc is connected to merlin
20 | 
21 | 	Scenario: Lower version should not be accepted
22 | 		Given ipc connect to merlin at socket test_ipc.sock
23 | 		And ipc sends event CTRL_ACTIVE
24 | 			| version | 0 |
25 | 		Then ipc is not connected to merlin
26 | 
27 | 	Scenario: Higher version should be accepted, up to other version to handle backward compatibility
28 | 		Given ipc connect to merlin at socket test_ipc.sock
29 | 		And ipc sends event CTRL_ACTIVE
30 | 			| version | 2 |
31 | 		And I wait for 1 second
32 | 		Then ipc is connected to merlin
33 | 


--------------------------------------------------------------------------------
/features/livestatus.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler @livestatus
 2 | Feature: I can ask livestatus for information
 3 | 	Those steps is just to verify the test environment livestatus steps, rather
 4 | 	than verifying merlin. Should be removed when livestatus requests is added
 5 | 	to merlin tests.
 6 | 
 7 | Background: Start naemon
 8 | 	Given I have naemon host objects
 9 | 		| use          | host_name | address   |
10 | 		| default-host | something | 127.0.0.1 |
11 | 		| default-host | gurka     | 127.0.0.2 |
12 | 	Given I have merlin configured for port 7000
13 | 		| type | name   | port |
14 | 	And I start naemon
15 | 
16 | Scenario: Ask livestatus
17 | 	When I submit the following livestatus query
18 | 		| GET hosts             |
19 | 		| Columns: name address |
20 | 	Then I should see the following livestatus response
21 | 		| name      | address   |
22 | 		| gurka     | 127.0.0.2 |
23 | 		| something | 127.0.0.1 |
24 | 


--------------------------------------------------------------------------------
/features/notification_persistence.feature:
--------------------------------------------------------------------------------
 1 | @daemons @config @merlin @queryhandler
 2 | Feature: Notification persistence
 3 |     Notification events that are received by the merlin daemon should be
 4 |     persisted in a database if available.
 5 | 
 6 |     @unstable
 7 |     Scenario: Merlin daemon receives one notification event
 8 |         Given I have merlin configured for port 7000
 9 |             | type   | name   | port | hostgroup    |
10 |         And I start merlin
11 |         And ipc connect to merlin at socket test_ipc.sock
12 |         And ipc is connected to merlin
13 | 
14 |         When ipc sends event CONTACT_NOTIFICATION_METHOD
15 |             | ack_author   | testCase         |
16 |             | ack_data     | A little comment |
17 |             | contact_name | myContact        |
18 |         And I wait for 2 seconds
19 | 
20 |         Then CONTACT_NOTIFICATION_METHOD is logged in the database 1 time with data
21 |             | ack_author   | testCase         |
22 |             | ack_data     | A little comment |
23 |             | contact_name | myContact        |
24 | 
25 |     @unstable
26 |     Scenario: Merlin daemon doesn't overwrite notification event
27 |         Given I have merlin configured for port 7000
28 |             | type   | name   | port | hostgroup    |
29 |         And I start merlin
30 |         And ipc connect to merlin at socket test_ipc.sock
31 |         And ipc is connected to merlin
32 | 
33 |         When ipc sends event CONTACT_NOTIFICATION_METHOD
34 |             | ack_author   | testCase         |
35 |             | ack_data     | A little comment |
36 |             | contact_name | myContact        |
37 |         And ipc sends event CONTACT_NOTIFICATION_METHOD
38 |             | ack_author   | testCase         |
39 |             | ack_data     | A little comment |
40 |             | contact_name | myContact        |
41 | 
42 |         And I wait for 2 seconds
43 |         Then CONTACT_NOTIFICATION_METHOD is logged in the database 2 times with data
44 |             | ack_author   | testCase         |
45 |             | ack_data     | A little comment |
46 |             | contact_name | myContact        |
47 | 
48 |     Scenario: Merlin daemon receives no notification event
49 |         Given I have merlin configured for port 7000
50 |             | type   | name   | port | hostgroup    |
51 |         And I start merlin
52 | 
53 |         Then CONTACT_NOTIFICATION_METHOD is logged in the database 0 times with data
54 |             | | |
55 | 


--------------------------------------------------------------------------------
/features/peer_nodeinfo_version.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler
 2 | Feature: Version compatibility between peers
 3 | 	We don't provide compatibility between versions at the moment.
 4 | 	Thus, disconnect from older versions.
 5 | 
 6 | 	It's up to a future version to handle backward compatibility,
 7 | 	so let the future version to disconnect if we're to old.
 8 | 
 9 | 	Background: I some default configuration in naemon
10 | 		Given I have naemon host objects
11 | 			| use          | host_name | address   |
12 | 			| default-host | something | 127.0.0.1 |
13 | 		And I have naemon service objects
14 | 			| use             | host_name | description |
15 | 			| default-service | something | PING        |
16 | 		And I have merlin configured for port 7000
17 | 			| type | name | port | connect |
18 | 			| peer | peer | 4001 | no      |
19 | 
20 | 		And I start naemon
21 | 		And node ipc have info hash config_hash at 1000
22 | 		And node ipc have expected hash config_hash at 2000
23 | 		And node peer have info hash config_hash at 3000
24 | 		And node peer have expected hash config_hash at 4000
25 | 
26 | 	Scenario: Same version should be accepted
27 | 		Given peer connect to merlin at port 7000 from port 11001
28 | 		And peer sends event CTRL_ACTIVE
29 | 			| version          |           1 |
30 | 			| configured_peers |           1 |
31 | 			| config_hash      | config_hash |
32 | 
33 | 		And I wait for 1 second
34 | 		Then peer is connected to merlin
35 | 		And peer received event CTRL_ACTIVE
36 | 			| version | 1 |
37 | 
38 | 	Scenario: Lower version should not be accepted
39 | 		Given peer connect to merlin at port 7000 from port 11001
40 | 		And peer sends event CTRL_ACTIVE
41 | 			| version          |           0 |
42 | 			| configured_peers |           1 |
43 | 			| config_hash      | config_hash |
44 | 		Then peer is not connected to merlin
45 | 
46 | 	Scenario: Higher version should be accepted, up to other part to validate compatibility
47 | 		Given peer connect to merlin at port 7000 from port 11001
48 | 		And peer sends event CTRL_ACTIVE
49 | 			| version          |           2 |
50 | 			| configured_peers |           1 |
51 | 			| config_hash      | config_hash |
52 | 		And I wait for 1 second
53 | 		Then peer is connected to merlin
54 | 		And peer received event CTRL_ACTIVE
55 | 			| version | 1 |
56 | 


--------------------------------------------------------------------------------
/features/retention_data_oconf_hash.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @queryhandler @oconf @livestatus
 2 | Feature: Retention data should not affect config hash
 3 | 	Since we calculate a hash of the current configuration to check if the
 4 | 	configuration should be synced, only the parts that is synced should affect
 5 | 	the hash.
 6 | 	
 7 | 	Scenario: The hash is reported correctly in a clean system
 8 | 		Given I have naemon hostgroup objects
 9 | 			| hostgroup_name | alias             |
10 | 			| poller-group   | Poller host group |
11 | 		And I have naemon host objects
12 | 			| use          | host_name | address   | hostgroups   | active_checks_enabled |
13 | 			| default-host | something | 127.0.0.1 | poller-group | 1                     |
14 | 		And I have merlin configured for port 7000
15 | 			| type   | name     | port | hostgroup    |
16 | 			| poller | myPoller | 4001 | poller-group |
17 | 		And I have config file status.sav
18 | 			"""
19 | 			host {
20 | 			host_name=something
21 | 			modified_attributes=2
22 | 			config:active_checks_enabled=1
23 | 			active_checks_enabled=0
24 | 			}
25 | 			"""
26 | 		When I start naemon
27 | 		And I wait for 2 seconds
28 | 		And I submit the following livestatus query
29 | 			| GET hosts                                   |
30 | 			| Columns: name address active_checks_enabled |
31 | 		Then I should see the following livestatus response
32 | 			| name      | address   | active_checks_enabled |
33 | 			| something | 127.0.0.1 | 0                     |
34 | 
35 | 		But file myPoller.cfg matches active_checks_enabled[\s]*1


--------------------------------------------------------------------------------
/features/runcmd.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler @livestatus
 2 | Feature: Test merlins runcmd feature.
 3 | 
 4 | 	Background: Set up naemon configuration
 5 | 
 6 | 		Given I have naemon hostgroup objects
 7 | 			| hostgroup_name | alias |
 8 | 			| pollergroup    | PG    |
 9 | 			| emptygroup     | EG    |
10 | 		And I have naemon host objects
11 | 			| use          | host_name | address   | contacts  | max_check_attempts | hostgroups  |
12 | 			| default-host | hostA     | 127.0.0.1 | myContact | 2                  | pollergroup |
13 | 			| default-host | hostB     | 127.0.0.2 | myContact | 2                  | pollergroup |
14 | 		And I have naemon service objects
15 | 			| use             | host_name | description |
16 | 			| default-service | hostA     | PONG        |
17 | 			| default-service | hostB     | PONG        |
18 | 		And I have naemon contact objects
19 | 			| use             | contact_name |
20 | 			| default-contact | myContact    |
21 | 
22 | 
23 | 	@unencrypted
24 | 	Scenario: The peer sends a request to "ipc" to execute a RUNCMD command without encryption
25 | 		The peer should recieve a response back.
26 | 
27 | 		Given I start naemon with merlin nodes connected
28 | 			| type   | name        | port |
29 | 			| peer   | my_peer     | 4123 |
30 | 		And I wait for 1 second
31 | 
32 | 		Then my_peer is connected to merlin
33 | 		When my_peer sends event RUNCMD_PACKET
34 | 			| sd      | 29		 							       |
35 | 			| content | command.name=test_command;command.command_line=echo OK;runcmd=test_command |
36 | 		And I wait for 4 second
37 | 
38 | 		Then file merlin.log matches RUNCMD: Can only accept runcmds over encrypted connections
39 | 
40 | 
41 | 	@encrypted
42 | 	Scenario: The peer sends a request to "ipc" to execute a RUNCMD without accept_runcmd set
43 | 		The peer should recieve a response back.
44 | 
45 | 		Given I start naemon with merlin nodes connected
46 | 			| type   | name        | port |
47 | 			| peer   | my_peer     | 4123 |
48 | 		And I wait for 1 second
49 | 
50 | 		Then my_peer is connected to merlin
51 | 		When my_peer sends event RUNCMD_PACKET
52 | 			| sd      | 29		 							       |
53 | 			| content | command.name=test_command;command.command_line=echo OK;runcmd=test_command |
54 | 		And I wait for 4 second
55 | 
56 | 		Then file merlin.log matches RUNCMD: accept_runcmd config setting not set for this node
57 | 
58 | 
59 | 	@encrypted
60 | 	Scenario: The peer sends a request to "ipc" to execute a RUNCMD with accept_runcmd set
61 | 		The peer should recieve a response back.
62 | 
63 | 		Given I start naemon with merlin nodes connected
64 | 			| type   | name        | port | accept_runcmd |
65 | 			| peer   | my_peer     | 4123 | 1             |
66 | 		And I wait for 1 second
67 | 
68 | 		Then my_peer is connected to merlin
69 | 		When my_peer sends event RUNCMD_PACKET
70 | 			| sd      | 29		 							       |
71 | 			| content | command.name=test_command;command.command_line=echo OK;runcmd=test_command |
72 | 		And I wait for 4 second
73 | 
74 | 		Then my_peer received event RUNCMD_PACKET contains
75 | 			| sd      | 29	      |
76 | 			| content | outstd=OK |
77 | 


--------------------------------------------------------------------------------
/features/scheduled_downtime.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler @livestatus
 2 | Feature: Schedule downtimes on hosts or services to avoid notifications during
 3 |     a given timespan
 4 | 
 5 |     Background: Set up naemon configuration
 6 |         Given I have naemon hostgroup objects
 7 |             | hostgroup_name | alias |
 8 |             | pollergroup    | PG    |
 9 |             | emptygroup     | EG    |
10 |         And I have naemon host objects
11 |             | use          | host_name | address   | max_check_attempts | hostgroups  |
12 |             | default-host | hostA     | 127.0.0.1 | 3                  | pollergroup |
13 |         And I have naemon service objects
14 |             | use             | host_name | description |
15 |             | default-service | hostA     | PONG        |
16 | 
17 |     Scenario: Scheduling a downtime locally
18 |         Given I start naemon with merlin nodes connected
19 |             | type   | name       | port | hostgroup  |
20 |             | peer   | the_peer   | 4001 | ignore     |
21 |             | poller | the_poller | 4002 | emptygroup |
22 |         When I put host hostA in downtime for 10 seconds
23 |         Then the_poller should not receive DOWNTIME
24 |         And the_peer should not receive DOWNTIME
25 | 


--------------------------------------------------------------------------------
/features/startup.feature:
--------------------------------------------------------------------------------
 1 | @config @daemons @merlin @queryhandler
 2 | Feature: Startup of merlin and Naemon
 3 | 
 4 | 	Scenario: Naemon and Merlin should be able to start correct even if a Merlin
 5 | 		node has unresolvable DNS.
 6 | 
 7 | 		Given I have merlin configured for port 7000
 8 | 			| type | name    | address   | port |
 9 | 			| peer | my_peer | my_peer   | 4123 |
10 | 
11 | 		When I start naemon
12 | 		And I wait for 1 second
13 | 
14 | 	Then my_peer should appear disconnected
15 | 
16 | 	@systemd
17 | 	Scenario: merlind should run as the monitor user when started from systemd
18 | 
19 | 		Given I start merlind with systemd
20 | 		Then merlind should not run as the root user
21 | 


--------------------------------------------------------------------------------
/features/step_definitions/cukemerlin.wire:
--------------------------------------------------------------------------------
1 | host: localhost
2 | port: 31221
3 | timeout:
4 |   invoke: 30


--------------------------------------------------------------------------------
/features/step_definitions/delay.rb:
--------------------------------------------------------------------------------
1 | Given /^I wait for (\d+) seconds?$/ do |n|
2 |   sleep(n.to_i)
3 | end


--------------------------------------------------------------------------------
/features/step_definitions/livestatus.rb:
--------------------------------------------------------------------------------
 1 | Then /^I should have ([0-9]+) ([^ ]+) objects? matching (.+)$/ do |count, type, filter|
 2 |   steps %Q{
 3 |     Given I submit the following livestatus query
 4 |       | GET #{type}       |
 5 |       | Filter: #{filter} |
 6 |       | StatsAnd: 0       |
 7 |     Then I should see the following livestatus response
 8 |       | stats_1  |
 9 |       | #{count} |
10 |   }
11 | end


--------------------------------------------------------------------------------
/features/step_definitions/merlin.rb:
--------------------------------------------------------------------------------
 1 | Given(/^([a-z0-9\-_]+) sends event ([A-Z_]+)$/) do |ref, event, values|
 2 |   defaults = {}
 3 |   if @merlin_packet_defaults.has_key? event then
 4 |     defaults = @merlin_packet_defaults[event].clone
 5 |   end
 6 | 
 7 |   # Allow multiple objects to be send
 8 |   values.transpose.hashes.each do |in_obj|
 9 |     # merge with default values and repack
10 |     in_obj = defaults.merge(in_obj)
11 |     step "#{ref} sends raw event #{event}", Cucumber::Ast::Table.new(in_obj.to_a)
12 |   end
13 | end
14 | 
15 | Then(/^(\d*) notifications? for host (.*) was sent after check result$/) do |count,h|
16 |   steps %Q{
17 |     Then file merlin.log has #{count} line matching holding host notification for #{h}$
18 |     And file merlin.log has #{count} line matching flushing host notification for #{h}$
19 |   }
20 | end
21 | 
22 | Then(/^(\d*) notifications? for service (.*) on host (.*) was sent after check result$/) do |count,s,h|
23 |   steps %Q{
24 |   Then file merlin.log has #{count} line matching holding service notification for #{s};#{h}$
25 |     And file merlin.log has #{count} line matching flushing service notification for #{s};#{h}$
26 |   }
27 | end
28 | 
29 | Then(/^no notification was held$/) do
30 |   step "file merlin.log does not match holding.*notification"
31 | end
32 | Then(/([a-z0-9\-_]+) (?:should appear|appears) disconnected$/) do |n|
33 |   steps %Q{
34 |     Given I ask query handler merlin nodeinfo
35 |       | filter_var | filter_val | match_var | match_val |
36 |       | name | #{n} | state | STATE_NONE |
37 |   }
38 | end
39 | 
40 | Then(/([a-z0-9\-_]+) (?:should appear|appears) connected$/) do |n|
41 |   steps %Q{
42 |     Given I ask query handler merlin nodeinfo
43 |       | filter_var | filter_val | match_var | match_val |
44 |       | name | #{n} | state | STATE_CONNECTED |
45 |   }
46 | end
47 | 
48 | Then(/([a-z0-9\-_]+) (?:should become|becomes) disconnected/) do |n|
49 |   steps %Q{
50 |     Then #{n} disconnects from merlin
51 |     And #{n} appears disconnected
52 |   }
53 | end


--------------------------------------------------------------------------------
/features/step_definitions/merlin_node_config.rb:
--------------------------------------------------------------------------------
1 | Given(/^I have merlin config ([^ ]+) set to (.+)$/) do |name, value|
2 |   @merlinnodeconfig.set_var(name, value)
3 | end
4 | 


--------------------------------------------------------------------------------
/features/step_definitions/naemon_object_config.rb:
--------------------------------------------------------------------------------
1 | Given(/^I have naemon (.+) objects$/) do |type, table|
2 |   table.hashes.each do |obj|
3 |     @naemonconfig.add_obj(type, obj)
4 |   end
5 | end
6 | 
7 | Given(/^I have naemon objects stored in (.+)$/) do |filename|
8 |   step "I have config file #{filename}", @naemonconfig.configfile
9 | end


--------------------------------------------------------------------------------
/features/step_definitions/naemon_system_config.rb:
--------------------------------------------------------------------------------
1 | Given(/^I have naemon config ([^ ]+) set to (.+)$/) do |name, value|
2 |   @naemonsysconfig.set_var(name, value)
3 | end
4 | 
5 | Given(/^I have naemon system config file ([^ ]+)$/) do |filename|
6 |   step "I have config file #{filename}", @naemonsysconfig.configfile
7 | end
8 | 


--------------------------------------------------------------------------------
/features/step_definitions/network_setup.rb:
--------------------------------------------------------------------------------
 1 | # Many test cases doesn't care about handshaking, but just that the correct
 2 | # nodes is configured and connected correctly. For those cases, this step just
 3 | # sets everything up according to the structure specified in the table.
 4 | 
 5 | Given(/^I start naemon with merlin nodes connected$/) do |nodes|
 6 |   sut_portnum = 7000
 7 | 
 8 |   configured_peers = 0
 9 |   configured_pollers = 0
10 |   configured_masters = 0
11 |   hostgroups = Hash.new(0)
12 | 
13 |   nodes.hashes.each do |obj|
14 |     case obj["type"]
15 |     when "peer"
16 |       configured_peers += 1
17 |     when "poller"
18 |       configured_pollers += 1
19 |       hostgroups[obj["hostgroup"]] += 1
20 |     when "master"
21 |       configured_masters += 1
22 |     end
23 |   end
24 | 
25 |   step "I have merlin configured for port #{sut_portnum}", nodes
26 |   step "ipc listens for merlin at socket test_ipc.sock"
27 |   step "I start naemon"
28 |   step "I wait for 1 second"
29 |   step "ipc received event CTRL_ACTIVE"
30 | 
31 |   # Just to clean up output, except from initial CTRL_ACTIVE
32 |   step "node ipc have info hash my_hash at 5000"
33 |   step "node ipc have expected hash my_hash at 5000"
34 | 
35 |   nodes.hashes.each do |obj|
36 |     step "node #{obj["name"]} have info hash my_hash at 3000"
37 |     step "node #{obj["name"]} have expected hash my_hash at 4000"
38 |     step "#{obj["name"]} connect to merlin at port #{sut_portnum} from port #{obj["port"].to_i+sut_portnum}"
39 |     case obj["type"]
40 |     when "peer"
41 |       step "#{obj["name"]} sends event CTRL_ACTIVE", Cucumber::Ast::Table.new([
42 |         ["configured_peers", configured_peers.to_s],
43 |         ["configured_pollers", configured_pollers.to_s],
44 |         ["configured_masters", configured_masters.to_s]
45 |       ])
46 |     when "poller"
47 |       step "#{obj["name"]} sends event CTRL_ACTIVE", Cucumber::Ast::Table.new([
48 |         ["configured_peers", (hostgroups[obj["hostgroup"]]-1).to_s],
49 |         ["configured_pollers", "0"],
50 |         ["configured_masters", (configured_peers+1).to_s]
51 |       ])
52 |     when "master"
53 |       # TODO: This makes no sense. The master should send the shape as the poller sees it.
54 |       step "#{obj["name"]} sends event CTRL_ACTIVE", Cucumber::Ast::Table.new([
55 |         ["configured_peers", 0],
56 |         ["configured_pollers", 0],
57 |         ["configured_masters", 0]
58 |       ])
59 |     end
60 |     step "#{obj["name"]} received event CTRL_ACTIVE"
61 |     step "#{obj["name"]} is connected to merlin"
62 |   end
63 | end


--------------------------------------------------------------------------------
/features/step_definitions/repeat.rb:
--------------------------------------------------------------------------------
 1 | # This step makes it possible to do:
 2 | #   Given for 3 times I send command SOMETHING
 3 | #
 4 | # Passing the "for 3 times" at the end makes it ambigous for steps having a
 5 | # wildcard at the end, for example if SOMETHING can contain spaces
 6 | Given(/^for ([\d]+) times (.*)$/) do |count, stepdef, *extra|
 7 |   for i in 1..count.to_i
 8 |     step stepdef, *extra
 9 |   end
10 | end


--------------------------------------------------------------------------------
/features/step_definitions/systemd_merlind.rb:
--------------------------------------------------------------------------------
 1 | # must be run as root with merlind installed
 2 | Given(/^I start merlind with systemd$/) do
 3 |     ret = system("systemctl start merlind")
 4 |     if (ret == false)
 5 |         fail("Failed to start merlind with systemd")
 6 |     end
 7 | end
 8 | 
 9 | 
10 | Then(/^merlind should not run as the root user$/) do
11 |     # verify merlind is not running as root user
12 |     # also fails if merlind is not running at all
13 |     ret = system("ps aux | grep merlind | grep -v grep | grep -v root")
14 |     if (ret == false)
15 |         fail("Merlind runs as root user or not at all")
16 |     end
17 | end
18 | 


--------------------------------------------------------------------------------
/features/support/database_config.rb:
--------------------------------------------------------------------------------
 1 | class DatabaseConfig
 2 |   attr_accessor :host
 3 |   attr_accessor :port
 4 |   attr_accessor :user
 5 |   attr_accessor :pass
 6 |   attr_accessor :name
 7 | 
 8 |   def initialize
 9 |     @host = "127.0.0.1" # 127.0.0.1 makes merlind use TCP instead of Unix socket
10 |     @port = "30000"
11 |     @user = "merlin"
12 |     @pass = "merlin"
13 |     @name = "merlin"
14 |   end
15 | end
16 | 
17 | Before do
18 |   @databaseconfig = DatabaseConfig.new
19 | end
20 | 


--------------------------------------------------------------------------------
/features/support/env.rb:
--------------------------------------------------------------------------------
 1 | # Make sure to use binaries in current working directory first, so we use newly
 2 | # compiled  in first case. Use the absolute path, so we can change working
 3 | # directory later.
 4 | #
 5 | # If started through CI, both cukemerlin and merlind is available installed, so
 6 | # it will use them in that case
 7 | 
 8 | testdir_path = Dir.pwd
 9 | ENV['PATH'] = "#{testdir_path}:#{ENV['PATH']}"
10 | 
11 | if ENV['CUKEMERLIN_AUTOSTART'] != "no" then
12 |   # Spawn cukemerlin (cucumber wire daemon)
13 |   cukemerlin = Process.spawn("cukemerlin --bind-port=31221")
14 | 
15 |   # Give cukemerlin time to start listen to the socket
16 |   sleep(2)
17 | 
18 |   at_exit do
19 |     Process.kill("TERM", cukemerlin)
20 |     Process.wait
21 |   end
22 | end


--------------------------------------------------------------------------------
/features/support/merlin_node_config.rb:
--------------------------------------------------------------------------------
 1 | class MerlinNodeConfig
 2 | 
 3 |   def initialize
 4 |     @current_config = {
 5 |       "notifies" => "yes",
 6 |       "binlog_dir" => ".",
 7 |       "oconfsplit_dir" => ".",
 8 |       "binlog_max_file_size" => "5000",
 9 |       "binlog_max_memory_size" => "500",
10 |       "binlog_persist" => "1",
11 |       "ipc_blocked_hostgroups" => ""
12 |     }
13 |   end
14 | 
15 |   def set_var(name, value)
16 |     @current_config[name] = value
17 |   end
18 | 
19 |   def get_var(name)
20 |     res = @current_config[name]
21 |     res
22 |   end
23 | end
24 | 
25 | Before do
26 |   # Create a global variable, that we can easily access it in the step definitions.
27 |   # However, the variable is intended to be accessed exclusively in the
28 |   # features/step_definitions/naemon_system_config.rb step definition for a
29 |   # neat logical isolation.
30 |   @merlinnodeconfig = MerlinNodeConfig.new
31 | end
32 | 


--------------------------------------------------------------------------------
/features/support/naemon_system_config.rb:
--------------------------------------------------------------------------------
 1 | class NaemonSystemConfig
 2 |   def initialize
 3 |     @current_config = {
 4 |       "query_socket" => "naemon.qh",
 5 |       "check_result_path" => "checkresults",
 6 |       "log_file" => "livestatus.log live",
 7 |       "event_broker_options" => "-1",
 8 |       "command_file" => "naemon.cmd",
 9 |       "object_cache_file" => "objects.cache",
10 |       "status_file" => "status_file.sav",
11 |       "log_file" => "naemon.log",
12 |       "retain_state_information" => "1",
13 |       "state_retention_file" => "status.sav",
14 |       "execute_host_checks" => "0",
15 |       "execute_service_checks" => "0"
16 |     }
17 |   end
18 | 
19 |   def set_var(name, value)
20 |     @current_config[name] = value
21 |   end
22 | 
23 |   def configfile
24 |     res = ""
25 |     @current_config.each do |name, value|
26 |       res += "#{name}=#{value}\n"
27 |     end
28 |     res
29 |   end
30 | end
31 | 
32 | Before do
33 |   # Create a global variable, that we can easily access it in the step definitions.
34 |   # However, the variable is intended to be accessed exclusively in the
35 |   # features/step_definitions/naemon_system_config.rb step definition for a
36 |   # neat logical isolation.
37 |   @naemonsysconfig = NaemonSystemConfig.new
38 | end
39 | 


--------------------------------------------------------------------------------
/generate_version_number.sh:
--------------------------------------------------------------------------------
1 | if [ -f .version_number ]; then
2 | 	cat .version_number | tr -d '\n'
3 | 	exit
4 | fi
5 | git describe --tags | sed 's/^v\([0-9.]*\).*$/\1/g' | tr -d '\n'
6 | 


--------------------------------------------------------------------------------
/install-merlin.sh.in:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # common variables used in default rules:
 4 | prefix=@prefix@
 5 | exec_prefix=@exec_prefix@
 6 | 
 7 | sqldir=@datarootdir@/merlin/sql
 8 | db_type=@db_type@
 9 | db_name=@db_name@
10 | db_user=@db_user@
11 | db_pass=@db_pass@
12 | 
13 | abort ()
14 | {
15 | 	echo "$@"
16 | 	echo "Aborting."
17 | 	exit 1
18 | }
19 | 
20 | db_setup ()
21 | {
22 | 	mysql="mysql"
23 | 	if [ -n "$db_user" ]; then
24 | 		mysql="$mysql -u$db_user"
25 | 		test -n "$db_pass" && mysql="$mysql -p$db_pass"
26 | 	fi
27 | 
28 | 	case "$db_type" in
29 | 		mysql)
30 | 			$(eval "$mysql -e 'use $db_name'")
31 | 			if [ $? -ne 0 ]; then
32 | 				echo "Couldn't connect to database, giving up."
33 | 				echo ""
34 | 				echo "Make sure there is a $db_type database called '$db_name',"
35 | 				echo "that $db_user can access it, and that you have provided the correct password"
36 | 				echo ""
37 | 				echo "Something similar to the below, depending on your mysql user login, should work:"
38 | 				echo "    mysql -uroot -e \"CREATE DATABASE IF NOT EXISTS $db_name\""
39 | 				echo "    mysql -uroot -e \"GRANT ALL ON $db_name.* TO $db_user@localhost IDENTIFIED BY '<password>'\""
40 | 				exit 1
41 | 			fi
42 | 
43 | 			test -z "$(eval "$mysql -f $db_name -se \"SHOW TABLES\"")"
44 | 			new_install=$?
45 | 			eval "$mysql -f $db_name" < $sqldir/mysql/merlin.sql
46 | 
47 | 			# Fetch db_version and do upgrade stuff if/when needed
48 | 			query="SELECT version FROM db_version"
49 | 			db_version=$(eval "$mysql $db_name -BNe \"$query\"")
50 | 
51 | 			# Check for upgrade scripts
52 | 			ver=$db_version
53 | 			if test "$db_version"; then
54 | 				while true; do
55 | 					nextver=$((ver+1))
56 | 					f="$sqldir/update-db-${ver}to${nextver}.sql"
57 | 					test -f "$f" || break
58 | 					eval "$mysql $db_name" < $f || abort "Incremental database upgrade from version $ver to version $nextver failed!"
59 | 					eval "$mysql $db_name -e \"UPDATE db_version SET version=$nextver\"" || abort "Failed to set new database version $nextver!"
60 | 					ver=$nextver
61 | 				done
62 | 			fi
63 | 			if [ $new_install -eq 0 ]; then
64 | 				for index in $sqldir/mysql/*-indexes.sql; do
65 | 					eval "$mysql -f $db_name" < $index
66 | 				done
67 | 			else
68 | 				# only check for indexes in report_data. sloppy, yes, but should be sufficient
69 | 				idx=$(eval "$mysql $db_name -N -s -e \"SHOW INDEX IN report_data\"" | wc -l);
70 | 				if [ $idx -eq '1' ]; then
71 | 					cat <<EOF
72 | ***************
73 | *** WARNING ***
74 | ***************
75 | 
76 | Some of your tables lack indexes, which might cause bad performance.
77 | Installing indexes might take quite some time (several hours for big installations), so I'm going
78 | to let you install them when it's convenient for you.
79 | 
80 | To install them manually, run:
81 | 
82 |     mon db fixindexes
83 | 
84 | EOF
85 | 				fi
86 | 			fi
87 | 			;;
88 | 		*)
89 | 			echo "Unknown database type '$db_type'"
90 | 			echo "I understand only lower-case database types."
91 | 			return 0
92 | 			;;
93 | 	esac
94 | }
95 | 
96 | 
97 | db_setup
98 | 


--------------------------------------------------------------------------------
/logs/no-lf-terminator.log:
--------------------------------------------------------------------------------
1 | [123] Testing


--------------------------------------------------------------------------------
/logs/nuls.log:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITRS-Group/monitor-merlin/216309152a44617ea74abb6ea58870d110a91b9f/logs/nuls.log


--------------------------------------------------------------------------------
/logs/single-read.log:
--------------------------------------------------------------------------------
1 | [1259938816] Testing
2 | 


--------------------------------------------------------------------------------
/merlind.service.in:
--------------------------------------------------------------------------------
 1 | [Unit]
 2 | Description=Merlin
 3 | After=syslog.target network.target mariadb.service
 4 | 
 5 | [Service]
 6 | #Starting the merlind with --debug option won't daemonize it.
 7 | #By doing this we leverage the rhel7 systemd unit file structure.
 8 | ExecStart=/usr/bin/merlind --config @pkgconfdir@/merlin.conf --debug
 9 | Restart=always
10 | User=@naemon_user@
11 | LimitNOFILE=16384
12 | 
13 | [Install]
14 | WantedBy=multi-user.target
15 | 


--------------------------------------------------------------------------------
/module/hooks.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_hooks_h__
 2 | #define INCLUDE_hooks_h__
 3 | 
 4 | #include <inttypes.h>
 5 | #include <naemon/naemon.h>
 6 | 
 7 | neb_cb_result * merlin_mod_hook(int cb, void *data);
 8 | extern void *neb_handle;
 9 | extern int merlin_hooks_init(uint32_t mask);
10 | extern int merlin_hooks_deinit(void);
11 | extern void merlin_set_block_comment(nebstruct_comment_data *cmnt);
12 | 
13 | #endif
14 | 


--------------------------------------------------------------------------------
/module/misc.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_misc_h__
 2 | #define INCLUDE_misc_h__
 3 | 
 4 | #include <time.h>
 5 | #include "module.h"
 6 | #include "sha1.h"
 7 | 
 8 | void file_list_free(struct file_list *list);
 9 | time_t get_last_cfg_change(void);
10 | file_list **get_sorted_oconf_files(unsigned int *n_files);
11 | int get_config_hash(unsigned char *hash);
12 | int hash_add_file(const char *path, blk_SHA_CTX *ctx);
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/module/net.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_net_h__
 2 | #define INCLUDE_net_h__
 3 | 
 4 | #include <netdb.h>
 5 | #include "shared.h"
 6 | 
 7 | extern unsigned short default_port;
 8 | extern unsigned int default_addr;
 9 | 
10 | extern int net_deinit(void);
11 | extern int net_init(void);
12 | extern int net_send_ipc_data(merlin_event *pkt);
13 | extern int net_is_connected(merlin_node *node);
14 | extern int net_try_connect(merlin_node *node);
15 | extern int net_sendto(merlin_node *node, merlin_event *pkt);
16 | extern int net_sendto_many(merlin_node **ntable, uint num, merlin_event *pkt);
17 | extern int net_input(int sd, int io_evt, void *node_);
18 | extern void disconnect_inactive(merlin_node *node);
19 | #endif /* INCLUDE_net_h__ */
20 | 


--------------------------------------------------------------------------------
/module/oconfsplit.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_oconfsplit_h__
 2 | #define INCLUDE_oconfsplit_h__
 3 | 
 4 | void split_init(void);
 5 | void split_deinit(void);
 6 | 
 7 | int split_config(void);
 8 | int split_grok_var(const char *var, const char *value);
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/module/queries.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_queries_h__
 2 | #define INCLUDE_queries_h__
 3 | 
 4 | #include "node.h"
 5 | 
 6 | int merlin_qh(int sd, char *buf, unsigned int len);
 7 | int runcmd_callback(merlin_node *node, merlin_event *pkt);
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/module/runcmd.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_runcmd_h__
 2 | #define INCLUDE_runcmd_h__
 3 | 
 4 | #include "node.h"
 5 | 
 6 | struct runcmd_ctx {
 7 |   struct merlin_runcmd * runcmd;
 8 |   struct merlin_node * node;
 9 |   uint16_t type;
10 | };
11 | typedef struct runcmd_ctx runcmd_ctx;
12 | 
13 | /* Sends a RUNCMD_PACKET */
14 | void send_runcmd_cmd(struct nm_event_execution_properties *evprop);
15 | /* Handles incoming RUNCMD_PACKETs */
16 | int handle_runcmd_event(merlin_node *node, merlin_event *pkt);
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/module/script-helpers.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_module_script_helpers_h__
 2 | #define INCLUDE_module_script_helpers_h__
 3 | #include "node.h"
 4 | int import_objects(char *cfg, char *cache);
 5 | void csync_node_active(merlin_node *node, const merlin_nodeinfo *info, int delta);
 6 | void csync_fetch(merlin_node *node);
 7 | void update_cluster_config(void);
 8 | void auto_delete_node_cmd(char * nodes_to_delete);
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/module/sha1.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_sha1_h__
 2 | #define INCLUDE_sha1_h__
 3 | /*
 4 |  * SHA1 routine optimized to do word accesses rather than byte accesses,
 5 |  * and to avoid unnecessary copies into the context array.
 6 |  *
 7 |  * This was initially based on the Mozilla SHA1 implementation, although
 8 |  * none of the original Mozilla code remains.
 9 |  */
10 | 
11 | typedef struct {
12 | 	unsigned long long size;
13 | 	unsigned int H[5];
14 | 	unsigned int W[16];
15 | } blk_SHA_CTX;
16 | 
17 | void blk_SHA1_Init(blk_SHA_CTX *ctx);
18 | void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *dataIn, unsigned long len);
19 | void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx);
20 | #endif
21 | 


--------------------------------------------------------------------------------
/module/testif_qh.c:
--------------------------------------------------------------------------------
 1 | #include "testif_qh.h"
 2 | #include <naemon/naemon.h>
 3 | #include <shared/node.h>
 4 | #include <shared/shared.h>
 5 | #include <shared/ipc.h>
 6 | #include <glib.h>
 7 | 
 8 | /**
 9 |  * Query handler inteface for test cases. Used to override runtime parameters
10 |  * to make it possible to have runtime parameters deterministically set, even
11 |  * if they in production might be incorrect.
12 |  *
13 |  * set hash <node> <hash> - Set the hash of a node (or ipc)
14 |  */
15 | static void merlin_testif_udpate_hash(merlin_node *node, const char *if_name, const char *type, const unsigned char *newhash, time_t last_cfg_change) {
16 | 	if(g_strcmp0(if_name, node->name) != 0) {
17 | 		return;
18 | 	}
19 | 	if (0 == g_strcmp0(type, "expected")) {
20 | 		memcpy(node->expected.config_hash, newhash, 20);
21 | 		node->expected.last_cfg_change = last_cfg_change;
22 | 	} else if (0 == g_strcmp0(type, "info")) {
23 | 		memcpy(node->info.config_hash, newhash, 20);
24 | 		node->info.last_cfg_change = last_cfg_change;
25 | 	}
26 | }
27 | 
28 | int merlin_testif_qh(int sd, char *buf) {
29 | 	gchar **parts = g_strsplit_set(buf, " ", 0);
30 | 	int retcode = 400;
31 | 	if( 0 == g_strcmp0(parts[0], "set") &&
32 | 		parts[1] != NULL && /* expected / info */
33 | 		0 == g_strcmp0(parts[2], "hash") &&
34 | 		parts[3] != NULL && /* node name (ipc, peer) */
35 | 		parts[4] != NULL && /* hash as hex, padded with 0 */
36 | 		parts[5] != NULL && /* last_cfg_change as integer */
37 | 		parts[6] == NULL
38 | 		) {
39 | 
40 | 		unsigned int i;
41 | 		unsigned int len;
42 | 		unsigned char newhash[20];
43 | 		time_t last_cfg_change = strtoull(parts[5], NULL, 10);
44 | 
45 | 
46 | 		memset(newhash, 0, 20);
47 | 		len = strlen(parts[4]);
48 | 		if(len > 40)
49 | 			len = 40;
50 | 		for(i=0;i+1<len;i+=2) {
51 | 			newhash[i/2] = (g_ascii_xdigit_value(parts[4][i+0]) << 4)
52 | 				| g_ascii_xdigit_value(parts[4][i+1]);
53 | 		}
54 | 
55 | 		nsock_printf(sd, "New hash: %s\n", newhash);
56 | 
57 | 		merlin_testif_udpate_hash(&ipc, parts[3], parts[1], newhash, last_cfg_change);
58 | 		for(i = 0; i < num_nodes; i++) {
59 | 			merlin_testif_udpate_hash(node_table[i], parts[3], parts[1], newhash, last_cfg_change);
60 | 		}
61 | 		retcode = 200;
62 | 	}
63 | 	g_strfreev(parts);
64 | 	return retcode;
65 | }
66 | 


--------------------------------------------------------------------------------
/module/testif_qh.h:
--------------------------------------------------------------------------------
1 | #ifndef INCLUDE_testcase_qh_h__
2 | #define INCLUDE_testcase_qh_h__
3 | 
4 | /* Handle test case query handler */
5 | int merlin_testif_qh(int sd, char *buf);
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/nrpe-merlin.cfg:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | #
 3 | # op5-nrpe command configuration file
 4 | #
 5 | # COMMAND DEFINITIONS
 6 | # Syntax:
 7 | #	command[<command_name>]=<command_line>
 8 | #
 9 | command[mon_procs]=/opt/plugins/check_procs -w 1:350 -c 1:600 -C naemon
10 | command[mon_cpu]=/opt/plugins/check_procs -w 30 -c 50 --metric=CPU -C naemon
11 | command[mon_vsz]=/opt/plugins/check_procs -w 700000 -c 800000 --metric=VSZ -C naemon
12 | command[naemon_parent_proc]=/opt/plugins/check_procs -p 1 -w 1:1 -c 1:1 -C naemon
13 | command[merlin_procs]=/opt/plugins/check_procs -w 1:1 -c 1:1 -C merlind
14 | command[merlin_cpu]=/opt/plugins/check_procs -w 5 -c 10 --metric=CPU -C merlind
15 | command[merlin_vsz]=/opt/plugins/check_procs -w 475000 -c 600000 --metric=VSZ -C merlind
16 | command[mysql]=/opt/plugins/check_mysql -d merlin -u merlin -p merlin
17 | command[mysql_vsz]=/opt/plugins/check_procs -w 5250000 -c 7500000 --metric=VSZ -C mysqld
18 | command[mer_prog_status]=/usr/bin/asmonitor -q /usr/bin/mon check status
19 | command[host_latency]=/usr/bin/asmonitor -q /usr/bin/mon check latency host
20 | command[service_latency]=/usr/bin/asmonitor -q /usr/bin/mon check latency service
21 | command[host_exectime]=/usr/bin/asmonitor -q /usr/bin/mon check exectime host
22 | command[service_exectime]=/usr/bin/asmonitor -q /usr/bin/mon check exectime service
23 | command[host_orphans]=/usr/bin/asmonitor -q /usr/bin/mon check orphans host
24 | command[service_orphans]=/usr/bin/asmonitor -q /usr/bin/mon check orphans service
25 | command[cores]=/usr/bin/asmonitor -q /usr/bin/mon check cores
26 | command[spooled_checks]=/usr/bin/asmonitor -q /usr/bin/mon check spool checks --delete
27 | command[spooled_perfdata]=/usr/bin/asmonitor -q /usr/bin/mon check spool perfdata
28 | command[check_distribution]=/usr/bin/asmonitor -q /usr/bin/mon check distribution
29 | 


--------------------------------------------------------------------------------
/op5build/ci_config.yml:
--------------------------------------------------------------------------------
 1 | vm-config: |
 2 |   {"numCPUs": 4}
 3 | post:
 4 |   steps: |
 5 |     set -x
 6 |     mkdir --parents --mode=777 /mnt/logs/merlin_dtest
 7 |     mon test dist --basepath=/mnt/logs/merlin_dtest
 8 |     mon test rsync
 9 |     rm --force --recursive /mnt/logs/merlin_dtest
10 |     sudo -u monitor mon test rsync
11 | 
12 |     # Run unit tests
13 |     pushd /mnt/git/apps/libexec
14 |     python3 -m pytest
15 |     popd
16 | 
17 |     # Verify file permissions after installation
18 |     stat --printf='%U:%G %a' /opt/monitor/op5/merlin/merlin.conf | xargs -I{} test "root:apache 660" = "{}"
19 | 
20 |     gpg2 --keyserver hkp://keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
21 |     curl -sSL https://get.rvm.io | bash -s stable
22 |     source /usr/local/rvm/scripts/rvm
23 |     rvm install 2.7
24 |     rvm use 2.7 --default
25 |     ruby -v
26 | 
27 |     # Install requirements for cucumber test
28 |     gem install \
29 |         mysql2 \
30 |         cucumber:1.3.18 \
31 |         rspec:2.14.1 \
32 |         parallel:1.13.0 \
33 |         parallel_tests:2.23.0 \
34 |         syntax:1.0.0 \
35 |         sequel:5.71.0
36 | 
37 |     # Run cucumber tests
38 |     ulimit -c unlimited
39 |     mkdir -p /mnt/logs
40 | 
41 |     cucumber ${VERBOSE:+-v} --strict --format html \
42 |         --out /mnt/logs/cucumber.html --format pretty\
43 |         --tags ~@encrypted
44 |     # Run the test suite again, but with encryption enabled
45 |     # Some tests has been disabled. These tests pass just fine when running the
46 |     # test suite with encryption enabled only, but for some reason fail when
47 |     # running after the above test, without encryption enabled. Further the
48 |     # disabled tests do not have any peers/pollers so encryption shouldn't
49 |     # affect them.
50 |     mon merlinkey generate
51 |     export MERLIN_ENCRYPTED=TRUE
52 |     export MERLIN_PUBKEY=/opt/monitor/op5/merlin/key.pub
53 |     export MERLIN_PRIVKEY=/opt/monitor/op5/merlin/key.priv
54 |     cucumber ${VERBOSE:+-v} --strict --format html \
55 |         --out /mnt/logs/cucumber_encrypted.html \
56 |         --format pretty --exclude "report_data" --tags ~@unstable --tags ~@unencrypted
57 | 


--------------------------------------------------------------------------------
/op5build/nacoma_hook.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import sys
 4 | from nacoma.hooks import Change
 5 | reportable_types = ['host', 'service']
 6 | 
 7 | libexec_dir = "@@LIBEXECDIR@@/mon/modules"
 8 | sys.path.insert(0, libexec_dir)
 9 | import merlin_conf as mconf
10 | mconf.parse()
11 | import merlin_db
12 | conn = merlin_db.connect(mconf)
13 | cursor = conn.cursor()
14 | 
15 | for line in sys.stdin:
16 |     change = Change(line)
17 |     if change.type not in reportable_types:
18 |         continue
19 |     if change.is_renamed():
20 |         if change.type == 'host':
21 |             arg = (change.oldname, change.newname)
22 |             query = 'INSERT INTO rename_log(from_host_name, from_service_description, to_host_name, to_service_description) VALUES (%s, NULL, %s, NULL)'
23 |             cursor.execute(query, arg)
24 |         else:
25 |             arg = change.oldname.split(';') + change.newname.split(';')
26 |             query = 'INSERT INTO rename_log(from_host_name, from_service_description, to_host_name, to_service_description) VALUES (%s, %s, %s, %s)'
27 |             cursor.execute(query, arg)
28 | conn.commit()
29 | conn.close()
30 | 


--------------------------------------------------------------------------------
/shared/cfgfile.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_cfgfile_h__
 2 | #define INCLUDE_cfgfile_h__
 3 | 
 4 | #include <stdlib.h>
 5 | 
 6 | /* types */
 7 | struct cfg_var {
 8 | 	unsigned line; /* starting line */
 9 | 	char *key;
10 | 	char *value;
11 | 	size_t key_len;
12 | 	size_t value_len;
13 | };
14 | 
15 | struct cfg_comp {
16 | 	char *name;               /* compound name */
17 | 	char *buf;                /* file contents, if this is a file */
18 | 	unsigned int vars;        /* number of variables */
19 | 	unsigned int vlist_len;   /* size of vlist */
20 | 	unsigned start;           /* starting line */
21 | 	unsigned nested;          /* number of compounds nested below this */
22 | 	struct cfg_var **vlist;   /* array of variables */
23 | 	struct cfg_comp *parent;  /* nested from */
24 | 	struct cfg_comp **nest;   /* compounds nested inside this one */
25 | };
26 | 
27 | /* prototypes */
28 | extern struct cfg_comp *cfg_parse_file(const char *path);
29 | extern void cfg_destroy_compound(struct cfg_comp *comp);
30 | extern void cfg_warn(struct cfg_comp *comp, struct cfg_var *v, const char *fmt, ...)
31 | 	__attribute__((__format__(__printf__, 3, 4)));
32 | extern void cfg_error(struct cfg_comp *comp, struct cfg_var *v, const char *fmt, ...)
33 | 	__attribute__((__format__(__printf__, 3, 4), __noreturn__));
34 | #endif /* _CONFIG_H */
35 | 


--------------------------------------------------------------------------------
/shared/codec.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_codec_h__
 2 | #define INCLUDE_codec_h__
 3 | 
 4 | #include "logging.h"
 5 | #include "shared.h"
 6 | #include "node.h"
 7 | #include <naemon/naemon.h>
 8 | 
 9 | int merlin_encode(void *data, int cb_type, char *buf, int buflen);
10 | int merlin_decode(void *ds, off_t len, int cb_type);
11 | static inline int merlin_encode_event(merlin_event *pkt, void *data)
12 | {
13 | 	return merlin_encode(data, pkt->hdr.type, pkt->body, sizeof(pkt->body));
14 | }
15 | static inline int merlin_decode_event(merlin_node *node, merlin_event *pkt)
16 | {
17 | 	int ret = merlin_decode(pkt->body, pkt->hdr.len, pkt->hdr.type);
18 | 
19 | 	if (ret) {
20 | 		lerr("CODEC: Failed to decode packet from '%s'. type: %u (%s); code: %u; len: %u",
21 | 			 node ? node->name : "(unknown)", pkt->hdr.type, callback_name(pkt->hdr.type), pkt->hdr.code, pkt->hdr.len);
22 | 	}
23 | 	return ret;
24 | }
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/shared/compat.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_compat_h__
 2 | #define INCLUDE_compat_h__
 3 | 
 4 | /*
 5 |  * CHAR_BIT really should be 8 on all systems we care about
 6 |  */
 7 | #ifndef CHAR_BIT
 8 | # define CHAR_BIT 8
 9 | #endif
10 | 
11 | #ifdef __WORDSIZE
12 | # define COMPAT_WORDSIZE __WORDSIZE
13 | #else
14 | # define COMPAT_WORDSIZE (sizeof(void *) * CHAR_BIT)
15 | #endif
16 | 
17 | /* runtime detection of endianness with GNU style macros */
18 | #define COMPAT_LITTLE_ENDIAN 1234
19 | #define COMPAT_BIG_ENDIAN    4321
20 | 
21 | static inline unsigned int endianness(void)
22 | {
23 | 	int i = 1;
24 | 
25 | #ifdef __BYTE_ORDER
26 | 	if (__BYTE_ORDER == COMPAT_LITTLE_ENDIAN || __BYTE_ORDER == COMPAT_BIG_ENDIAN)
27 | 		return __BYTE_ORDER;
28 | #elif defined(_BYTE_ORDER)
29 | 	if (_BYTE_ORDER == COMPAT_LITTLE_ENDIAN || _BYTE_ORDER == COMPAT_BIG_ENDIAN)
30 | 		return _BYTE_ORDER;
31 | #endif /* __BYTE_ORDER */
32 | 
33 | 	if (((char *)&i)[0] == 1)
34 | 		return COMPAT_LITTLE_ENDIAN;
35 | 
36 | 	return COMPAT_BIG_ENDIAN;
37 | }
38 | 
39 | #ifdef NEEDS_MEMRCHR
40 | extern void *memrchr(const void *s, int c, size_t n);
41 | #endif
42 | 
43 | #ifdef NEEDS_ASPRINTF
44 | #include <stdarg.h>
45 | extern int asprintf(char **strp, const char *fmt, ...);
46 | extern int vasprintf(char **strp, const char *fmt, va_list ap);
47 | #endif
48 | 
49 | #ifndef NEBATTR_CHECK_ALERT
50 | # define NEBATTR_CHECK_ALERT 1
51 | #endif
52 | 
53 | #endif /* INCLUDE_compat_h__ */
54 | 


--------------------------------------------------------------------------------
/shared/configuration.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Common configuration definitions between module and daemon
 3 |  */
 4 | 
 5 | #ifndef INCLUDE_configuration_h__
 6 | #define INCLUDE_configuration_h__
 7 | 
 8 | #include "node.h"
 9 | #include "cfgfile.h"
10 | 
11 | extern int db_log_reports;
12 | extern int db_log_notifications;
13 | extern merlin_confsync global_csync;
14 | 
15 | int grok_confsync_compound(struct cfg_comp *comp, merlin_confsync *csync);
16 | int grok_common_var(struct cfg_comp *config, struct cfg_var *v);
17 | void grok_db_compound(struct cfg_comp *c);
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/shared/encryption.c:
--------------------------------------------------------------------------------
 1 | #include "shared.h"
 2 | #include "configuration.h"
 3 | #include "logging.h"
 4 | #include "ipc.h"
 5 | #include "node.h"
 6 | #include <errno.h>
 7 | #include <string.h>
 8 | #include <unistd.h>
 9 | #include <sodium.h>
10 | #include <stdbool.h>
11 | 
12 | bool sodium_init_done = false;
13 | int init_sodium(void);
14 | 
15 | int open_encryption_key(const char * path, unsigned char * target, size_t size){
16 | 	FILE *f;
17 | 	size_t read;
18 | 
19 | 	f = fopen(path, "r");
20 | 	if (f == NULL) {
21 | 		lerr("Failed to open encryption file for writing");
22 | 		return -1;
23 | 	}
24 | 
25 | 	read = fread(target, size, 1, f);
26 | 	if (read != 1) {
27 | 		lerr("Could not read encryption key");
28 | 		return -1;
29 | 	}
30 | 
31 | 	if (fclose(f) != 0) {
32 | 		lerr("Failed open encryption file stream");
33 | 		return -1;
34 | 	}
35 | 	return 0;
36 | }
37 | 
38 | int init_sodium() {
39 | 	if (sodium_init_done == false) {
40 | 		if (sodium_init() < 0) {
41 | 			lwarn("sodium_init failed\n");
42 | 			return -1;
43 | 		} else {
44 | 			sodium_init_done = true;
45 | 		}
46 | 	}
47 | 	return 0;
48 | }
49 | 
50 | int encrypt_pkt(merlin_event * pkt, merlin_node * recv) {
51 | 	ldebug("Encrypting pkt for node: %s", recv->name);
52 | 	if (init_sodium() == -1) {
53 | 		return -1;
54 | 	}
55 | 
56 | 	randombytes_buf(pkt->hdr.nonce, sizeof(pkt->hdr.nonce));
57 | 
58 | 	if (crypto_box_detached_afternm(
59 | 				(unsigned char *)pkt->body, pkt->hdr.authtag,
60 | 				(unsigned char *)pkt->body, pkt->hdr.len,
61 | 				pkt->hdr.nonce, recv->sharedkey) != 0) {
62 | 		lerr("could not encrypt msg!\n");
63 | 		return -1;
64 | 	}
65 | 
66 | 	ldebug("Pkt encryption for node: %s succeeded", recv->name);
67 | 
68 | 	return 0;
69 | }
70 | 
71 | int decrypt_pkt(merlin_event * pkt, merlin_node * sender) {
72 | 	ldebug("Decrypting pkt from node: %s", sender->name);
73 | 	if (init_sodium() == -1) {
74 | 		return -1;
75 | 	}
76 | 
77 | 	if (crypto_box_open_detached_afternm(
78 | 				(unsigned char *)pkt->body,
79 | 				(const unsigned char *)pkt->body,
80 | 				pkt->hdr.authtag, pkt->hdr.len, pkt->hdr.nonce,
81 | 				sender->sharedkey) != 0) {
82 | 		lerr("Encrypted message forged!\n");
83 | 		return -1;
84 | 	}
85 | 
86 | 	ldebug("Pkt decryption from node: %s succeeded", sender->name);
87 | 
88 | 	return 0;
89 | }
90 | 
91 | 
92 | 


--------------------------------------------------------------------------------
/shared/encryption.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_encryption_h__
 2 | #define INCLUDE_encryption_h__
 3 | 
 4 | #include "shared.h"
 5 | 
 6 | int encrypt_pkt(merlin_event * pkt, merlin_node * sender);
 7 | int decrypt_pkt(merlin_event * pkt, merlin_node * recv);
 8 | int open_encryption_key(const char * path, unsigned char * target, size_t size);
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/shared/io.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * I/O utilities
 3 |  */
 4 | 
 5 | #include "io.h"
 6 | #include "shared.h"
 7 | #include "logging.h"
 8 | 
 9 | #include <string.h>
10 | 
11 | int io_poll(int fd, int events, int msec)
12 | {
13 | 	struct pollfd pfd;
14 | 
15 | 	pfd.fd = fd;
16 | 	pfd.events = events;
17 | 
18 | 	return poll(&pfd, 1, msec);
19 | }
20 | 
21 | int io_send_all(int fd, const void *buf, size_t len)
22 | {
23 | 	int poll_ret, sent, loops = 0;
24 | 	size_t total = 0;
25 | 
26 | 	if (!buf || !len)
27 | 		return 0;
28 | 
29 | 	poll_ret = io_poll(fd, POLLOUT, 0);
30 | 	if (poll_ret < 0)
31 | 		lerr("io_poll(%d, POLLOUT, 0) returned %d: %s", fd, poll_ret, strerror(errno));
32 | 
33 | 	do {
34 | 		loops++;
35 | 		sent = send(fd, buf + total, len - total, MSG_DONTWAIT);
36 | 		if (poll_ret > 0 && sent + total == 0) {
37 | 			/* disconnected peer? */
38 | 			return 0;
39 | 		}
40 | 		if (sent < 0) {
41 | 			if (errno == EAGAIN || errno == EWOULDBLOCK) {
42 | 				sent = io_write_ok(fd, 100);
43 | 				continue;
44 | 			}
45 | 
46 | 			lerr("send(%d, (buf + total), %zu, MSG_DONTWAIT) returned %d (%s)",
47 | 				 fd, len - total, sent, strerror(errno));
48 | 			continue;
49 | 		}
50 | 
51 | 		total += sent;
52 | 	} while (total < len && sent > 0 && loops < 15);
53 | 
54 | 	if (sent < 0)
55 | 		return sent;
56 | 
57 | 	return total;
58 | }
59 | 


--------------------------------------------------------------------------------
/shared/io.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_io_h__
 2 | #define INCLUDE_io_h__
 3 | 
 4 | #include <sys/types.h>
 5 | #include <sys/poll.h>
 6 | #include <sys/socket.h>
 7 | 
 8 | #define io_read_ok(fd, msec) io_poll(fd, POLLIN, msec)
 9 | #define io_write_ok(fd, msec) io_poll(fd, POLLOUT, msec)
10 | extern int io_poll(int fd, int events, int msec);
11 | extern int io_send_all(int fd, const void *buf, size_t len);
12 | 
13 | #endif /* INCLUDE_io_h__ */
14 | 


--------------------------------------------------------------------------------
/shared/ipc.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_ipc_h__
 2 | #define INCLUDE_ipc_h__
 3 | 
 4 | #include <unistd.h>
 5 | #include <sys/un.h>
 6 | #include "node.h"
 7 | 
 8 | #ifndef UNIX_PATH_MAX
 9 | # define UNIX_PATH_MAX 108
10 | #endif
11 | extern merlin_node ipc;
12 | 
13 | extern void ipc_init_struct(void);
14 | extern int ipc_init(void);
15 | extern void ipc_deinit(void);
16 | extern int ipc_grok_var(char *var, char *val);
17 | extern int ipc_ctrl(int code, uint sel, void *data, uint32_t len);
18 | extern int ipc_send_event(merlin_event *pkt);
19 | extern int ipc_listen_sock_desc(void);
20 | extern int ipc_is_connected(int msec);
21 | extern int ipc_reinit(void);
22 | extern int ipc_accept(void);
23 | extern void ipc_log_event_count(void);
24 | 
25 | #define ipc_send_ctrl(code, sel) ipc_ctrl(code, sel, NULL, 0)
26 | #endif /* INCLUDE_ipc_h__ */
27 | 


--------------------------------------------------------------------------------
/shared/logging.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_mrln_logging_h__
 2 | #define INCLUDE_mrln_logging_h__
 3 | 
 4 | #include <stdarg.h>
 5 | #include <stdio.h>
 6 | #include <syslog.h>
 7 | 
 8 | #ifdef DEBUG_LOGGING
 9 | # define ldebug(fmt, args...) \
10 | 	log_msg(LOG_DEBUG, "%s:%s():%d: " fmt, __FILE__, __func__, __LINE__, ##args)
11 | # define linfo(fmt, args...) \
12 | 	log_msg(LOG_INFO, "%s:%s():%d " fmt, __FILE__, __func__, __LINE__, ##args)
13 | # define lmsg(fmt, args...) \
14 | 	log_msg(LOG_NOTICE, "%s:%s():%d " fmt, __FILE__, __func__, __LINE__, ##args)
15 | # define lwarn(fmt, args...) \
16 | 	log_msg(LOG_WARNING, "%s:%s():%d " fmt, __FILE__, __func__, __LINE__, ##args)
17 | # define lerr(fmt, args...) \
18 | 	log_msg(LOG_ERR, "%s:%s():%d " fmt, __FILE__, __func__, __LINE__, ##args)
19 | #else
20 | # define ldebug(fmt, args...) log_msg(LOG_DEBUG, fmt, ##args)
21 | # define linfo(fmt, args...) log_msg(LOG_INFO, fmt, ##args)
22 | # define lmsg(fmt, args...) log_msg(LOG_NOTICE, fmt, ##args)
23 | # define lwarn(fmt, args...) log_msg(LOG_WARNING, fmt, ##args)
24 | # define lerr(fmt, args...) log_msg(LOG_ERR, fmt, ##args)
25 | #endif
26 | 
27 | extern int log_init(void);
28 | extern void log_deinit(void);
29 | extern int log_grok_var(char *var, char *val);
30 | extern void log_msg(int severity, const char *fmt, ...)
31 | 	__attribute__((__format__(__printf__, 2, 3)));
32 | #endif
33 | 


--------------------------------------------------------------------------------
/shared/pgroup.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_pgroup_h__
 2 | #define INCLUDE_pgroup_h__
 3 | 
 4 | #include <naemon/naemon.h>
 5 | #include <stdint.h>
 6 | 
 7 | struct merlin_node;
 8 | struct merlin_event;
 9 | 
10 | /* nodeflags that must be shared between all nodes in a peer group */
11 | #define PGROUP_NODE_FLAGS (MERLIN_NODE_TAKEOVER)
12 | 
13 | #define assigned_peer(id, active_peers) (active_peers ? ((id) % (active_peers)) : 0)
14 | 
15 | /* track assigned objects */
16 | struct merlin_assigned_objects {
17 | 	int32_t hosts, services;
18 | };
19 | 
20 | struct merlin_peer_group {
21 | 	int id;
22 | 	struct merlin_node **nodes;
23 | 	unsigned int active_nodes;
24 | 	unsigned int total_nodes;
25 | 	unsigned int num_hostgroups;
26 | 	int overlapping;
27 | 	int flags; /* flags shared between nodes */
28 | 	/*
29 | 	 * counts for how hosts and services should be distributed
30 | 	 * Access as assign[node->pg->active_nodes][node->peer_id]
31 | 	 * to find out how many checks a node should run.
32 | 	 * When all pollers in this peer-group are offline, the
33 | 	 * checks will be distributed to the master nodes according
34 | 	 * to the same mapping.
35 | 	 */
36 | 	unsigned int alloc;
37 | 	struct merlin_assigned_objects **assign;
38 | 	struct merlin_assigned_objects **inherit;
39 | 	struct merlin_assigned_objects assigned;
40 | 	char *hostgroups;
41 | 	char **hostgroup_array;
42 | 	bitmap *host_map;
43 | 	bitmap *service_map;
44 | 	uint32_t *host_id_table;
45 | 	uint32_t *service_id_table;
46 | };
47 | typedef struct merlin_peer_group merlin_peer_group;
48 | 
49 | void pgroup_assign_peer_ids(merlin_peer_group *pg);
50 | int pgroup_init(void);
51 | void pgroup_deinit(void);
52 | int pgroup_send_event(merlin_peer_group *pg, struct merlin_event *pkt);
53 | merlin_peer_group *pgroup_by_host_id(unsigned int id);
54 | merlin_peer_group *pgroup_by_service_id(unsigned int id);
55 | struct merlin_node *pgroup_host_node(unsigned int id);
56 | struct merlin_node *pgroup_service_node(unsigned int id);
57 | char *get_sorted_csstr(const char *orig_str);
58 | #endif
59 | 


--------------------------------------------------------------------------------
/sort-merge_logs.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | #
 3 | # import_logs.sh - poller log concatenation for master servers
 4 | #
 5 | # This script is meant to be run on a master server when pollers
 6 | # have sent in their logfiles. It will execute the op5 import
 7 | # program to inject the logfiles into the database, thereby
 8 | # making them available for graphing with the pretty, pretty
 9 | # report library and gui
10 | 
11 | pushed_logs=/opt/monitor/pushed_logs
12 | import=/opt/monitor/op5/reports/module/import
13 | log_file=/opt/monitor/var/nagios.log
14 | archive_dir=/opt/monitor/var/archives
15 | test -d $archive_dir &&
16 | 	newest_archived=$(/bin/ls --color=none -rt1 $archive_dir/*.log 2>/dev/null | tail -1)
17 | 
18 | merged=$(mktemp)
19 | trap "rm -f $merged" 0 1 2 3 15
20 | mkdir -m 777 -p $pushed_logs/importing
21 | mv $pushed_logs/*.log.gz $pushed_logs/importing
22 | (cat $newest_archived $log_file; zcat $pushed_logs/importing/*.log.gz) \
23 | 	| sort > $merged && \
24 | 	$import --incremental $merged && \
25 | 	rm -rf $pushed_logs/importing
26 | 


--------------------------------------------------------------------------------
/sql/mysql/drop_indexes.sql:
--------------------------------------------------------------------------------
 1 | DROP INDEX rd_timestamp ON report_data;
 2 | DROP INDEX rd_event_type ON report_data;
 3 | DROP INDEX rd_host_name ON report_data;
 4 | DROP INDEX rd_service_name ON report_data;
 5 | DROP INDEX rd_state ON report_data;
 6 | DROP INDEX pd_time ON perfdata;
 7 | DROP INDEX pd_host_name ON perfdata;
 8 | DROP INDEX pd_service_name ON perfdata;
 9 | DROP INDEX n_host_name ON notification;
10 | DROP INDEX n_service_name ON notification;
11 | DROP INDEX n_contact_name ON notification;
12 | 


--------------------------------------------------------------------------------
/sql/mysql/notification-indexes.sql:
--------------------------------------------------------------------------------
1 | CREATE INDEX n_host_name ON notification(host_name);
2 | CREATE INDEX n_service_name ON notification(host_name, service_description);
3 | CREATE INDEX n_contact_name ON notification(contact_name);
4 | 


--------------------------------------------------------------------------------
/sql/mysql/perfdata-indexes.sql:
--------------------------------------------------------------------------------
1 | CREATE INDEX pd_time ON perfdata(timestamp);
2 | CREATE INDEX pd_host_name ON perfdata(host_name);
3 | CREATE INDEX pd_service_name ON perfdata(host_name, service_description);
4 | 


--------------------------------------------------------------------------------
/sql/update-db-1to2.sql:
--------------------------------------------------------------------------------
1 | ALTER TABLE notification
2 | 	ADD COLUMN command_name VARCHAR(255) AFTER
3 | 	service_description;
4 | 


--------------------------------------------------------------------------------
/sql/update-db-2to3.sql:
--------------------------------------------------------------------------------
 1 | CREATE TABLE report_data_tmp (
 2 | 	`id` bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
 3 | 	`timestamp` int(11) NOT NULL DEFAULT '0',
 4 | 	`event_type` int(11) NOT NULL DEFAULT '0',
 5 | 	`flags` int(11) DEFAULT NULL,
 6 | 	`attrib` int(11) DEFAULT NULL,
 7 | 	`host_name` varchar(255) COLLATE latin1_general_cs DEFAULT '',
 8 | 	`service_description` varchar(255) COLLATE latin1_general_cs DEFAULT '',
 9 | 	`state` int(2) NOT NULL DEFAULT '0',
10 | 	`hard` int(2) NOT NULL DEFAULT '0',
11 | 	`retry` int(5) NOT NULL DEFAULT '0',
12 | 	`downtime_depth` int(11) DEFAULT NULL,
13 | 	`output` text COLLATE latin1_general_cs,
14 | 	`long_output` text COLLATE latin1_general_cs,
15 | 	KEY `rd_timestamp` (`timestamp`),
16 | 	KEY `rd_event_type` (`event_type`),
17 | 	KEY `rd_name_evt_time` (`host_name`,`service_description`,`event_type`,`hard`,`timestamp`),
18 | 	KEY `rd_state` (`state`)
19 | );
20 | 
21 | INSERT INTO report_data_tmp (`timestamp`, `event_type`, `flags`, `attrib`, `host_name`, `service_description`, `state`, `hard`, `retry`, `downtime_depth`, `output`)
22 | SELECT `timestamp`, `event_type`, `flags`, `attrib`, `host_name`, `service_description`, `state`, `hard`, `retry`, `downtime_depth`, `output`
23 | FROM report_data;
24 | 
25 | ALTER TABLE report_data RENAME report_data_old;
26 | ALTER TABLE report_data_tmp RENAME report_data;
27 | DROP TABLE report_data_old;
28 | 
29 | -- No id added for report_data_extras, only long_output
30 | 
31 | CREATE TABLE report_data_extras_tmp (
32 | 	`timestamp` int(11) NOT NULL DEFAULT '0',
33 | 	`event_type` int(11) NOT NULL DEFAULT '0',
34 | 	`flags` int(11) DEFAULT NULL,
35 | 	`attrib` int(11) DEFAULT NULL,
36 | 	`host_name` varchar(255) COLLATE latin1_general_cs DEFAULT '',
37 | 	`service_description` varchar(255) COLLATE latin1_general_cs DEFAULT '',
38 | 	`state` int(2) NOT NULL DEFAULT '0',
39 | 	`hard` int(2) NOT NULL DEFAULT '0',
40 | 	`retry` int(5) NOT NULL DEFAULT '0',
41 | 	`downtime_depth` int(11) DEFAULT NULL,
42 | 	`output` text COLLATE latin1_general_cs,
43 | 	`long_output` text COLLATE latin1_general_cs,
44 | 	KEY `rd_timestamp` (`timestamp`),
45 | 	KEY `rd_event_type` (`event_type`),
46 | 	KEY `rd_name_evt_time` (`host_name`,`service_description`,`event_type`,`hard`,`timestamp`),
47 | 	KEY `rd_state` (`state`)
48 | );
49 | 
50 | INSERT INTO report_data_extras_tmp (`timestamp`, `event_type`, `flags`, `attrib`, `host_name`, `service_description`, `state`, `hard`, `retry`, `downtime_depth`, `output`)
51 | SELECT `timestamp`, `event_type`, `flags`, `attrib`, `host_name`, `service_description`, `state`, `hard`, `retry`, `downtime_depth`, `output`
52 | FROM report_data_extras;
53 | 
54 | ALTER TABLE report_data_extras RENAME report_data_extras_old;
55 | ALTER TABLE report_data_extras_tmp RENAME report_data_extras;
56 | DROP TABLE report_data_extras_old;
57 | 


--------------------------------------------------------------------------------
/sudo/merlin.in:
--------------------------------------------------------------------------------
 1 | Defaults:@naemon_user@ !requiretty
 2 | @naemon_user@ ALL=(root) NOPASSWD:/usr/bin/mon restart
 3 | @naemon_user@ ALL=(root) NOPASSWD:/usr/bin/op5 restart
 4 | 
 5 | Cmnd_Alias      MON_OPERATOR =  /usr/bin/mon node,\
 6 |         /usr/bin/mon node status,\
 7 |         /usr/bin/mon node list*,\
 8 |         /usr/bin/mon node show*,\
 9 |         /usr/bin/mon check,\
10 |         /usr/bin/mon check exectime*,\
11 |         /usr/bin/mon check latency*,\
12 |         /usr/bin/mon check orphans,\
13 |         /usr/bin/mon start,\
14 |         /usr/bin/mon stop,\
15 |         /usr/bin/mon restart
16 | 
17 | Cmnd_Alias      SELF_MON_CMDS =  /usr/bin/mon check *,\
18 |         /opt/plugins/check_op5_license
19 | 
20 | %mon_operators  ALL = (ALL) NOPASSWD: MON_OPERATOR
21 | %nrpe  ALL = (@naemon_user@) NOPASSWD: SELF_MON_CMDS
22 | 


--------------------------------------------------------------------------------
/test_protocol/dotest.py:
--------------------------------------------------------------------------------
 1 | 
 2 | import socket
 3 | import struct
 4 | import time
 5 | from merlinpkt import *
 6 | from merlinnet import *
 7 | 
 8 | sock = socket.socket(socket.AF_UNIX)
 9 | sock.connect("/tmp/merlintest/ipc.sock")
10 | merl = MerlinNet(sock)
11 | merl.send(MerlinPktNodeInfo(), {
12 | 	"hdr.code": CTRL_ACTIVE
13 | 	})
14 | merl.send(MerlinPktHostCheckData(), {
15 | 		"nebattr": 3,
16 | 		"name": "hostmonitor",
17 | 		"state.current_state": 1,
18 | 		"state.state_type": 1,
19 | 		"state.last_check": (int)(time.time()),
20 | 		"state.plugin_output": "Some output",
21 | 		"state.long_plugin_output": "Something long",
22 | 		"state.perf_data": "measure=131"
23 | 		})
24 | merl.send(MerlinPktServiceCheckData(), {
25 | 		"nebattr": 3,
26 | 		"host_name": "servicemonitor",
27 | 		"service_description": "PING or something",
28 | 		"state.current_state": 1,
29 | 		"state.state_type": 1,
30 | 		"state.last_check": (int)(time.time()),
31 | 		"state.plugin_output": "Some output",
32 | 		"state.long_plugin_output": "Something long",
33 | 		"state.perf_data": "measure=131"
34 | 		})
35 | 


--------------------------------------------------------------------------------
/test_protocol/merlinnet.py:
--------------------------------------------------------------------------------
 1 | class MerlinNet:
 2 | 	def __init__(self, sock):
 3 | 		self._sock = sock
 4 | 
 5 | 	def read(self, pkt):
 6 | 		size = pkt.size()
 7 | 		buffer = self._sock.recv(size)
 8 | 		return pkt.unpack(buffer)
 9 | 
10 | 	def send(self, pkt, values):
11 | 		buf = pkt.pack(values)
12 | 		self._sock.sendall(buf)


--------------------------------------------------------------------------------
/tests/bltest.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITRS-Group/monitor-merlin/216309152a44617ea74abb6ea58870d110a91b9f/tests/bltest.c


--------------------------------------------------------------------------------
/tests/codectest.c:
--------------------------------------------------------------------------------
  1 | #include "codec.h"
  2 | #include "logging.c"
  3 | #include <check.h>
  4 | 
  5 | void general_setup(void)
  6 | {
  7 | 	merlin_log_file = "stdout";
  8 | 	log_levels = -1;
  9 | 	log_init();
 10 | }
 11 | 
 12 | void general_teardown(void)
 13 | {
 14 | }
 15 | 
 16 | START_TEST(test_encode_serviceevent)
 17 | {
 18 | 	int ret;
 19 | 	merlin_event pkt;
 20 | 	merlin_service_status ds, *out;
 21 | 
 22 | 	memset(&pkt, 0, sizeof(pkt));
 23 | 	pkt.hdr.type = NEBCALLBACK_SERVICE_CHECK_DATA;
 24 | 	pkt.hdr.selection = DEST_BROADCAST;
 25 | 	pkt.hdr.code = MAGIC_NONET;
 26 | 	memset(&ds, 0, sizeof(ds));
 27 | 	/* set some relevant values at the beginning and end of the struct */
 28 | 	ds.state.initial_state = 123;
 29 | 	ds.state.notified_on = 456;
 30 | 	ds.host_name = "foo";
 31 | 	ds.state.perf_data = "bar";
 32 | 	ret = merlin_encode_event(&pkt, (void *)&ds);
 33 | 	ck_assert(ret > 0);
 34 | 	pkt.hdr.len = ret;
 35 | 	ret = merlin_decode_event(NULL, &pkt);
 36 | 	ck_assert_int_eq(ret, 0);
 37 | 	out = (merlin_service_status *) pkt.body;
 38 | 	ck_assert_int_eq(123, out->state.initial_state);
 39 | 	ck_assert_int_eq(456, out->state.notified_on);
 40 | 	ck_assert_str_eq("foo", out->host_name);
 41 | 	ck_assert_str_eq("bar", out->state.perf_data);
 42 | }
 43 | END_TEST
 44 | 
 45 | START_TEST(test_encode_too_long)
 46 | {
 47 | 	int ret;
 48 | 	merlin_event pkt;
 49 | 	merlin_service_status ds, *out;
 50 | 	char *input = calloc((1 << 20) + 1, 1);
 51 | 
 52 | 	memset(&pkt, 0, sizeof(pkt));
 53 | 	pkt.hdr.type = NEBCALLBACK_SERVICE_CHECK_DATA;
 54 | 	pkt.hdr.selection = DEST_BROADCAST;
 55 | 	pkt.hdr.code = MAGIC_NONET;
 56 | 	memset(&ds, 0, sizeof(ds));
 57 | 	memset(input, 'a', 1 << 20);
 58 | 	input[1<<20] = 0;
 59 | 	ds.host_name = strdup(input);
 60 | 	ds.service_description = "This should be truncated away";
 61 | 	ds.state.perf_data = "This should be truncated away";
 62 | 	ds.state.plugin_output = "This should be truncated away";
 63 | 	ds.state.long_plugin_output = "This should be truncated away";
 64 | 	ret = merlin_encode_event(&pkt, (void *)&ds);
 65 | 	ck_assert(ret > 0);
 66 | 	pkt.hdr.len = ret;
 67 | 	ret = merlin_decode_event(NULL, &pkt);
 68 | 	ck_assert_int_eq(ret, 0);
 69 | 	out = (merlin_service_status *) pkt.body;
 70 | 	ck_assert(pkt.body[(128 << 10) - 1] == 0);
 71 | 	ck_assert(strcmp(input, out->host_name));
 72 | 	ck_assert(!strncmp(input, out->host_name, 120<<10));
 73 | 	ck_assert(NULL == out->service_description);
 74 | }
 75 | END_TEST
 76 | 
 77 | Suite *
 78 | check_codec_suite(void)
 79 | {
 80 | 	Suite *s = suite_create("codec");
 81 | 
 82 | 	TCase *tc = tcase_create("codec");
 83 | 	tcase_add_checked_fixture (tc, general_setup, general_teardown);
 84 | 	tcase_add_test(tc, test_encode_serviceevent);
 85 | 	tcase_add_test(tc, test_encode_too_long);
 86 | 	suite_add_tcase(s, tc);
 87 | 
 88 | 	return s;
 89 | }
 90 | 
 91 | int main(__attribute__((unused)) int argc, __attribute__((unused)) char *argv[]) {
 92 | 		int number_failed;
 93 | 	Suite *s = check_codec_suite();
 94 | 	SRunner *sr = srunner_create(s);
 95 | 	srunner_run_all(sr, CK_NORMAL);
 96 | 	number_failed = srunner_ntests_failed(sr);
 97 | 	srunner_free(sr);
 98 | 	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 99 | }
100 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/base/cukemerlin.c:
--------------------------------------------------------------------------------
 1 | #include <glib.h>
 2 | #include <glib-object.h>
 3 | #include <stdlib.h>
 4 | #include <string.h>
 5 | 
 6 | #include "cukesocket.h"
 7 | #include "json.h"
 8 | 
 9 | #include <steps/steps.h>
10 | 
11 | static gchar *opt_bind_address = "0.0.0.0";
12 | static gint opt_bind_port = 31221;
13 | 
14 | static GMainLoop *mainloop = NULL;
15 | 
16 | static void stop_mainloop(int signal);
17 | 
18 | static GOptionEntry opt_entries[] = {
19 | 		{ "bind-address", 'a', 0, G_OPTION_ARG_STRING, &opt_bind_address,
20 | 				"Bind to this address", "addr" },
21 | 		{ "bind-port", 'p', 0, G_OPTION_ARG_INT, &opt_bind_port,
22 | 				"Listen to this port", "port" }, { NULL } };
23 | 
24 | int main(int argc, char *argv[]) {
25 | 	GOptionContext *optctx;
26 | 	GError *error = NULL;
27 | 	CukeSocket *cs = NULL;
28 | 
29 | #if !GLIB_CHECK_VERSION(2,36,0)
30 | 	g_type_init();
31 | #endif
32 | 
33 | 	optctx = g_option_context_new("- Merlin protocol cucumber test daemon");
34 | 	g_option_context_add_main_entries(optctx, opt_entries, NULL);
35 | 	if (!g_option_context_parse(optctx, &argc, &argv, &error)) {
36 | 		g_print("%s\n", error->message);
37 | 		g_error_free(error);
38 | 		exit(1);
39 | 	}
40 | 
41 | 	mainloop = g_main_loop_new(NULL, TRUE);
42 | 	/* non glib-unix version of stopping signals */
43 | 	signal(SIGHUP, stop_mainloop);
44 | 	signal(SIGINT, stop_mainloop);
45 | 	signal(SIGTERM, stop_mainloop);
46 | 
47 | 	cs = cukesock_new(opt_bind_address, opt_bind_port);
48 | 	g_return_val_if_fail(cs != NULL, 1);
49 | 
50 | 	steps_load(cs);
51 | 
52 | 	g_message("Main Loop: Enter");
53 | 	g_main_loop_run(mainloop);
54 | 	g_message("Main Loop: Exit");
55 | 
56 | 	cukesock_destroy(cs);
57 | 	g_main_loop_unref(mainloop);
58 | 
59 | 	g_option_context_free(optctx);
60 | 
61 | 	return 0;
62 | }
63 | 
64 | static void stop_mainloop(int signal) {
65 | 	g_main_loop_quit(mainloop);
66 | }
67 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/base/cukesocket.h:
--------------------------------------------------------------------------------
 1 | #ifndef TESTS_CUKEMERLIN_CUKESOCKET_H_
 2 | #define TESTS_CUKEMERLIN_CUKESOCKET_H_
 3 | 
 4 | #include <glib.h>
 5 | #include "json.h"
 6 | 
 7 | struct CukeSocket_;
 8 | typedef struct CukeSocket_ CukeSocket;
 9 | 
10 | typedef gpointer CukeResponseRef;
11 | 
12 | typedef gpointer (*CukeStepBeginScenario)(void);
13 | typedef void (*CukeStepEndScenario)(gpointer *scenario);
14 | typedef void (*CukeStepHandler)(gpointer *scenario, JsonNode *args, CukeResponseRef respref);
15 | 
16 | #define STEP_BEGIN(_NAME) \
17 | 		static gpointer _NAME(void)
18 | #define STEP_END(_NAME) \
19 | 		static void _NAME(gpointer *scenario)
20 | #define STEP_DEF(_NAME) \
21 | 		static void _NAME(gpointer *scenario, JsonNode *args, CukeResponseRef respref)
22 | 
23 | #define STEP_OK \
24 | 		cukesock_respond(1, respref, "")
25 | #define STEP_FAIL(_MSG) \
26 | 		cukesock_respond(0, respref, (_MSG))
27 | #define STEP_DIFF(_A, _B) \
28 | 		cukesock_respond_diff(respref, (_A), (_B))
29 | 
30 | typedef struct CukeStepDefinition_ {
31 | 	const gchar *match;
32 | 	CukeStepHandler handler;
33 | } CukeStepDefinition;
34 | 
35 | typedef struct CukeStepEnvironment_ {
36 | 	const gchar *tag;
37 | 	CukeStepBeginScenario begin_scenario;
38 | 	CukeStepEndScenario end_scenario;
39 | 	int num_defs; /*< Updated by cukesock_register_stepenv */
40 | 	CukeStepDefinition definitions[];
41 | } CukeStepEnvironment;
42 | 
43 | CukeSocket *cukesock_new(const gchar *bind_addr, const gint bind_port);
44 | void cukesock_destroy(CukeSocket *cs);
45 | 
46 | void cukesock_respond(int status, CukeResponseRef respref, const gchar *msg);
47 | void cukesock_respond_diff(CukeResponseRef respref, const JsonNode *a, const JsonNode *b);
48 | 
49 | void cukesock_register_stepenv(CukeSocket *cs, CukeStepEnvironment *stepenv);
50 | 
51 | 
52 | #endif /* TESTS_CUKEMERLIN_CUKESOCKET_H_ */
53 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/base/jsonsocket.h:
--------------------------------------------------------------------------------
 1 | #ifndef JSONSOCKET_H
 2 | #define JSONSOCKET_H
 3 | 
 4 | #include <glib.h>
 5 | #include <gio/gio.h>
 6 | 
 7 | #include "json.h"
 8 | 
 9 | struct JSONSocket_;
10 | typedef struct JSONSocket_ JSONSocket;
11 | 
12 | JSONSocket *jsonsocket_new(const gchar *bind_addr, const gint bind_port,
13 | 		gpointer (*session_new)(GSocket *, gpointer),
14 | 		gboolean (*session_newline)(GSocket *, JsonNode *, gpointer),
15 | 		void (*session_destroy)(gpointer), gpointer user_data);
16 | void jsonsocket_destroy(JSONSocket *sockserv);
17 | 
18 | void jsonsocket_send(GSocket *sock, const JsonNode *node);
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/base/jsonx.h:
--------------------------------------------------------------------------------
 1 | #ifndef TESTS_CUKEMERLIN_JSONX_H_
 2 | #define TESTS_CUKEMERLIN_JSONX_H_
 3 | 
 4 | #include "json.h"
 5 | 
 6 | /* Helper to pack an array. NULL-terminate a list of JsonNodes */
 7 | JsonNode *jsonx_packarray(JsonNode *node, ...);
 8 | 
 9 | /* Helper to pack an object. NULL-terminate the last name and node */
10 | JsonNode *jsonx_packobject(const char *name, JsonNode *node, ...);
11 | 
12 | /* Helper to clone an object. */
13 | JsonNode *jsonx_clone(const JsonNode *node);
14 | 
15 | /**
16 |  * Convert a table to hashes objects
17 |  *
18 |  * Having a table:
19 |  * [
20 |  *   ["f_a",     "f_b"],
21 |  *   ["value_1", "value_2"],
22 |  *   ["value_3", "value_4"]
23 |  * ]
24 |  *
25 |  * Is cloned and converted to:
26 |  * [
27 |  *   {"f_a": "value_1", "f_b": "value_2"},
28 |  *   {"f_a": "value_3", "f_b": "value_4"}
29 |  * ]
30 |  *
31 |  * represented as JsonNode
32 |  *
33 |  * Return NULL if table isn't two dimensional, where every row has equal number
34 |  * of fields, and first row don't only contain string values.
35 |  */
36 | JsonNode *jsonx_table_hashes(const JsonNode *node);
37 | 
38 | /**
39 |  * Locate a value within a JsonNode
40 |  *
41 |  * cmd can be one of following:
42 |  *  'o' = next parameter is a char*, locate member in object node and recurse
43 |  *  'a' = next parameter is an int, locate index in array node and recurse
44 |  *  's' = next parameter is a char**, retrieve a string node and exit
45 |  *  'i' = next parameter is an int*, retrieve a int node and exit
46 |  *  'j' = next parameter is an JsonNode*, retrieve the current node and exit
47 |  *
48 |  *  Return TRUE if match is successful, FALSE if not.
49 |  *
50 |  *  Example:
51 |  *
52 |  *  node = [{"boll": "kalle"}]
53 |  *
54 |  *  if(jsonx_locate(node, 'a', 0, 'o', "boll", 's', &str)) {
55 |  *      printf("Found string: %s\n", str);
56 |  *  } else {
57 |  *      printf("Not found\n");
58 |  *  }
59 |  */
60 | int jsonx_locate(JsonNode *node, ...);
61 | 
62 | 
63 | /**
64 |  * Convert all non-object/array fields to string
65 |  *
66 |  * This makes comparisons easier when interacting with loosely typed languages
67 |  *
68 |  * It creates a clone of the object, which needs to be freed
69 |  */
70 | JsonNode *jsonx_stringobj(const JsonNode *node);
71 | #endif
72 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps.c:
--------------------------------------------------------------------------------
 1 | #include <base/cukesocket.h>
 2 | #include "steps.h"
 3 | 
 4 | #include "steps_test.h"
 5 | #include "steps_merlin.h"
 6 | #include "steps_daemons.h"
 7 | #include "steps_config.h"
 8 | #include "steps_queryhandler.h"
 9 | #include "steps_livestatus.h"
10 | 
11 | 
12 | void steps_load(CukeSocket *cs) {
13 | 	cukesock_register_stepenv(cs, &steps_test);
14 | 	cukesock_register_stepenv(cs, &steps_merlin);
15 | 	cukesock_register_stepenv(cs, &steps_daemons);
16 | 	cukesock_register_stepenv(cs, &steps_config);
17 | 	cukesock_register_stepenv(cs, &steps_queryhandler);
18 | 	cukesock_register_stepenv(cs, &steps_livestatus);
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps.h:
--------------------------------------------------------------------------------
 1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_H_
 2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_H_
 3 | 
 4 | #include <base/cukesocket.h>
 5 | 
 6 | /**
 7 |  * Load all step definitions available into the given CukeSocket. This just
 8 |  * isolates the implementation of step definitions from the cukemerlin basedir
 9 |  */
10 | void steps_load(CukeSocket *cs);
11 | 
12 | #endif /* TESTS_CUKEMERLIN_STEPS_STEPS_H_ */
13 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_config.h:
--------------------------------------------------------------------------------
1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_CONFIG_H_
2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_CONFIG_H_
3 | 
4 | #include <base/cukesocket.h>
5 | extern CukeStepEnvironment steps_config;
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_daemons.h:
--------------------------------------------------------------------------------
1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_DAEMONS_H_
2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_DAEMONS_H_
3 | 
4 | #include <base/cukesocket.h>
5 | extern CukeStepEnvironment steps_daemons;
6 | 
7 | #endif /* TESTS_CUKEMERLIN_STEPS_STEPS_DAEMONS_H_ */
8 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_livestatus.h:
--------------------------------------------------------------------------------
1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_LIVESTATUS_H_
2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_LIVESTATUS_H_
3 | 
4 | #include <base/cukesocket.h>
5 | extern CukeStepEnvironment steps_livestatus;
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_merlin.h:
--------------------------------------------------------------------------------
1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_MERLIN_H_
2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_MERLIN_H_
3 | 
4 | #include <base/cukesocket.h>
5 | extern CukeStepEnvironment steps_merlin;
6 | 
7 | #endif /* TESTS_CUKEMERLIN_STEPS_STEPS_MERLIN_H_ */
8 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_queryhandler.h:
--------------------------------------------------------------------------------
1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_QUERYHANDLER_H_
2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_QUERYHANDLER_H_
3 | 
4 | #include <base/cukesocket.h>
5 | extern CukeStepEnvironment steps_queryhandler;
6 | 
7 | #endif
8 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_test.c:
--------------------------------------------------------------------------------
 1 | #include "steps_test.h"
 2 | #include <glib.h>
 3 | #include <stdlib.h>
 4 | 
 5 | STEP_BEGIN(step_begin_scenario);
 6 | STEP_END(step_end_scenario);
 7 | STEP_DEF(step_fail);
 8 | STEP_DEF(step_success);
 9 | 
10 | CukeStepEnvironment steps_test = {
11 | 		.tag = "test",
12 | 		.begin_scenario = step_begin_scenario,
13 | 		.end_scenario = step_end_scenario,
14 | 
15 | 		.definitions = {
16 | 				{"^I fail$", step_fail},
17 | 				{"^I succeed$", step_success},
18 | 				{"^I do (.*) stuff$", step_success},
19 | 				{"^I do (.*) stuff (.*)$", step_success},
20 | 				{NULL, NULL}
21 | 		}
22 | };
23 | 
24 | 
25 | STEP_BEGIN(step_begin_scenario) {
26 | 	glong *buf = g_malloc(sizeof(glong));
27 | 	*buf = 0;
28 | 	g_message("Scenario started");
29 | 	return buf;
30 | }
31 | 
32 | STEP_END(step_end_scenario) {
33 | 	glong *buf = (glong*)scenario;
34 | 	g_message("Scenario ended, %ld steps", *buf);
35 | 	g_free(buf);
36 | }
37 | 
38 | STEP_DEF(step_fail) {
39 | 	glong *buf = (glong*)scenario;
40 | 	if(args) {
41 | 		char *jsonbuf = json_encode(args);
42 | 		g_message("Got some data: %s", jsonbuf);
43 | 		free(jsonbuf);
44 | 	}
45 | 	(*buf)++;
46 | 
47 | 	STEP_FAIL("This should fail");
48 | }
49 | STEP_DEF(step_success) {
50 | 	glong *buf = (glong*)scenario;
51 | 	if(args) {
52 | 		char *jsonbuf = json_encode(args);
53 | 		g_message("Got some data: %s", jsonbuf);
54 | 		free(jsonbuf);
55 | 	}
56 | 	(*buf)++;
57 | 
58 | 	STEP_OK;
59 | }
60 | 


--------------------------------------------------------------------------------
/tests/cukemerlin/steps/steps_test.h:
--------------------------------------------------------------------------------
1 | #ifndef TESTS_CUKEMERLIN_STEPS_STEPS_TEST_H_
2 | #define TESTS_CUKEMERLIN_STEPS_STEPS_TEST_H_
3 | 
4 | #include <base/cukesocket.h>
5 | extern CukeStepEnvironment steps_test;
6 | 
7 | #endif /* TESTS_CUKEMERLIN_STEPS_STEPS_TEST_H_ */
8 | 


--------------------------------------------------------------------------------
/tests/merlincat/client_gsource.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLS_MERLINCAT_CLIENT_GSOURCE_H_
 2 | #define TOOLS_MERLINCAT_CLIENT_GSOURCE_H_
 3 | 
 4 | #include <glib.h>
 5 | #include "conn_info.h"
 6 | 
 7 | struct ClientSource_;
 8 | typedef struct ClientSource_ ClientSource;
 9 | 
10 | ClientSource *client_source_new(const ConnectionInfo*,
11 | 	/*
12 | 	 * arg 1: connection reference, for sending data
13 | 	 * arg 2: user_data passed to this method
14 | 	 * Returns connection specific user data storage
15 | 	 */
16 | 	gpointer (*conn_new)(ConnectionStorage *, gpointer),
17 | 
18 | 	/*
19 | 	 * arg 1: connection reference, for sending data
20 | 	 * arg 2: data buffer for receiving data
21 | 	 * arg 3: length of recieved data
22 | 	 * arg 4: connection user storage
23 | 	 */
24 | 	void (*conn_data)(ConnectionStorage *, gpointer, gsize, gpointer),
25 | 
26 | 	/*
27 | 	 * arg 1: connection user storage
28 | 	 */
29 | 	void (*conn_close)(gpointer),
30 | 
31 | 	/*
32 | 	 * Client user storage (passed to conn_new callback)
33 | 	 */
34 | 	gpointer user_data);
35 | void client_source_destroy(ClientSource *cs);
36 | 
37 | #endif /* TOOLS_MERLINCAT_CLIENT_GSOURCE_H_ */
38 | 


--------------------------------------------------------------------------------
/tests/merlincat/conn_info.c:
--------------------------------------------------------------------------------
 1 | #include "conn_info.h"
 2 | 
 3 | struct ConnectionStorage_ {
 4 | 	void (*send)(gpointer, gconstpointer, gsize);
 5 | 	void (*destroy)(gpointer);
 6 | 	gboolean (*is_connected)(gpointer);
 7 | 	gpointer user_data;
 8 | };
 9 | 
10 | ConnectionStorage *connection_new(
11 | 		void (*send)(gpointer, gconstpointer, gsize),
12 | 		void (*destroy)(gpointer),
13 | 		gboolean (*is_connected)(gpointer),
14 | 		gpointer user_data) {
15 | 	ConnectionStorage *cs = g_malloc(sizeof(ConnectionStorage));
16 | 	if(cs == NULL)
17 | 		return NULL;
18 | 	cs->send = send;
19 | 	cs->destroy = destroy;
20 | 	cs->is_connected = is_connected;
21 | 	cs->user_data = user_data;
22 | 	return cs;
23 | }
24 | 
25 | void connection_destroy(ConnectionStorage *cs) {
26 | 	if(cs == NULL)
27 | 		return;
28 | 	if(cs->destroy)
29 | 		(*cs->destroy)(cs->user_data);
30 | 	g_free(cs);
31 | }
32 | 
33 | void connection_send(ConnectionStorage *cs, gconstpointer data, gsize len) {
34 | 	(*cs->send)(cs->user_data, data, len);
35 | }
36 | 
37 | gboolean connection_is_connected(ConnectionStorage *cs) {
38 | 	return (*cs->is_connected)(cs->user_data);
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/merlincat/conn_info.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLS_MERLINCAT_CONN_INFO_H_
 2 | #define TOOLS_MERLINCAT_CONN_INFO_H_
 3 | 
 4 | #include <glib.h>
 5 | 
 6 | /**
 7 |  * Description of connection information, used as bundling arguments to both
 8 |  * client_source_new and server_source_new
 9 |  *
10 |  * No methods taking this struct as an argumnet are allowed to keep a reference
11 |  * to this struct, but only use it as named attributes to the method called.
12 |  */
13 | typedef struct ConnectionInfo_ {
14 | 	 enum { TCP, UNIX } type;
15 | 	 char *dest_addr;
16 | 	 int dest_port;
17 | 	 char *source_addr;
18 | 	 int source_port;
19 | 	 gboolean listen;
20 | } ConnectionInfo;
21 | 
22 | /**
23 |  * Information about a connection.
24 |  */
25 | struct ConnectionStorage_;
26 | typedef struct ConnectionStorage_ ConnectionStorage;
27 | 
28 | ConnectionStorage *connection_new(
29 | 		void (*send)(gpointer, gconstpointer, gsize),
30 | 		void (*destroy)(gpointer),
31 | 		gboolean (*is_connected)(gpointer),
32 | 		gpointer user_data);
33 | void connection_destroy(ConnectionStorage *cs);
34 | void connection_send(ConnectionStorage *cs, gconstpointer data, gsize len);
35 | gboolean connection_is_connected(ConnectionStorage *cs);
36 | 
37 | #endif /* TOOLS_MERLINCAT_CONN_INFO_H_ */
38 | 


--------------------------------------------------------------------------------
/tests/merlincat/console.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLS_MERLINCAT_CONSOLE_H_
 2 | #define TOOLS_MERLINCAT_CONSOLE_H_
 3 | 
 4 | #include <shared/node.h>
 5 | 
 6 | struct ConsoleIO_;
 7 | typedef struct ConsoleIO_ ConsoleIO;
 8 | 
 9 | ConsoleIO *consoleio_new(void (*session_newline)(const char *, gpointer),
10 | 		gpointer user_data);
11 | 
12 | void consoleio_destroy(ConsoleIO *cio);
13 | 
14 | #endif /* TOOLS_MERLINCAT_CONSOLE_H_ */
15 | 


--------------------------------------------------------------------------------
/tests/merlincat/event_packer.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLS_MERLINCAT_EVENT_PACKER_H_
 2 | #define TOOLS_MERLINCAT_EVENT_PACKER_H_
 3 | 
 4 | #include <glib.h>
 5 | #include <shared/node.h>
 6 | #include <naemon/naemon.h>
 7 | 
 8 | /**
 9 |  * Takes a merlin event struct, and resturns a newly allocated string containing
10 |  * the event in a text-friendly parseable format.
11 |  *
12 |  * The returned string should be freed with free
13 |  */
14 | char *event_packer_pack(const merlin_event *evt);
15 | 
16 | /**
17 |  * Takes a merlin event struct, and resturns a newly allocated kvvec containing
18 |  * all fields in the merlin_event struct, as a kvvec
19 |  *
20 |  * If name is not null, *name will point to a constant internal string with the
21 |  * name of the event. It should not be freed
22 |  *
23 |  * The kvvec should be freed with kvvec_destroy(kvv, KVVEC_FREE_ALL);
24 |  */
25 | struct kvvec *event_packer_pack_kvv(const merlin_event *evt, const char **name);
26 | 
27 | /**
28 |  * Takes a line representing the an merlin_event as a line as outputted from
29 |  * event_packer_pack, and resturns a newly allocated merlin_event
30 |  *
31 |  * The returned merlin_event should be freed with free
32 |  */
33 | merlin_event *event_packer_unpack(const char *line);
34 | 
35 | /**
36 |  * Takes a name of an event and return the corresponding packet type.
37 |  *
38 |  * Useful for searching filtering packets by type
39 |  */
40 | uint16_t event_packer_str_to_type(const char *typestr);
41 | 
42 | /**
43 |  * Takes an event type, as string, and a kvvec of parameters, and returns a
44 |  * newly allocated merlin_event, that should be freed with free()
45 |  *
46 |  * If any failure, return NULL
47 |  */
48 | merlin_event *event_packer_unpack_kvv(const char *cmd, struct kvvec *kvv);
49 | 
50 | #endif /* TOOLS_MERLINCAT_EVENT_PACKER_H_ */
51 | 


--------------------------------------------------------------------------------
/tests/merlincat/merlincat_codec.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_merlincat_codec_h__
 2 | #define INCLUDE_merlincat_codec_h__
 3 | 
 4 | /**
 5 |  * NOTE: This is a version of codec.h, used as a reference implementation of
 6 |  * codecs.
 7 |  *
 8 |  * This implementation should not be changed, unless there is a explicit SIGSEGV
 9 |  * or similar to resolve within the test code. Changing this means that the
10 |  * protocol have changed, and regression bugs can appear
11 |  */
12 | 
13 | #include <glib.h>
14 | 
15 | int merlincat_encode(gpointer data, int cb_type, gpointer buf, gsize buflen);
16 | int merlincat_decode(gpointer ds, gsize len, int cb_type);
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/tests/merlincat/merlincat_encryption.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLS_MERLINCAT_ENCRYPTION_H_
 2 | #define TOOLS_MERLINCAT_ENCRYPTION_H_
 3 | 
 4 | #include <shared/node.h>
 5 | #include <naemon/naemon.h>
 6 | #include <sodium.h>
 7 | 
 8 | /**
 9 |  * Encrypts a merlin packet in place, if enabled using envrioment variables.
10 |  *
11 |  * Returns 0 on success and -1 otherwise
12 |  */
13 | int merlincat_encrypt_pkt(merlin_event * pkt);
14 | 
15 | /**
16 |  * Decrypts a merlin packet in place, if enabled using envrioment variables.
17 |  *
18 |  * Returns 0 on success and -1 otherwise
19 |  */
20 | int merlincat_decrypt_pkt(merlin_event * pkt);
21 | 
22 | #endif /* TOOLS_MERLINCAT_ENCRYPTION_H_ */
23 | 


--------------------------------------------------------------------------------
/tests/merlincat/merlinreader.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * merlinreader.c
 3 |  *
 4 |  * This file reimplements the merlin packet encoder/decoder. This version should
 5 |  * be treated as a reference implementation for testing purposes, so changes in
 6 |  * merlin which introduces possible bugs shouldn't affect the test code.
 7 |  *
 8 |  * So don't change this file unless possible SIGSEGV or similar in the tests.
 9 |  */
10 | 
11 | #include <glib.h>
12 | #include <shared/node.h>
13 | #include "merlinreader.h"
14 | 
15 | struct MerlinReader_ {
16 | 	union {
17 | 		char raw[MAX_PKT_SIZE];
18 | 		merlin_event evt;
19 | 	} buffer;
20 | 	gsize bufsize;
21 | };
22 | 
23 | MerlinReader *merlinreader_new(void) {
24 | 	MerlinReader *mr = g_malloc(sizeof(MerlinReader));
25 | 	mr->bufsize = 0;
26 | 	return mr;
27 | }
28 | void merlinreader_destroy(MerlinReader *mr) {
29 | 	g_free(mr);
30 | }
31 | 
32 | gsize merlinreader_add_data(MerlinReader *mr, gpointer data, gsize size) {
33 | 	if (size > MAX_PKT_SIZE - mr->bufsize) {
34 | 		size = MAX_PKT_SIZE - mr->bufsize;
35 | 	}
36 | 	memcpy(&mr->buffer.raw[mr->bufsize], data, size);
37 | 	mr->bufsize += size;
38 | 	return size;
39 | }
40 | merlin_event *merlinreader_get_event(MerlinReader *mr) {
41 | 	gsize event_size;
42 | 	merlin_event *event_storage = NULL;
43 | 	/* We need at least a header to be able to read anything at all */
44 | 	if (mr->bufsize < sizeof(merlin_header))
45 | 		return NULL;
46 | 
47 | 	if (mr->buffer.evt.hdr.sig.id != MERLIN_SIGNATURE) {
48 | 		/* TODO: Error handling... look for a correct header to resync? */
49 | 		goto error;
50 | 
51 | 	}
52 | 	event_size = mr->buffer.evt.hdr.len + sizeof(merlin_header);
53 | 
54 | 	/* Is the event to short for the buffer? */
55 | 	if (mr->bufsize < event_size)
56 | 		return NULL;
57 | 
58 | 	/* Tear out the event from the buffer */
59 | 	event_storage = g_memdup(mr->buffer.raw, event_size);
60 | 
61 | 	mr->bufsize -= event_size;
62 | 	memmove(mr->buffer.raw, mr->buffer.raw + event_size, mr->bufsize);
63 | 
64 | 	return event_storage;
65 | 
66 | error:
67 | 	g_free(event_storage);
68 | 	return NULL;
69 | }
70 | 


--------------------------------------------------------------------------------
/tests/merlincat/merlinreader.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * merlinreader.h
 3 |  *
 4 |  * This file reimplements the merlin packet encoder/decoder. This version should
 5 |  * be treated as a reference implementation for testing purposes, so changes in
 6 |  * merlin which introduces possible bugs shouldn't affect the test code.
 7 |  *
 8 |  * So don't change this file unless possible SIGSEGV or similar in the tests.
 9 |  */
10 | 
11 | #ifndef TOOLS_MERLINCAT_MERLINREADER_H_
12 | #define TOOLS_MERLINCAT_MERLINREADER_H_
13 | 
14 | #include <glib.h>
15 | #include <shared/node.h>
16 | 
17 | struct MerlinReader_;
18 | typedef struct MerlinReader_ MerlinReader;
19 | 
20 | MerlinReader *merlinreader_new(void);
21 | void merlinreader_destroy(MerlinReader *mr);
22 | 
23 | /**
24 |  * Add data to the merlin reader buffer.
25 |  *
26 |  * Returns number of bytes used from block refered to as "data" (of size "size")
27 |  */
28 | gsize merlinreader_add_data(MerlinReader *mr, gpointer data, gsize size);
29 | merlin_event *merlinreader_get_event(MerlinReader *mr);
30 | 
31 | #endif /* TOOLS_MERLINCAT_MERLINREADER_H_ */
32 | 


--------------------------------------------------------------------------------
/tests/merlincat/server_gsource.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLS_MERLINCAT_SERVER_GSOURCE_H_
 2 | #define TOOLS_MERLINCAT_SERVER_GSOURCE_H_
 3 | 
 4 | #include "conn_info.h"
 5 | 
 6 | #include <glib.h>
 7 | 
 8 | struct ServerSource_;
 9 | typedef struct ServerSource_ ServerSource;
10 | 
11 | ServerSource *server_source_new(const ConnectionInfo *conn_info,
12 | 	/*
13 | 	 * arg 1: connection reference, for sending data
14 | 	 * arg 2: user_data passed to this method
15 | 	 * Returns connection specific user data storage
16 | 	 */
17 | 	gpointer (*conn_new)(ConnectionStorage *, gpointer),
18 | 
19 | 	/*
20 | 	 * arg 1: connection reference, for sending data
21 | 	 * arg 2: data buffer for receiving data
22 | 	 * arg 3: length of recieved data
23 | 	 * arg 4: connection user storage
24 | 	 */
25 | 	void (*conn_data)(ConnectionStorage *, gpointer, gsize, gpointer),
26 | 
27 | 	/*
28 | 	 * arg 1: connection user storage
29 | 	 */
30 | 	void (*conn_close)(gpointer),
31 | 
32 | 	/*
33 | 	 * Server user storage (passed to conn_new callback)
34 | 	 */
35 | 	gpointer user_data);
36 | void server_source_destroy(ServerSource *cs);
37 | 
38 | #endif /* TOOLS_MERLINCAT_SERVER_GSOURCE_H_ */
39 | 


--------------------------------------------------------------------------------
/tests/pyunit/test_oconf.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import os
 4 | import sys
 5 | import unittest
 6 | 
 7 | # needed for finding oconf
 8 | sys.path.append(os.path.abspath('apps/libexec'))
 9 | 
10 | # needed for finding compound_config within oconf
11 | sys.path.append(os.path.abspath('apps/libexec/modules'))
12 | import oconf
13 | 
14 | class CmdPollerFix(unittest.TestCase):
15 | 
16 | 	def test_comment_cfg_file(self):
17 | 		wanted_config_result = "cfg_file=oconf/from-master.cfg\n#cfg_file=bye.cfg\nanother_prop=1\n".splitlines()
18 | 		config_on_disk = "cfg_file=oconf/from-master.cfg\ncfg_file=bye.cfg\nanother_prop=1".splitlines()
19 | 		self.assertEqual(wanted_config_result, oconf.make_config_file_suitable_for_poller(config_on_disk))
20 | 
21 | 	def test_add_from_master_directive(self):
22 | 		wanted_config_result = "#cfg_file=bye.cfg\nanother_prop=1\ncfg_file=oconf/from-master.cfg\n".splitlines()
23 | 		config_on_disk = "cfg_file=bye.cfg\nanother_prop=1".splitlines()
24 | 		self.assertEqual(wanted_config_result, oconf.make_config_file_suitable_for_poller(config_on_disk))
25 | 
26 | if __name__ == '__main__':
27 | 	unittest.main()
28 | 


--------------------------------------------------------------------------------
/tests/showlog_test_monitor_and_not_monitor1_svc.log:
--------------------------------------------------------------------------------
 1 | [1386686225] INITIAL HOST STATE: monitor;UP;HARD;1;
 2 | [1386686225] INITIAL SERVICE STATE: monitor;Cron process;OK;HARD;1;(null)
 3 | [1386686225] INITIAL SERVICE STATE: not-monitor1;Cron process;OK;HARD;1;(null)
 4 | [1386760150] HOST FLAPPING ALERT: monitor;STARTED; Host appears to have started flapping (21.1% change > 20.0% threshold)
 5 | [1387441769] SERVICE FLAPPING ALERT: monitor;Cron process;STARTED; Service appears to have started flapping (22.6% change >= 20.0% threshold)
 6 | [1387441769] SERVICE FLAPPING ALERT: not-monitor1;Cron process;STARTED; Service appears to have started flapping (22.6% change >= 20.0% threshold)
 7 | [1389179712] SERVICE ALERT: monitor;Cron process;CRITICAL;HARD;3;(Service check timed out after 60.01 seconds)
 8 | [1389179712] SERVICE ALERT: not-monitor1;Cron process;CRITICAL;HARD;3;(Service check timed out after 60.01 seconds)
 9 | [1389182045] HOST ALERT: monitor;DOWN;HARD;3;(Host check timed out after 60.01 seconds)
10 | [1412769600] CURRENT HOST STATE: monitor;UP;HARD;1;(No output on stdout) stderr: /opt/plugins/check_spam.sh: line 3: [: -lt: unary operator expected
11 | [1412769600] CURRENT SERVICE STATE: monitor;Cron process;CRITICAL;HARD;3;CHECK_NRPE: Error - Could not complete SSL handshake.
12 | [1412769600] CURRENT SERVICE STATE: not-monitor1;Cron process;CRITICAL;HARD;3;CHECK_NRPE: Error - Could not complete SSL handshake.
13 | [1412770298] SERVICE DOWNTIME ALERT: monitor;Cron process;STARTED; Service has entered a period of scheduled downtime
14 | [1412770298] SERVICE DOWNTIME ALERT: not-monitor1;Cron process;STARTED; Service has entered a period of scheduled downtime
15 | [1412770330] HOST DOWNTIME ALERT: monitor;STARTED; Host has entered a period of scheduled downtime
16 | [1412770708] SERVICE NOTIFICATION: monitor;monitor;Cron process;CRITICAL;service-notify;CHECK_NRPE: Error - Could not complete SSL handshake.
17 | [1412770708] SERVICE NOTIFICATION: monitor;not-monitor1;Cron process;CRITICAL;service-notify;CHECK_NRPE: Error - Could not complete SSL handshake.
18 | [1412770875] HOST NOTIFICATION: monitor;monitor;DOWN;host-notify;alert dammit
19 | [1412770876] HOST NOTIFICATION SUPPRESSED: monitor;Notification was blocked by a NEB module. Module '/usr/lib64/merlin/merlin.so' cancelled notification: 'Notification will be handled by a peer (peer01)'
20 | 


--------------------------------------------------------------------------------
/tests/showlog_test_monitoronly.log:
--------------------------------------------------------------------------------
 1 | [1386686225] INITIAL HOST STATE: monitor;UP;HARD;1;
 2 | [1386686225] INITIAL SERVICE STATE: monitor;Cron process;OK;HARD;1;(null)
 3 | [1386760150] HOST FLAPPING ALERT: monitor;STARTED; Host appears to have started flapping (21.1% change > 20.0% threshold)
 4 | [1387441769] SERVICE FLAPPING ALERT: monitor;Cron process;STARTED; Service appears to have started flapping (22.6% change >= 20.0% threshold)
 5 | [1389179712] SERVICE ALERT: monitor;Cron process;CRITICAL;HARD;3;(Service check timed out after 60.01 seconds)
 6 | [1389182045] HOST ALERT: monitor;DOWN;HARD;3;(Host check timed out after 60.01 seconds)
 7 | [1412769600] CURRENT HOST STATE: monitor;UP;HARD;1;(No output on stdout) stderr: /opt/plugins/check_spam.sh: line 3: [: -lt: unary operator expected
 8 | [1412769600] CURRENT SERVICE STATE: monitor;Cron process;CRITICAL;HARD;3;CHECK_NRPE: Error - Could not complete SSL handshake.
 9 | [1412770298] SERVICE DOWNTIME ALERT: monitor;Cron process;STARTED; Service has entered a period of scheduled downtime
10 | [1412770330] HOST DOWNTIME ALERT: monitor;STARTED; Host has entered a period of scheduled downtime
11 | [1412770708] SERVICE NOTIFICATION: monitor;monitor;Cron process;CRITICAL;service-notify;CHECK_NRPE: Error - Could not complete SSL handshake.
12 | [1412770875] HOST NOTIFICATION: monitor;monitor;DOWN;host-notify;alert dammit
13 | [1412770876] HOST NOTIFICATION SUPPRESSED: monitor;Notification was blocked by a NEB module. Module '/usr/lib64/merlin/merlin.so' cancelled notification: 'Notification will be handled by a peer (peer01)'
14 | 


--------------------------------------------------------------------------------
/tests/showlog_test_not_monitor1_svc_only.log:
--------------------------------------------------------------------------------
1 | [1386686225] INITIAL SERVICE STATE: not-monitor1;Cron process;OK;HARD;1;(null)
2 | [1387441769] SERVICE FLAPPING ALERT: not-monitor1;Cron process;STARTED; Service appears to have started flapping (22.6% change >= 20.0% threshold)
3 | [1389179712] SERVICE ALERT: not-monitor1;Cron process;CRITICAL;HARD;3;(Service check timed out after 60.01 seconds)
4 | [1412769600] CURRENT SERVICE STATE: not-monitor1;Cron process;CRITICAL;HARD;3;CHECK_NRPE: Error - Could not complete SSL handshake.
5 | [1412770298] SERVICE DOWNTIME ALERT: not-monitor1;Cron process;STARTED; Service has entered a period of scheduled downtime
6 | [1412770708] SERVICE NOTIFICATION: monitor;not-monitor1;Cron process;CRITICAL;service-notify;CHECK_NRPE: Error - Could not complete SSL handshake.
7 | 


--------------------------------------------------------------------------------
/tests/singlenode.conf:
--------------------------------------------------------------------------------
 1 | log_level = all;
 2 | #
 3 | # Sample configuration file for merlin
 4 | #
 5 | # Default options have been commented out
 6 | #
 7 | ipc_socket = /tmp/ipc.sock;
 8 | 
 9 | # module-specific configuration options.
10 | module {
11 | 	# textual log of normal hum-drum events
12 | 	log_file = stdout;
13 | }
14 | 
15 | # daemon-specific config options
16 | daemon {
17 | 	pidfile = /var/run/merlin.pid;
18 | 
19 | 	# same as the "module" section above
20 | 	log_file = stdout;
21 | 
22 | 	# address to listen to. 0.0.0.0 is default
23 | 	#address = 0.0.0.0;
24 | 
25 | 	# port to listen to. 15551 is default. This is a daemon
26 | 	# specific config setting, as the module never listens to
27 | 	# the network
28 | 	port = 15551;
29 | 	database {
30 | 		# change to no to disable database completely
31 | 		# enabled = yes;
32 | 
33 | 		# write data necessary for creating availability reports
34 | 		# into report_data
35 | 		# log_report_data = yes;
36 | 
37 | 		# log contact notifications to the 'notifications' table
38 | 		# log_notifications = yes;
39 | 
40 | 		# Change this to yes to track current status (host, service etc
41 | 		# tables).
42 | 		# track_current = no;
43 | 
44 | 		# server location and authentication variables
45 | 		name = @@DBNAME@@;
46 | 		user = @@DBUSER@@;
47 | 		pass = @@DBPASS@@;
48 | 		host = localhost;
49 | 		type = @@DBTYPE@@;
50 | 	}
51 | 
52 | 	# this section describes how we handle config synchronization
53 | 	# It can also be configured on a per-node basis to override the
54 | 	# globals set here.
55 | 	# "push" and "fetch" point to a command supposed to be run when we
56 | 	# want to push configuration to any or all nodes in the network.
57 | 	# They're invoked with the following arguments:
58 | 	# --merlin-cfg=/path/to/merlin.conf
59 | 	object_config {
60 | 		# a "push" happens for peers and pollers that we know have an
61 | 		# older configuration than we do. This is what one would
62 | 		# normally want to happen, since it originates from the node
63 | 		# that already has all the information
64 | 		push = mon oconf push
65 | 
66 | 		# a "fetch" happens for peers and masters that we know
67 | 		# have a newer configuration than we do. One won't normally
68 | 		# configure this (and it currently lacks scripting support),
69 | 		# but it's available for advanced users who know what they're
70 | 		# doing
71 | 		#fetch = mon oconf fetch
72 | 	}
73 | }
74 | 


--------------------------------------------------------------------------------
/tests/sltest.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITRS-Group/monitor-merlin/216309152a44617ea74abb6ea58870d110a91b9f/tests/sltest.c


--------------------------------------------------------------------------------
/tests/test-csync.c:
--------------------------------------------------------------------------------
 1 | #include "module.h"
 2 | #include "ipc.h"
 3 | #include "shared.h"
 4 | #include "logging.h"
 5 | #include "test_utils.h"
 6 | #include "configuration.h"
 7 | #include "script-helpers.h"
 8 | 
 9 | int main(__attribute__((unused)) int argc, __attribute__((unused)) char **argv)
10 | {
11 | 	merlin_node node;
12 | 	merlin_nodeinfo info;
13 | 
14 | 	t_set_colors(0);
15 | 	t_verbose = 1;
16 | 
17 | 	memset(&node, 0, sizeof(node));
18 | 	memset(&info, 0, sizeof(info));
19 | 	ipc.info.last_cfg_change = 10;
20 | 	self = &ipc.info;
21 | 	node.info.last_cfg_change = 5;
22 | 	info.last_cfg_change = 1;
23 | 	node.type = MODE_POLLER;
24 | 	node.name = "testelitest";
25 | 
26 | 	log_grok_var("log_level", "debug");
27 | 
28 | 	/* remove this line to see what's going on */
29 | 	log_grok_var("log_file", "/dev/null");
30 | 
31 | 
32 | 	global_csync.push.cmd = ":";
33 | 	global_csync.fetch.cmd = ":";
34 | 
35 | 	printf("node.csync_last_attemp: %lu\n", node.csync_last_attempt);
36 | 	t_start("csync tests");
37 | 
38 | 	/* test that we avoid pushing when "connect = no" */
39 | 	node.flags = MERLIN_NODE_DEFAULT_POLLER_FLAGS & ~MERLIN_NODE_CONNECT;
40 | 	csync_node_active(&node, &info, -1);
41 | 	ok_int(node.csync_last_attempt, 0, "Should avoid config pushing when 'connect = no'");
42 | 
43 | 	/*
44 | 	 * make sure we push when "connect = no" but pushing is
45 | 	 * explicitly configured for this node
46 | 	 */
47 | 	node.csync_num_attempts = 0;
48 | 	node.csync.push.cmd = ":";
49 | 	node.csync.configured = 1;
50 | 	csync_node_active(&node, &info, -1);
51 | 	ok_int(node.csync_num_attempts, 1, "Should push config when 'connect = no' and node has local push config");
52 | 	node.csync.push.is_running = 0;
53 | 	csync_node_active(&node, &info, -1);
54 | 
55 | 	/* test that we avoid pushing when max attempts is reached */
56 | 	node.flags = MERLIN_NODE_DEFAULT_POLLER_FLAGS;
57 | 	node.csync_num_attempts = node.csync_max_attempts = 3;
58 | 	csync_node_active(&node, &info, -1);
59 | 	ok_int(node.csync_last_attempt > 0, 1, "Should keep pushing config when max attempts reached");
60 | 
61 | 	return t_end();
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/test-importlog.c:
--------------------------------------------------------------------------------
 1 | #include <check.h>
 2 | #include <stdlib.h>
 3 | #include <sys/wait.h>
 4 | #include "auth.c"
 5 | 
 6 | #define pipe(a) ck_assert(0 == pipe(a))
 7 | 
 8 | static char *
 9 | run_with(char *args[], char *input_str)
10 | {
11 | 	int output[2];
12 | 	int input[2];
13 | 	pid_t pid;
14 | 	char *output_str = calloc(1, 6000);
15 | 	size_t len;
16 | 	int status;
17 | 
18 | 	pipe(output);
19 | 	pipe(input);
20 | 	pid = fork();
21 | 	if (pid < 0) {
22 | 		ck_abort_msg("Couldn't fork to run command");
23 | 	}
24 | 	else if (pid == 0) {
25 | 		char *the_environ[] = { NULL };
26 | 
27 | 		close(output[0]);
28 | 		close(input[1]);
29 | 		dup2(output[1], STDOUT_FILENO);
30 | 		dup2(output[1], STDERR_FILENO);
31 | 		dup2(input[0], STDIN_FILENO);
32 | 		args[0] = "./import";
33 | 		execve("./import", args, the_environ);
34 | 		ck_abort_msg("Execve failed. This is bad.");
35 | 	}
36 | 
37 | 	close(output[1]);
38 | 	close(input[0]);
39 | 	if (input_str != NULL)
40 | 		assert_write(input[1], input_str, strlen(input_str));
41 | 	close(input[1]);
42 | 	waitpid(pid, &status, 0);
43 | 	len = read(output[0], output_str, 6000);
44 | 	output_str[len] = '\0';
45 | 	return output_str;
46 | }
47 | 
48 | /*
49 |  * This test ensures that the "mon log import" function does not crash when
50 |  * the log contains a line containing [not-a-timestamp].
51 |  */
52 | START_TEST (invalid_timestamp)
53 | {
54 | 	char *output;
55 | 	char *args[] = {
56 | 		NULL,
57 | 		"--no-sql",
58 | 		"tests/importlog_naemon.log",
59 | 		NULL
60 | 	};
61 | 
62 | 	/* Check that output does not contain crash msg */
63 | 	output = run_with(args, NULL);
64 | 	if (strstr(output, "crash() called when parsing") != NULL) {
65 | 		ck_abort_msg("Import crashed when parsing a line. Output: \n%s", output);
66 | 	}
67 | 
68 | 	free(output);
69 | }
70 | END_TEST
71 | 
72 | Suite *
73 | importlog_suite(void)
74 | {
75 | 	Suite *s = suite_create("Importlog");
76 | 	TCase *invalid_line;
77 | 
78 | 	invalid_line = tcase_create("Invalid log line");
79 | 	tcase_add_test(invalid_line, invalid_timestamp);
80 | 	suite_add_tcase(s, invalid_line);
81 | 
82 | 	return s;
83 | }
84 | 
85 | int
86 | main (void)
87 | {
88 | 	int number_failed;
89 | 	Suite *s = importlog_suite();
90 | 	SRunner *sr = srunner_create(s);
91 | 	srunner_run_all(sr, CK_NORMAL);
92 | 	number_failed = srunner_ntests_failed(sr);
93 | 	srunner_free(sr);
94 | 	return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
95 | }
96 | 


--------------------------------------------------------------------------------
/tests/test-stringutils.c:
--------------------------------------------------------------------------------
 1 | #include "test_utils.h"
 2 | #include "string_utils.h"
 3 | #include <stdlib.h>
 4 | #include <string.h>
 5 | #define T_ASSERT(pred, msg) do {\
 6 | 	if ((pred)) { t_pass("%s: %s", __FUNCTION__, msg); } else { t_fail("%s: %s", __FUNCTION__, msg); } \
 7 | 	} while (0)
 8 | 
 9 | void test_unescape_newlines(void)
10 | {
11 | 	char *src = "foo\nbar\\n\\baz\\n";
12 | 	char *expected = "foo\nbar\n\\baz\n";
13 | 	char *dest = (char *)malloc(strlen(src));
14 | 	char in[] = "abc\\n";
15 | 	char out[16] = {0,};
16 | 	size_t len = 0, expected_size = 0;
17 | 
18 | 	len = unescape_newlines(dest, src, strlen(src) + 1);
19 | 	T_ASSERT(0 == strcmp(expected, dest), "newlines unescaped as expected");
20 | 	expected_size = strlen(expected) + 1;
21 | 	T_ASSERT(len == expected_size, "returned length is correct");
22 | 	expected_size = strlen(dest) + 1;
23 | 	T_ASSERT(len == expected_size, "destination buffer is of correct length");
24 | 	free(dest);
25 | 
26 | 	/*test binary safe-ness*/
27 | 	src = "foo\nbar\\nboll\0kaka";
28 | 	expected = "foo\nbar\nboll\0kaka";
29 | 	expected_size = 18;
30 | 	dest = (char *)malloc(expected_size);
31 | 	len = unescape_newlines(dest, src, 19);
32 | 	T_ASSERT(expected_size == len, "returned length is correct");
33 | 	T_ASSERT(0 == memcmp(expected, dest, len), "length argument is respected");
34 | 	free(dest);
35 | 
36 | 	/* test quoted backslash */
37 | 	src = "foo\\\\nbar";
38 | 	expected = "foo\\nbar";
39 | 	expected_size = 9;
40 | 	dest = (char *)malloc(expected_size);
41 | 	len = unescape_newlines(dest, src, strlen(src) + 1);
42 | 	T_ASSERT(expected_size == len, "returned length is correct");
43 | 	T_ASSERT(0 == memcmp(expected, dest, len), "length argument is respected");
44 | 	free(dest);
45 | 
46 | 	memset(out, 0, 16);
47 | 	len = unescape_newlines(out, in, 4);
48 | 	T_ASSERT(4 == len, "returned length is correct");
49 | 	T_ASSERT(4 == strlen(out), "only the correct number of bytes copied");
50 | 	T_ASSERT(out[3] == '\\', "half an escaped newline isn't parsed");
51 | }
52 | 
53 | int main(__attribute__((unused)) int argc, __attribute__((unused)) char *argv[]) {
54 | 	t_set_colors(0);
55 | 	t_verbose = 1;
56 | 
57 | 	t_start("testing string utilities");
58 | 	test_unescape_newlines();
59 | 
60 | 	return t_end();
61 | }
62 | 


--------------------------------------------------------------------------------
/tests/twopeers.conf:
--------------------------------------------------------------------------------
 1 | log_level = all;
 2 | #
 3 | # Sample configuration file for merlin
 4 | #
 5 | # Default options have been commented out
 6 | #
 7 | ipc_socket = /tmp/ipc.sock;
 8 | 
 9 | # module-specific configuration options.
10 | module {
11 | 	# textual log of normal hum-drum events
12 | 	log_file = stdout;
13 | }
14 | 
15 | # daemon-specific config options
16 | daemon {
17 | 	pidfile = /var/run/merlin.pid;
18 | 
19 | 	# same as the "module" section above
20 | 	log_file = stdout;
21 | 
22 | 	# address to listen to. 0.0.0.0 is default
23 | 	#address = 0.0.0.0;
24 | 
25 | 	# port to listen to. 15551 is default. This is a daemon
26 | 	# specific config setting, as the module never listens to
27 | 	# the network
28 | 	port = 15551;
29 | 	database {
30 | 		# change to no to disable database completely
31 | 		# enabled = yes;
32 | 
33 | 		# write data necessary for creating availability reports
34 | 		# into report_data
35 | 		# log_report_data = yes;
36 | 
37 | 		# log contact notifications to the 'notifications' table
38 | 		# log_notifications = yes;
39 | 
40 | 		# Change this to yes to track current status (host, service etc
41 | 		# tables).
42 | 		# track_current = no;
43 | 
44 | 		# server location and authentication variables
45 | 		name = @@DBNAME@@;
46 | 		user = @@DBUSER@@;
47 | 		pass = @@DBPASS@@;
48 | 		host = localhost;
49 | 		type = @@DBTYPE@@;
50 | 	}
51 | 
52 | 	# this section describes how we handle config synchronization
53 | 	# It can also be configured on a per-node basis to override the
54 | 	# globals set here.
55 | 	# "push" and "fetch" point to a command supposed to be run when we
56 | 	# want to push configuration to any or all nodes in the network.
57 | 	# They're invoked with the following arguments:
58 | 	# --merlin-cfg=/path/to/merlin.conf
59 | 	object_config {
60 | 		# a "push" happens for peers and pollers that we know have an
61 | 		# older configuration than we do. This is what one would
62 | 		# normally want to happen, since it originates from the node
63 | 		# that already has all the information
64 | 		push = mon oconf push
65 | 
66 | 		# a "fetch" happens for peers and masters that we know
67 | 		# have a newer configuration than we do. One won't normally
68 | 		# configure this (and it currently lacks scripting support),
69 | 		# but it's available for advanced users who know what they're
70 | 		# doing
71 | 		#fetch = mon oconf fetch
72 | 	}
73 | }
74 | 
75 | peer peer1 {
76 | 	address = 10.11.12.13
77 | }
78 | 
79 | peer peer2 {
80 | 	address = 10.11.12.14
81 | }
82 | 


--------------------------------------------------------------------------------
/tools/auth.c:
--------------------------------------------------------------------------------
 1 | #include "logutils.h"
 2 | #include "cfgfile.h"
 3 | #include "auth.h"
 4 | #include <naemon/naemon.h>
 5 | #include <glib.h>
 6 | 
 7 | static GHashTable *auth_hosts, *auth_services;
 8 | static int blocksize = 1 << 20;
 9 | 
10 | int auth_host_ok(const char *host)
11 | {
12 | 	return !!g_hash_table_lookup(auth_hosts, host);
13 | }
14 | 
15 | int auth_service_ok(const char *host, const char *svc)
16 | {
17 | 	return !!(g_hash_table_lookup(auth_services, &((nm_service_key){ (char *) host, (char *) svc })) || auth_host_ok(host));
18 | }
19 | 
20 | int auth_read_input(FILE *input)
21 | {
22 | 	char *objectstr, *alloced;
23 | 	int tot_read = 0, len = 0;
24 | 	char *hostend, *svcend;
25 | 
26 | 	auth_hosts = g_hash_table_new_full(g_str_hash, g_str_equal, free, NULL);
27 | 	auth_services = g_hash_table_new_full(nm_service_hash, nm_service_equal, (GDestroyNotify) nm_service_key_destroy, NULL);
28 | 	if (!input)
29 | 		return 0;
30 | 	alloced = objectstr = malloc(blocksize);
31 | 	while ((len = fread(objectstr, 1, blocksize - tot_read - 1, input)) > 0) {
32 | 		tot_read += len;
33 | 		alloced[tot_read] = 0;
34 | 		if (tot_read + 1 >= blocksize) {
35 | 			blocksize *= 2;
36 | 			alloced = objectstr = realloc(alloced, blocksize);
37 | 		}
38 | 		objectstr = alloced + tot_read;
39 | 	}
40 | 	alloced[tot_read] = 0;
41 | 	objectstr = alloced;
42 | 	while (1) {
43 | 		char delim;
44 | 		hostend = strpbrk(objectstr, "\n;");
45 | 		if (hostend) {
46 | 			delim = *hostend;
47 | 			*hostend = 0;
48 | 		}
49 | 		g_hash_table_insert(auth_hosts, strdup(objectstr), (void*)1);
50 | 		if (!hostend)
51 | 			break;
52 | 		objectstr = hostend + 1;
53 | 		if (delim == '\n')
54 | 			break;
55 | 	}
56 | 	if (!hostend) {
57 | 		goto error_out;
58 | 	}
59 | 	while (1) {
60 | 		char delim;
61 | 		hostend = strpbrk(objectstr, "\n;");
62 | 		if (!hostend)
63 | 			break;
64 | 		if (*hostend == '\n') {
65 | 			// invalid. let's ignore the odd hostname
66 | 			goto error_out;
67 | 		}
68 | 		svcend = strpbrk(hostend+1, "\n;");
69 | 		*hostend = 0;
70 | 		if (svcend) {
71 | 			delim = *svcend;
72 | 			*svcend = 0;
73 | 		}
74 | 		g_hash_table_insert(auth_services, nm_service_key_create(objectstr, hostend+1), (void*)1);
75 | 		if (!svcend)
76 | 			break;
77 | 		objectstr = svcend + 1;
78 | 		if (delim == '\n')
79 | 			break;
80 | 	}
81 | 	free (alloced);
82 | 	return 0;
83 | error_out:
84 | 	free(alloced);
85 | 	return 1;
86 | }
87 | 


--------------------------------------------------------------------------------
/tools/auth.h:
--------------------------------------------------------------------------------
1 | #ifndef INCLUDE_auth_h__
2 | #define INCLUDE_auth_h__
3 | int auth_host_ok(const char *host);
4 | int auth_service_ok(const char *host, const char *service);
5 | int auth_read_input(FILE *input);
6 | #endif
7 | 


--------------------------------------------------------------------------------
/tools/colors.h:
--------------------------------------------------------------------------------
 1 | #ifndef colors_h__
 2 | #define colors_h__
 3 | #define CLR_RESET          "\033[m"
 4 | #define CLR_BOLD           "\033[1m"
 5 | #define CLR_RED            "\033[31m"
 6 | #define CLR_GREEN          "\033[32m"
 7 | #define CLR_BROWN          "\033[33m"
 8 | #define CLR_YELLOW         "\033[33m\033[1m"
 9 | #define CLR_BLUE           "\033[34m"
10 | #define CLR_MAGENTA        "\033[35m"
11 | #define CLR_CYAN           "\033[36m"
12 | #define CLR_BG_RED         "\033[41m"
13 | #define CLR_BRIGHT_RED     "\033[31m\033[1m"
14 | #define CLR_BRIGHT_GREEN   "\033[32m\033[1m"
15 | #define CLR_BRIGHT_BLUE    "\033[34m\033[1m"
16 | #define CLR_BRIGHT_MAGENTA "\033[35m\033[1m"
17 | #define CLR_BRIGHT_CYAN    "\033[36m\033[1m"
18 | #endif
19 | 


--------------------------------------------------------------------------------
/tools/keygen.c:
--------------------------------------------------------------------------------
 1 | #include <getopt.h>
 2 | #include <sodium.h>
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | #include <string.h>
 6 | #include <unistd.h>
 7 | 
 8 | int write_key(char *path, unsigned char *key, size_t len) {
 9 |   FILE *f;
10 |   size_t written;
11 | 
12 |   f = fopen(path, "w");
13 | 
14 |   if (f == NULL) {
15 |     printf("Failed to open file for writing: %s\n", path);
16 |     return 1;
17 |   }
18 | 
19 |   written = fwrite(key, len, 1, f);
20 |   if (written != 1) {
21 |     printf("Failed writing to file: %s\n", path);
22 |     printf("Written: %ld\n", written);
23 |     return 1;
24 |   }
25 |   if (fclose(f) != 0) {
26 |     printf("Failed to close file stream: %s\n", path);
27 |     return 1;
28 |   }
29 |   return 0;
30 | }
31 | 
32 | int main(int argc, char **argv) {
33 |   unsigned char pubkey[crypto_box_PUBLICKEYBYTES];
34 |   unsigned char privkey[crypto_box_SECRETKEYBYTES];
35 |   char *path = NULL;
36 |   char *pubkey_path = NULL;
37 |   char *privkey_path = NULL;
38 |   char pubkey_file[] = "/key.pub";
39 |   char privkey_file[] = "/key.priv";
40 | 
41 |   int c;
42 | 
43 |   while ((c = getopt(argc, argv, "p:")) != -1)
44 |     switch (c) {
45 |     case 'p':
46 |       path = optarg;
47 |       break;
48 |     case '?':
49 |       if (optopt == 'p')
50 |         fprintf(stderr, "Option -%c requires an argument.\n", optopt);
51 |       else if (isprint(optopt))
52 |         fprintf(stderr, "Unknown option `-%c'.\n", optopt);
53 |       else
54 |         fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
55 |       return 1;
56 |     default:
57 |       return 1;
58 |     }
59 | 
60 |   if (path == NULL) {
61 |     fprintf(stderr, "A path must be supplied with the -p argument\n");
62 |     return 1;
63 |   }
64 | 
65 |   if (sodium_init() < 0) {
66 |     printf("%s\n", "Could init crypo lib. Exiting.");
67 |     return 1;
68 |   }
69 | 
70 |   crypto_box_keypair(pubkey, privkey);
71 | 
72 |   // size of path prefix plus length of filename plus one for string terminator
73 |   pubkey_path = malloc(sizeof(char) * (strlen(path) + strlen(pubkey_file) + 1));
74 |   privkey_path =
75 |       malloc(sizeof(char) * (strlen(path) + strlen(privkey_file) + 1));
76 | 
77 |   strcat(pubkey_path, path);
78 |   strcat(pubkey_path, pubkey_file);
79 |   strcat(privkey_path, path);
80 |   strcat(privkey_path, privkey_file);
81 | 
82 |   if (write_key(pubkey_path, pubkey, crypto_box_PUBLICKEYBYTES)) {
83 |     free(pubkey_path);
84 |     free(privkey_path);
85 |     return 1;
86 |   }
87 | 
88 |   if (write_key(privkey_path, privkey, crypto_box_SECRETKEYBYTES)) {
89 |     free(pubkey_path);
90 |     free(privkey_path);
91 |     return 1;
92 |   }
93 | 
94 |   free(pubkey_path);
95 |   free(privkey_path);
96 | 
97 |   return 0;
98 | }
99 | 


--------------------------------------------------------------------------------
/tools/lparse.h:
--------------------------------------------------------------------------------
 1 | #ifndef lparse_h__
 2 | #define lparse_h__
 3 | #include <stdint.h>
 4 | extern int lparse_fd(int fd, uint64_t size, int (*parse)(char *, uint));
 5 | extern int lparse_rev_fd(int fd, uint64_t size, int (*parse)(char *, uint));
 6 | extern int lparse_path_real(int rev, const char *path, uint64_t size, int (*parse)(char *, uint));
 7 | #define lparse_path(path, size, parse) lparse_path_real(0, path, size, parse)
 8 | #define lparse_rev_path(path, size, parse) lparse_path_real(1, path, size, parse)
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/tools/oconf.c:
--------------------------------------------------------------------------------
 1 | #include <string.h>
 2 | #include "module.h"
 3 | #include "misc.h"
 4 | #include "shared.h"
 5 | 
 6 | /*
 7 |  * the code in misc.c expects this to be a global variable. Yes, that's
 8 |  * weird, and no I'm not gonna do anything about it right now. it is a
 9 |  * global variable in Nagios and the module is the designated user of
10 |  * that functionality, so it's not, strictly speaking, necessary.
11 |  */
12 | char *config_file = NULL;
13 | 
14 | #define CMD_HASH 1
15 | #define CMD_LAST_CHANGE 2
16 | #define CMD_FILES 3
17 | int main(int argc, char **argv)
18 | {
19 | 	unsigned char hash[20];
20 | 	int cmd = 0;
21 | 	unsigned int i;
22 | 	char *base, *cmd_string = NULL;
23 | 
24 | 	base = strrchr(argv[0], '/');
25 | 	if (!base)
26 | 		base = argv[0];
27 | 	else
28 | 		base++;
29 | 
30 | 	if (!prefixcmp(base, "oconf.")) {
31 | 		cmd_string = base + strlen("oconf.");
32 | 		if (!strcmp(cmd_string, "changed")) {
33 | 			cmd = CMD_LAST_CHANGE;
34 | 		} else if (!strcmp(cmd_string, "hash")) {
35 | 			cmd = CMD_HASH;
36 | 		}
37 | 	}
38 | 
39 | 	for (i = 1; i < (unsigned int)argc; i++) {
40 | 		char *arg = argv[i];
41 | 		if (!prefixcmp(arg, "--nagios-cfg=")) {
42 | 			config_file = &arg[strlen("--nagios-cfg=")];
43 | 			continue;
44 | 		}
45 | 		while (*arg == '-')
46 | 			arg++;
47 | 
48 | 		if (!prefixcmp(arg, "last") || !prefixcmp(arg, "change")) {
49 | 			cmd = CMD_LAST_CHANGE;
50 | 			continue;
51 | 		}
52 | 		if (!strcmp(arg, "sha1") || !strcmp(arg, "hash")) {
53 | 			cmd = CMD_HASH;
54 | 			continue;
55 | 		}
56 | 		if (!prefixcmp(arg, "list") || !strcmp(arg, "files")) {
57 | 			cmd = CMD_FILES;
58 | 			continue;
59 | 		}
60 | 	}
61 | 	if (!config_file)
62 | 		config_file = "/opt/monitor/etc/nagios.cfg";
63 | 
64 | 	switch (cmd) {
65 | 	case CMD_HASH:
66 | 		get_config_hash(hash);
67 | 		printf("%s\n", tohex(hash, 20));
68 | 		break;
69 | 	case CMD_LAST_CHANGE:
70 | 		printf("%lu\n", get_last_cfg_change());
71 | 		break;
72 | 	case CMD_FILES:
73 | 		{
74 | 			struct file_list **sorted_flist;
75 | 			unsigned int num_files;
76 | 
77 | 			sorted_flist = get_sorted_oconf_files(&num_files);
78 | 			if(!sorted_flist)
79 | 				break;
80 | 
81 | 			for (i = 0; i < num_files; i++) {
82 | 				printf("%s\n", sorted_flist[i]->name);
83 | 				sorted_flist[i]->next = NULL;
84 | 				file_list_free(sorted_flist[i]);
85 | 			}
86 | 			free(sorted_flist);
87 | 		}
88 | 		break;
89 | 	}
90 | 	return 0;
91 | }
92 | 


--------------------------------------------------------------------------------
/tools/test_utils.h:
--------------------------------------------------------------------------------
 1 | #ifndef INCLUDE_test_utils_h__
 2 | #define INCLUDE_test_utils_h__
 3 | #define TEST_PASS 1
 4 | #define TEST_FAIL 0
 5 | 
 6 | /*
 7 |  * You might suspect test utils is test specific code.
 8 |  * You'd be wrong.
 9 |  *
10 |  * As our tools are mostly invoked by daemons, printing their output to stdout
11 |  * might be considered unhelpful, but I guess that's a future fix.
12 |  */
13 | 
14 | extern const char *red, *green, *yellow, *cyan, *reset;
15 | extern unsigned int passed, failed, t_verbose;
16 | 
17 | extern void t_set_colors(int force);
18 | extern void t_start(const char *fmt, ...)
19 | 	__attribute__((__format__(__printf__, 1, 2)));
20 | extern void t_pass(const char *fmt, ...)
21 | 	__attribute__((__format__(__printf__, 1, 2)));
22 | extern void t_fail(const char *fmt, ...)
23 | 	__attribute__((__format__(__printf__, 1, 2)));
24 | extern void t_diag(const char *fmt, ...)
25 | 	__attribute__((__format__(__printf__, 1, 2)));
26 | extern int ok_int(int a, int b, const char *name);
27 | extern int ok_uint(unsigned int a, unsigned int b, const char *name);
28 | extern int ok_str(const char *a, const char *b, const char *name);
29 | extern int t_end(void);
30 | #endif
31 | 


--------------------------------------------------------------------------------