summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorDamjan Marion <damarion@cisco.com>2017-04-19 14:09:07 +0200
committerDamjan Marion <dmarion.lists@gmail.com>2017-04-20 11:30:28 +0000
commit686c1c8454803e48d45428a720f129f24dc981f7 (patch)
treea5a7b959c029467afb949ccb252b5310921fecf4 /src
parentf1ff5ff1049fd2750823273a3a92779e5fd6e1a5 (diff)
Extend ebuild to specify "configure" subdir, enable verify for sample-plugin
Change-Id: I2056e5d19bc3713e7a13e015dabf3b2431800973 Signed-off-by: Damjan Marion <damarion@cisco.com>
Diffstat (limited to 'src')
-rw-r--r--src/examples/sample-plugin/sample/sample_test.c2
1 files changed, 0 insertions, 2 deletions
diff --git a/src/examples/sample-plugin/sample/sample_test.c b/src/examples/sample-plugin/sample/sample_test.c
index b3e71c760ac..2298675be74 100644
--- a/src/examples/sample-plugin/sample/sample_test.c
+++ b/src/examples/sample-plugin/sample/sample_test.c
@@ -92,9 +92,7 @@ _(SAMPLE_MACSWAP_ENABLE_DISABLE_REPLY, sample_macswap_enable_disable_reply)
static int api_sample_macswap_enable_disable (vat_main_t * vam)
{
- sample_test_main_t * sm = &sample_test_main;
unformat_input_t * i = vam->input;
- f64 timeout;
int enable_disable = 1;
u32 sw_if_index = ~0;
vl_api_sample_macswap_enable_disable_t * mp;
='#n177'>177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 
#!/usr/bin/env python3

import unittest
from framework import VppTestCase, VppTestRunner
from util import ppp
from scapy.packet import Raw
from scapy.layers.inet import IP, UDP
from syslog_rfc5424_parser import SyslogMessage, ParseError
from syslog_rfc5424_parser.constants import SyslogFacility, SyslogSeverity
from vpp_papi import VppEnum


class TestSyslog(VppTestCase):
    """Syslog Protocol Test Cases"""

    @property
    def SYSLOG_SEVERITY(self):
        return VppEnum.vl_api_syslog_severity_t

    @classmethod
    def setUpClass(cls):
        super(TestSyslog, cls).setUpClass()

        try:
            (cls.pg0,) = cls.create_pg_interfaces(range(1))
            cls.pg0.admin_up()
            cls.pg0.config_ip4()
            cls.pg0.resolve_arp()

        except Exception:
            super(TestSyslog, cls).tearDownClass()
            raise

    @classmethod
    def tearDownClass(cls):
        super(TestSyslog, cls).tearDownClass()

    def syslog_generate(self, facility, severity, appname, msgid, sd=None, msg=None):
        """
        Generate syslog message

        :param facility: facility value
        :param severity: severity level
        :param appname: application name that originate message
        :param msgid: message identifier
        :param sd: structured data (optional)
        :param msg: free-form message (optional)
        """
        facility_str = [
            "kernel",
            "user-level",
            "mail-system",
            "system-daemons",
            "security-authorization",
            "syslogd",
            "line-printer",
            "network-news",
            "uucp",
            "clock-daemon",
            "",
            "ftp-daemon",
            "ntp-subsystem",
            "log-audit",
            "log-alert",
            "",
            "local0",
            "local1",
            "local2",
            "local3",
            "local4",
            "local5",
            "local6",
            "local7",
        ]

        severity_str = [
            "emergency",
            "alert",
            "critical",
            "error",
            "warning",
            "notice",
            "informational",
            "debug",
        ]

        cli_str = "test syslog %s %s %s %s" % (
            facility_str[facility],
            severity_str[severity],
            appname,
            msgid,
        )
        if sd is not None:
            for sd_id, sd_params in sd.items():
                cli_str += " sd-id %s" % (sd_id)
                for name, value in sd_params.items():
                    cli_str += " sd-param %s %s" % (name, value)
        if msg is not None:
            cli_str += " %s" % (msg)
        self.vapi.cli(cli_str)

    def syslog_verify(
        self, data, facility, severity, appname, msgid, sd=None, msg=None
    ):
        """
        Verify syslog message

        :param data: syslog message
        :param facility: facility value
        :param severity: severity level
        :param appname: application name that originate message
        :param msgid: message identifier
        :param sd: structured data (optional)
        :param msg: free-form message (optional)
        """
        message = data.decode("utf-8")
        if sd is None:
            sd = {}
        try:
            message = SyslogMessage.parse(message)
        except ParseError as e:
            self.logger.error(e)
            raise
        else:
            self.assertEqual(message.facility, facility)
            self.assertEqual(message.severity, severity)
            self.assertEqual(message.appname, appname)
            self.assertEqual(message.msgid, msgid)
            self.assertEqual(message.msg, msg)
            self.assertEqual(message.sd, sd)
            self.assertEqual(message.version, 1)
            self.assertEqual(message.hostname, self.pg0.local_ip4)

    def test_syslog(self):
        """Syslog Protocol test"""
        self.vapi.syslog_set_sender(
            src_address=self.pg0.local_ip4, collector_address=self.pg0.remote_ip4
        )
        config = self.vapi.syslog_get_sender()
        self.assertEqual(str(config.collector_address), self.pg0.remote_ip4)
        self.assertEqual(config.collector_port, 514)
        self.assertEqual(str(config.src_address), self.pg0.local_ip4)
        self.assertEqual(config.vrf_id, 0)
        self.assertEqual(config.max_msg_size, 480)

        appname = "test"
        msgid = "testMsg"
        msg = "this is message"
        sd1 = {
            "exampleSDID@32473": {"iut": "3", "eventSource": "App", "eventID": "1011"}
        }
        sd2 = {
            "exampleSDID@32473": {"iut": "3", "eventSource": "App", "eventID": "1011"},
            "examplePriority@32473": {"class": "high"},
        }

        self.pg_enable_capture(self.pg_interfaces)
        self.syslog_generate(
            SyslogFacility.local7, SyslogSeverity.info, appname, msgid, None, msg
        )
        capture = self.pg0.get_capture(1)
        try:
            self.assertEqual(capture[0][IP].src, self.pg0.local_ip4)
            self.assertEqual(capture[0][IP].dst, self.pg0.remote_ip4)
            self.assertEqual(capture[0][UDP].dport, 514)
            self.assert_packet_checksums_valid(capture[0], False)
        except:
            self.logger.error(ppp("invalid packet:", capture[0]))
            raise
        self.syslog_verify(
            capture[0][Raw].load,
            SyslogFacility.local7,
            SyslogSeverity.info,
            appname,
            msgid,
            None,
            msg,
        )

        self.pg_enable_capture(self.pg_interfaces)
        self.vapi.syslog_set_filter(self.SYSLOG_SEVERITY.SYSLOG_API_SEVERITY_WARN)
        filter = self.vapi.syslog_get_filter()
        self.assertEqual(filter.severity, self.SYSLOG_SEVERITY.SYSLOG_API_SEVERITY_WARN)
        self.syslog_generate(
            SyslogFacility.local7, SyslogSeverity.info, appname, msgid, None, msg
        )
        self.pg0.assert_nothing_captured()

        self.pg_enable_capture(self.pg_interfaces)
        self.syslog_generate(
            SyslogFacility.local6, SyslogSeverity.warning, appname, msgid, sd1, msg
        )
        capture = self.pg0.get_capture(1)
        self.syslog_verify(
            capture[0][Raw].load,
            SyslogFacility.local6,
            SyslogSeverity.warning,
            appname,
            msgid,
            sd1,
            msg,
        )

        self.vapi.syslog_set_sender(
            self.pg0.local_ip4, self.pg0.remote_ip4, collector_port=12345
        )
        config = self.vapi.syslog_get_sender()
        self.assertEqual(config.collector_port, 12345)

        self.pg_enable_capture(self.pg_interfaces)
        self.syslog_generate(
            SyslogFacility.local5, SyslogSeverity.err, appname, msgid, sd2, None
        )
        capture = self.pg0.get_capture(1)
        try:
            self.assertEqual(capture[0][UDP].dport, 12345)
        except:
            self.logger.error(ppp("invalid packet:", capture[0]))
            raise
        self.syslog_verify(
            capture[0][Raw].load,
            SyslogFacility.local5,
            SyslogSeverity.err,
            appname,
            msgid,
            sd2,
            None,
        )


if __name__ == "__main__":
    unittest.main(testRunner=VppTestRunner)