Beispiel #1
0
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
"""
Test Mongodb retention.
"""

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
mongodb_retention = modulesctx.get_module('retention_mongodb')
get_instance = mongodb_retention.get_instance

modconf = Module()
modconf.module_name = "MongodbRetention"
modconf.uri = 'mongodb://127.0.0.1:27017'
modconf.database = 'test'
modconf.module_type = mongodb_retention.properties['type']
modconf.properties = mongodb_retention.properties.copy()


class TestMongodbRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_mongodb_retention(self):
        # get our modules
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
"""
Test the named pipe arbiter module.
"""

import os, time, platform

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
named_pipe = modulesctx.get_module('named_pipe')
Named_Pipe_arbiter = named_pipe.Named_Pipe_arbiter
get_instance = named_pipe.get_instance

modconf = Module()
modconf.module_name = "NamedPipe"
modconf.module_type = named_pipe.properties['type']
modconf.properties = named_pipe.properties.copy()


class TestModuleNamedPipe(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_read_named_pipe(self):

        # Ok, windows do not have named pipe, we know...
Beispiel #3
0
import time
import random
import copy

from shinken_modules import ShinkenModulesTest
from shinken_test import time_hacker, unittest

from shinken.objects.module import Module
from shinken.objects.service import Service
from shinken.modulesctx import modulesctx
from shinken.comment import Comment
from shinken.log import logger
from shinken.modulesmanager import ModulesManager
from shinken.misc.datamanager import datamgr

livestatus_broker = modulesctx.get_module('livestatus')
LiveStatus_broker = livestatus_broker.LiveStatus_broker
LiveStatus = livestatus_broker.LiveStatus
LiveStatusRegenerator = livestatus_broker.LiveStatusRegenerator
LiveStatusQueryCache = livestatus_broker.LiveStatusQueryCache
Logline = livestatus_broker.Logline
LiveStatusLogStoreSqlite = modulesctx.get_module(
    'logstore-sqlite').LiveStatusLogStoreSqlite

from mock_livestatus import mock_livestatus_handle_request

sys.setcheckinterval(10000)


@mock_livestatus_handle_request
class TestConfig(ShinkenModulesTest):
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os
from shinken_test import unittest, ShinkenTest

from shinken.brok import Brok
from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('simplelog').get_instance


class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_simplelog(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_type == 'simple_log':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.path == 'tmp/nagios.log')
        self.assert_(mod.module_name == 'Simple-log')
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

"""
Test the named pipe arbiter module.
"""

import os, time, platform

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
named_pipe = modulesctx.get_module('named_pipe')
Named_Pipe_arbiter = named_pipe.Named_Pipe_arbiter
get_instance       = named_pipe.get_instance


modconf = Module()
modconf.module_name = "NamedPipe"
modconf.module_type = named_pipe.properties['type']
modconf.properties = named_pipe.properties.copy()


class TestModuleNamedPipe(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_read_named_pipe(self):
Beispiel #6
0
# Shinken is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
"""
Test memcache retention.
"""

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
memcache_retention_scheduler = modulesctx.get_module('retention_memcache')
get_instance = memcache_retention_scheduler.get_instance

modconf = Module()
modconf.module_name = "MemcacheRetention"
modconf.module_type = memcache_retention_scheduler.properties['type']
modconf.properties = memcache_retention_scheduler.properties.copy()

try:
    import memcache
except ImportError:
    memcache = None


class TestMemcacheRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

from shinken_test import unittest, ShinkenTest

from shinken.brok import Brok

from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('merlindb').get_instance



class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_simplelog(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_name == 'ToMerlindb_Sqlite':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.database_path == '/usr/local/shinken/var/merlindb.sqlite')
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os
from tempfile import mktemp

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('file_tag').get_instance


class TestFileTag(ShinkenTest):
    def setUp(self):
        self.setup_with_file('etc/nagios_module_file_tag.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('FileTag')

        # look for a objects that use it
        h1 = self.sched.hosts.find_by_name("test_host_0")
        h2 = self.sched.hosts.find_by_name("test_router_0")

        # get our modules
        path = mktemp()
Beispiel #9
0
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os
import time

from shinken_test import unittest, ShinkenTest

from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('perfdata_service').get_instance


class TestModSRVPErfdata(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_service_perfdata(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_type == 'service_perfdata':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.path == 'tmp/service-perfdata')
        self.assert_(mod.module_name == 'Service-Perfdata')
Beispiel #10
0
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os
from shinken_test import *
sys.path.append("../shinken/modules")

from shinken.brok import Brok

from shinken.modulesctx import modulesctx
host_perfdata_broker = modulesctx.get_module('perfdata_host')
get_instance = host_perfdata_broker.get_instance


class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_host_perfdata(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_type == 'host_perfdata':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.path == 'tmp/host-perfdata')
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('status_dat').get_instance


class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def nb_of_string(self, buf, s):
        nb_s = 0
        for line in buf.splitlines():
            if line == s:
                print "Find string"
                nb_s += 1
        return nb_s

    def test_simplelog(self):
        print self.conf.modules
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
"""
Test pickle retention broker.
"""

import os
import copy

from shinken_test import unittest, ShinkenTest

from shinken.daemons.brokerdaemon import Broker
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
pickle_retention_file_generic = modulesctx.get_module(
    'pickle_retention_file_generic')
get_instance = pickle_retention_file_generic.get_instance

modconf = Module()
modconf.module_name = "PickleRetentionGeneric"
modconf.module_type = pickle_retention_file_generic.properties['type']
modconf.properties = pickle_retention_file_generic.properties.copy()


class TestPickleRetentionBroker(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_pickle_retention(self):
        # get our modules
        mod = pickle_retention_file_generic.Pickle_retention_generic(
            modconf, 'tmp/retention-test.dat')
from shinken_modules import ShinkenModulesTest
from shinken_test import time_hacker, unittest

from shinken.modulesctx import modulesctx
from shinken.objects.module import Module
from shinken.comment import Comment
from shinken.objects.service import Service


from mock_livestatus import mock_livestatus_handle_request


from livestatus.log_line import Logline


LiveStatusLogStoreMongoDB = modulesctx.get_module("logstore-mongodb").LiveStatusLogStoreMongoDB


sys.setcheckinterval(10000)


@mock_livestatus_handle_request
class TestConfig(ShinkenModulesTest):

    # how much seconds give to mongod be fully started
    # == listening on its input socket/port.
    mongod_start_timeout = 60

    @classmethod
    def _read_mongolog_and_raise(cls, log, proc, reason):
        try:
Beispiel #14
0
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
ip_tag_arbiter = modulesctx.get_module('ip_tag')
get_instance   = ip_tag_arbiter.get_instance


class TestIpTag(ShinkenTest):

    def setUp(self):
        self.setup_with_file('etc/nagios_module_ip_tag.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('IpTag')

        # look for a objects that use it
        h1 = self.sched.hosts.find_by_name("test_host_0")
        h2 = self.sched.hosts.find_by_name("test_router_0")
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os
from shinken_test import *
sys.path.append("../shinken/modules")

from shinken.brok import Brok


from shinken.modulesctx import modulesctx
host_perfdata_broker = modulesctx.get_module('perfdata_host')
get_instance = host_perfdata_broker.get_instance


class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_host_perfdata(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_type == 'host_perfdata':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.path == 'tmp/host-perfdata')
Test the hot dependencies arbiter module.
"""

import os, time

from shinken_test import unittest, ShinkenTest, original_time_time, original_time_sleep

# Need to use the real time-functions as we are reading timestamps
# from the filesystem.
time.time = original_time_time
time.sleep = original_time_sleep

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
hot_dependencies_arbiter = modulesctx.get_module('hot_dependencies')
Hot_dependencies_arbiter = hot_dependencies_arbiter.Hot_dependencies_arbiter
get_instance             = hot_dependencies_arbiter.get_instance

modconf = Module()
modconf.module_name = "PickleRetention"
modconf.module_type = hot_dependencies_arbiter.properties['type']
modconf.modules = []
modconf.properties = hot_dependencies_arbiter.properties.copy()


try:
    import json
except ImportError:
    # For old Python version, load
    # simple json (it can be hard json?! It's 2 functions guy!)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

"""
Test Redis retention.
"""

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module
from shinken.log import logger
from shinken.modulesctx import modulesctx
redis_retention_scheduler = modulesctx.get_module('retention_redis')
get_instance = redis_retention_scheduler.get_instance

modconf = Module()
modconf.module_name = "RedisRetention"
modconf.module_type = redis_retention_scheduler.properties['type']
modconf.properties = redis_retention_scheduler.properties.copy()


try:
    import redis
except ImportError:
    redis = None

class TestRedis(ShinkenTest):
    # setUp is inherited from ShinkenTest
Beispiel #18
0
This class is for attaching a sqlite database to a livestatus broker module.
It is one possibility for an exchangeable storage for log broks
"""

import os
import sys
import time
import datetime
import re

from functools import partial

from shinken.log import logger
from shinken.modulesctx import modulesctx

livestatus_broker = modulesctx.get_module('livestatus')
LiveStatusStack = livestatus_broker.LiveStatusStack
LOGCLASS_INVALID = livestatus_broker.LOGCLASS_INVALID
Logline = livestatus_broker.Logline


old_implementation = False
try:
    import sqlite3
except ImportError:  # python 2.4 do not have it
    try:
        import pysqlite2.dbapi2 as sqlite3  # but need the pysqlite2 install from http://code.google.com/p/pysqlite/downloads/list
    except ImportError:  # python 2.4 do not have it
        import sqlite as sqlite3  # one last try
        old_implementation = True
try:
    from nose.exc import SkipTest
except ImportError:
    SkipTest = None

if not sys.version_info > (2, 5):
    if SkipTest:
        raise SkipTest("bah, i am 2.4.x")
    else:
        raise SystemExit(0)

from shinken.objects.module import Module
from shinken.modulesctx import modulesctx

passwd_ui = modulesctx.get_module("auth_htpasswd")
get_instance = passwd_ui.get_instance

from shinken.log import logger


if sys.version_info > (2, 5):
    modconf = Module()
    modconf.module_name = "PasswdUI"
    modconf.module_type = passwd_ui.properties["type"]
    modconf.properties = passwd_ui.properties.copy()


class TestPasswdUI(ShinkenTest):
    # setUp is inherited from ShinkenTest
Beispiel #20
0
"""
This class is for attaching a sqlite database to a livestatus broker module.
It is one possibility for an exchangeable storage for log broks
"""

import os
import sys
import time
import datetime
import re
from shinken.objects.service import Service
from shinken.log import logger
from shinken.modulesctx import modulesctx


livestatus_broker = modulesctx.get_module('livestatus')

# Import a class from the livestatus module, should be already loaded!
#from shinken.modules.livestatus import module as livestatus_broker
LiveStatusStack = livestatus_broker.LiveStatusStack
LOGCLASS_INVALID = livestatus_broker.LOGCLASS_INVALID
Logline = livestatus_broker.Logline


old_implementation = False
try:
    import sqlite3
except ImportError:  # python 2.4 do not have it
    try:
        import pysqlite2.dbapi2 as sqlite3  # but need the pysqlite2 install from http://code.google.com/p/pysqlite/downloads/list
    except ImportError:  # python 2.4 do not have it
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
"""
Test generic pickle retention.
"""

import os
import time

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx

pickle_retention_file_scheduler = modulesctx.get_module(
    'pickle_retention_file_scheduler')
get_instance = pickle_retention_file_scheduler.get_instance

modconf = Module()
modconf.module_name = "PickleRetention"
modconf.module_type = pickle_retention_file_scheduler.properties['type']
modconf.modules = []
modconf.properties = pickle_retention_file_scheduler.properties.copy()


class TestPickleRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_pickle_retention(self):
        now = time.time()
        # get our modules
Beispiel #22
0
# Shinken is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

from shinken_test import *
from shinken.modulesctx import modulesctx
modulesctx.set_modulesdir(modules_dir)
webui = modulesctx.get_module('webui')
helper = webui.helper


class TestUIHelper(ShinkenTest):
    def setUp(self):
        self.setup_with_file('etc/shinken_1r_1h_1s.cfg')

    def test_duration_print(self):
        now = time.time()

        # Got bogus return
        s = helper.print_duration(None)
        print "Res", s
        self.assert_(s == 'N/A')
        s = helper.print_duration(0)
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test the npcd broker module
#

import os, sys, string, time
from multiprocessing import Queue

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
npcdmod_broker = modulesctx.get_module('npcdmod')
Npcd_broker = npcdmod_broker.Npcd_broker

sys.setcheckinterval(10000)

modconf = Module()
modconf.module_name = "ncpd"
modconf.module_type = npcdmod_broker.properties['type']
modconf.modules = []
modconf.properties = npcdmod_broker.properties.copy()


class TestNpcd(ShinkenTest):
    def add(self, b):
        self.broks[b.id] = b
#
# This file is used to test reading and processing of config files
#

import os
from tempfile import mktemp

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx

get_instance = modulesctx.get_module("file_tag").get_instance


class TestFileTag(ShinkenTest):
    def setUp(self):
        self.setup_with_file("etc/nagios_module_file_tag.cfg")

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name("FileTag")

        # look for a objects that use it
        h1 = self.sched.hosts.find_by_name("test_host_0")
        h2 = self.sched.hosts.find_by_name("test_router_0")

        # get our modules
        path = mktemp()
Beispiel #25
0
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os
from shinken_test import *
from shinken.brok import Brok

from shinken.modulesctx import modulesctx
trending_broker = modulesctx.get_module('trending')
get_instance = trending_broker.get_instance

modconf = Module()
modconf.module_name = "Trending"
modconf.module_type = trending_broker.properties['type']
modconf.properties = trending_broker.properties.copy()


class TestTrendingModule(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_trending_module(self):
        
        mod = trending_broker.Trending_broker(modconf)
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
hack_poller_tag_by_macros = modulesctx.get_module('hack_poller_tag_by_macros')
get_instance = hack_poller_tag_by_macros.get_instance



class TestHackPollerTagByMacors(ShinkenTest):

    def setUp(self):
        self.setup_with_file('etc/nagios_module_hack_poller_tag_by_macros.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('HackCommandsPollerTag')

        # get our modules
        mod = hack_poller_tag_by_macros.Hack_pt_by_macros(modconf)
        # Look if we really change our commands
Beispiel #27
0
"""

import os
import time
import datetime
import re
import sys
import pymongo
from pymongo import MongoClient
import traceback

from shinken.objects.service import Service
from shinken.modulesctx import modulesctx

# Import a class from the livestatus module, should be already loaded!
livestatus = modulesctx.get_module('livestatus')

LiveStatusStack = livestatus.LiveStatusStack
# LOGCLASS_INVALID = livestatus.LOGCLASS_INVALID
# Logline = livestatus.Logline
from log_line import (Logline, LOGCLASS_INVALID)

try:
    from pymongo import ReplicaSetConnection, ReadPreference
except ImportError:
    ReplicaSetConnection = None
    ReadPreference = None
from pymongo.errors import AutoReconnect

from shinken.basemodule import BaseModule
from shinken.log import logger
Test the hot dependencies arbiter module.
"""

import os, time

from shinken_test import unittest, ShinkenTest, time_hacker

# Need to use the real time-functions as we are reading timestamps
# from the filesystem.
time_hacker.set_real_time()

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx

hot_dependencies_arbiter = modulesctx.get_module('hot_dependencies')
Hot_dependencies_arbiter = hot_dependencies_arbiter.Hot_dependencies_arbiter
get_instance = hot_dependencies_arbiter.get_instance

modconf = Module()
modconf.module_name = "PickleRetention"
modconf.module_type = hot_dependencies_arbiter.properties['type']
modconf.modules = []
modconf.properties = hot_dependencies_arbiter.properties.copy()

try:
    import json
except ImportError:
    # For old Python version, load
    # simple json (it can be hard json?! It's 2 functions guy!)
    try:
Beispiel #29
0
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os
from Queue import Empty
from multiprocessing import Queue, Manager, active_children

from shinken_test import *
from shinken.log import logger
from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
nrpe_poller = modulesctx.get_module('booster_nrpe')
get_instance = nrpe_poller.get_instance

from shinken.message import Message

modconf = Module()
modconf.module_name = "NrpePoller"
modconf.module_type = nrpe_poller.properties['type']
modconf.properties = nrpe_poller.properties.copy()


class TestNrpePoller(ShinkenTest):
    # Uncomment this is you want to use a specific configuration
    # for your test
    #def setUp(self):
    #    self.setup_with_file('etc/shinken_module_hack_cmd_poller_tag.cfg')
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

from shinken_test import unittest, ShinkenTest

from shinken.brok import Brok

from shinken.modulesctx import modulesctx

get_instance = modulesctx.get_module('merlindb').get_instance


class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_simplelog(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_name == 'ToMerlindb_Sqlite':
                mod = m
        self.assert_(mod is not None)
        self.assert_(
            mod.database_path == '/usr/local/shinken/var/merlindb.sqlite')
Beispiel #31
0
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx

hack_poller_tag_by_macros = modulesctx.get_module('hack_poller_tag_by_macros')
get_instance = hack_poller_tag_by_macros.get_instance


class TestHackPollerTagByMacors(ShinkenTest):
    def setUp(self):
        self.setup_with_file('etc/nagios_module_hack_poller_tag_by_macros.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('HackCommandsPollerTag')

        # get our modules
        mod = hack_poller_tag_by_macros.Hack_pt_by_macros(modconf)
        # Look if we really change our commands

        # Calls the mod with our config
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.
"""
Test Nagios retention
"""

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
nagios_retention_file_scheduler = modulesctx.get_module('retention_nagios')
get_instance = nagios_retention_file_scheduler.get_instance

modconf = Module()
modconf.module_name = "NagiosRetention"
modconf.module_type = nagios_retention_file_scheduler.properties['type']
modconf.properties = nagios_retention_file_scheduler.properties.copy()


class TestNagiosRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_pickle_retention(self):
        # get our modules
        mod = nagios_retention_file_scheduler.Nagios_retention_scheduler(
            modconf, 'etc/module_nagios_retention/retention.dat')
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
hack_commands_poller_tag_arbiter = modulesctx.get_module(
    'hack_commands_poller_tag_arbiter')
get_instance = hack_commands_poller_tag_arbiter.get_instance


class TestHackCmdPollerTag(ShinkenTest):
    def setUp(self):
        self.setup_with_file('etc/nagios_module_hack_cmd_poller_tag.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('HackCommandsPollerTag')

        # get our modules
        mod = hack_commands_poller_tag_arbiter.Hack_cmds_pt(modconf)
        # Look if we really change our commands

        # Calls the mod with our config
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

"""
Test Mongodb retention.
"""

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
mongodb_retention = modulesctx.get_module('retention_mongodb')
get_instance = mongodb_retention.get_instance

modconf = Module()
modconf.module_name = "MongodbRetention"
modconf.uri = 'mongodb://127.0.0.1:27017'
modconf.database = 'test'
modconf.module_type = mongodb_retention.properties['type']
modconf.properties = mongodb_retention.properties.copy()


class TestMongodbRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_mongodb_retention(self):
        # get our modules
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('status_dat').get_instance




class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def nb_of_string(self, buf, s):
        nb_s = 0
        for line in buf.splitlines():
            if line == s:
                print "Find string"
                nb_s += 1
        return nb_s
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
ip_tag_arbiter = modulesctx.get_module('ip-tag')
get_instance   = ip_tag_arbiter.get_instance


class TestIpTag(ShinkenTest):

    def setUp(self):
        self.setup_with_file('etc/nagios_module_ip_tag.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('IpTag')

        # look for a objects that use it
        h1 = self.sched.hosts.find_by_name("test_host_0")
        h2 = self.sched.hosts.find_by_name("test_router_0")
Beispiel #37
0
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#
exit()
import os
from shinken_test import *
from shinken.brok import Brok

from shinken.modulesctx import modulesctx
trending_broker = modulesctx.get_module('trending')
get_instance = trending_broker.get_instance

modconf = Module()
modconf.module_name = "Trending"
modconf.module_type = trending_broker.properties['type']
modconf.properties = trending_broker.properties.copy()


class TestTrendingModule(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_trending_module(self):

        mod = trending_broker.Trending_broker(modconf)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

"""
Test Nagios retention
"""

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
nagios_retention_file_scheduler = modulesctx.get_module('retention_nagios')
get_instance                    = nagios_retention_file_scheduler.get_instance


modconf = Module()
modconf.module_name = "NagiosRetention"
modconf.module_type = nagios_retention_file_scheduler.properties['type']
modconf.properties = nagios_retention_file_scheduler.properties.copy()


class TestNagiosRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_pickle_retention(self):
        # get our modules
        mod = nagios_retention_file_scheduler.Nagios_retention_scheduler(
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os

from shinken_test import unittest, ShinkenTest

from shinken.log import logger
from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
hack_commands_poller_tag_arbiter = modulesctx.get_module('hack_commands_poller_tag_arbiter')
get_instance = hack_commands_poller_tag_arbiter.get_instance


class TestHackCmdPollerTag(ShinkenTest):

    def setUp(self):
        self.setup_with_file('etc/nagios_module_hack_cmd_poller_tag.cfg')

    def test_hack_cmd_poller_tag(self):
        modconf = self.conf.modules.find_by_name('HackCommandsPollerTag')

        # get our modules
        mod = hack_commands_poller_tag_arbiter.Hack_cmds_pt(modconf)
        # Look if we really change our commands
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

"""
Test pickle retention arbiter.
"""

import os
import copy

from shinken_test import unittest, ShinkenTest

from shinken.daemons.arbiterdaemon import Arbiter
from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
pickle_retention_file_generic = modulesctx.get_module('pickle_retention_file_generic')
get_instance = pickle_retention_file_generic.get_instance

modconf = Module()
modconf.module_name = "PickleRetentionGeneric"
modconf.module_type = pickle_retention_file_generic.properties['type']
modconf.properties = pickle_retention_file_generic.properties.copy()


class TestPickleRetentionArbiter(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_pickle_retention(self):
        # get our modules
        mod = pickle_retention_file_generic.Pickle_retention_generic(
            modconf, 'tmp/retention-test.dat')
Beispiel #41
0
This class is for attaching a mongodb database to a livestatus broker module.
It is one possibility for an exchangeable storage for log broks
"""

import os
import time
import datetime
import re
import sys
import pymongo

from shinken.objects.service import Service
from shinken.modulesctx import modulesctx

# Import a class from the livestatus module, should be already loaded!
livestatus = modulesctx.get_module("livestatus")

# when livestatus will be correctly setup, replace:
LiveStatusStack = livestatus.LiveStatusStack
LOGCLASS_INVALID = livestatus.LOGCLASS_INVALID
Logline = livestatus.Logline
# by:
# from livestatus import LiveStatusStack
# from livestatus.log_line import LOGCLASS_INVALID, Logline


try:
    from pymongo import ReplicaSetConnection, ReadPreference
except ImportError:
    ReplicaSetConnection = None
    ReadPreference = None
Beispiel #42
0
from shinken.misc.datamanager import datamgr
from shinken.log import logger

#
from  shinken_test import (
    modules_dir,
    ShinkenTest,
    time_hacker, # not used here but "sub"-imported by lvestatus test (to be corrected)
)

modulesctx.set_modulesdir(modules_dir)


# Special Livestatus module opening since the module rename
#from shinken.modules.livestatus import module as livestatus_broker
livestatus_broker = modulesctx.get_module('livestatus')
LiveStatus_broker = livestatus_broker.LiveStatus_broker
LiveStatus = livestatus_broker.LiveStatus
LiveStatusRegenerator = livestatus_broker.LiveStatusRegenerator
LiveStatusQueryCache = livestatus_broker.LiveStatusQueryCache

Logline = livestatus_broker.Logline
LiveStatusLogStoreMongoDB = modulesctx.get_module('logstore-mongodb').LiveStatusLogStoreMongoDB
LiveStatusLogStoreSqlite = modulesctx.get_module('logstore-sqlite').LiveStatusLogStoreSqlite

livestatus_modconf = Module()
livestatus_modconf.module_name = "livestatus"
livestatus_modconf.module_type = livestatus_broker.properties['type']
livestatus_modconf.properties = livestatus_broker.properties.copy()

# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os
from Queue import Empty
from multiprocessing import Queue, Manager, active_children

from shinken_test import *
from shinken.log import logger
from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
nrpe_poller = modulesctx.get_module('booster_nrpe')
get_instance = nrpe_poller.get_instance

from shinken.message import Message

modconf = Module()
modconf.module_name = "NrpePoller"
modconf.module_type = nrpe_poller.properties['type']
modconf.properties = nrpe_poller.properties.copy()


class TestNrpePoller(ShinkenTest):
    # Uncomment this is you want to use a specific configuration
    # for your test
    #def setUp(self):
    #    self.setup_with_file('etc/nagios_module_hack_cmd_poller_tag.cfg')
Beispiel #44
0
from shinken_test import time_hacker, unittest

from shinken.modulesctx import modulesctx
from shinken.objects.module import Module
from shinken.comment import Comment
from shinken.objects.service import Service


from mock_livestatus import mock_livestatus_handle_request



from livestatus.log_line import Logline


LiveStatusLogStoreMongoDB = modulesctx.get_module('logstore-mongodb').LiveStatusLogStoreMongoDB


sys.setcheckinterval(10000)


@mock_livestatus_handle_request
class TestConfig(ShinkenModulesTest):

    # how much seconds give to mongod be fully started
    # == listening on its input socket/port.
    mongod_start_timeout = 60

    @classmethod
    def _read_mongolog_and_raise(cls, log, proc, reason):
        try:
Beispiel #45
0
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os
from shinken_test import unittest, ShinkenTest

from shinken.brok import Brok
from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('simplelog').get_instance



class TestConfig(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_simplelog(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_type == 'simple_log':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.path == 'tmp/nagios.log')
Beispiel #46
0
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test the npcd broker module
#

import os, sys, string, time
from multiprocessing import Queue

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
npcdmod_broker = modulesctx.get_module('npcdmod')
Npcd_broker = npcdmod_broker.Npcd_broker


sys.setcheckinterval(10000)

modconf = Module()
modconf.module_name = "ncpd"
modconf.module_type = npcdmod_broker.properties['type']
modconf.modules = []
modconf.properties = npcdmod_broker.properties.copy()


class TestNpcd(ShinkenTest):

    def add(self, b):
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

"""
Test generic pickle retention.
"""

import os
import time

from shinken_test import unittest, ShinkenTest

from shinken.objects.module import Module

from shinken.modulesctx import modulesctx
pickle_retention_file_scheduler = modulesctx.get_module('pickle_retention_file_scheduler')
get_instance = pickle_retention_file_scheduler.get_instance

modconf = Module()
modconf.module_name = "PickleRetention"
modconf.module_type = pickle_retention_file_scheduler.properties['type']
modconf.modules = []
modconf.properties = pickle_retention_file_scheduler.properties.copy()


class TestPickleRetention(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_pickle_retention(self):
        now = time.time()
        # get our modules
Beispiel #48
0
#
# Shinken is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

from shinken_test import *
from shinken.modulesctx import modulesctx
webui = modulesctx.get_module('webui')
helper = webui.helper


class TestUIHelper(ShinkenTest):
    def setUp(self):
        self.setup_with_file('etc/nagios_1r_1h_1s.cfg')

    def test_duration_print(self):
        now = time.time()

        # Got bogus return
        s = helper.print_duration(None)
        print "Res", s
        self.assert_(s == 'N/A')
        s = helper.print_duration(0)
from shinken_test import unittest, ShinkenTest
try:
    from nose.exc import SkipTest
except ImportError:
    SkipTest = None

if not sys.version_info > (2, 5):
    if SkipTest:
        raise SkipTest("bah, i am 2.4.x")
    else:
        raise SystemExit(0)

from shinken.objects.module import Module
from shinken.modulesctx import modulesctx
passwd_ui = modulesctx.get_module('auth_htpasswd')
get_instance = passwd_ui.get_instance

from shinken.log import logger


if sys.version_info > (2, 5):
    modconf = Module()
    modconf.module_name = "PasswdUI"
    modconf.module_type = passwd_ui.properties['type']
    modconf.properties = passwd_ui.properties.copy()


class TestPasswdUI(ShinkenTest):
    # setUp is inherited from ShinkenTest
Beispiel #50
0
This class is for attaching a mongodb database to a livestatus broker module.
It is one possibility for an exchangeable storage for log broks
"""

import os
import time
import datetime
import re
import sys
import pymongo

from shinken.objects.service import Service
from shinken.modulesctx import modulesctx

# Import a class from the livestatus module, should be already loaded!
livestatus = modulesctx.get_module('livestatus')

# when livestatus will be correctly setup, replace:
LiveStatusStack = livestatus.LiveStatusStack
LOGCLASS_INVALID = livestatus.LOGCLASS_INVALID
Logline = livestatus.Logline
# by:
#from livestatus import LiveStatusStack
#from livestatus.log_line import LOGCLASS_INVALID, Logline



try:
    from pymongo import ReplicaSetConnection, ReadPreference
except ImportError:
    ReplicaSetConnection = None
#
# You should have received a copy of the GNU Affero General Public License
# along with Shinken.  If not, see <http://www.gnu.org/licenses/>.


#
# This file is used to test reading and processing of config files
#

import os
import time

from shinken_test import unittest, ShinkenTest

from shinken.modulesctx import modulesctx
get_instance = modulesctx.get_module('perfdata_service').get_instance


class TestModSRVPErfdata(ShinkenTest):
    # setUp is inherited from ShinkenTest

    def test_service_perfdata(self):
        print self.conf.modules
        # get our modules
        mod = None
        for m in self.conf.modules:
            if m.module_type == 'service_perfdata':
                mod = m
        self.assert_(mod is not None)
        self.assert_(mod.path == 'tmp/service-perfdata')
        self.assert_(mod.module_name == 'Service-Perfdata')