diff options
Diffstat (limited to 'vnfs/vCPE/vpp-ves-agent-for-vgmux')
| -rw-r--r-- | vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Hc2vpp-Add-VES-agent-for-vG-MUX.patch | 1079 | ||||
| -rw-r--r-- | vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Vpp-Add-VES-agent-for-vG-MUX.patch | 12192 |
2 files changed, 13271 insertions, 0 deletions
diff --git a/vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Hc2vpp-Add-VES-agent-for-vG-MUX.patch b/vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Hc2vpp-Add-VES-agent-for-vG-MUX.patch new file mode 100644 index 00000000..8c2e31b7 --- /dev/null +++ b/vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Hc2vpp-Add-VES-agent-for-vG-MUX.patch @@ -0,0 +1,1079 @@ +From 9a00b1af18dfe4c2df185299b8bd2db7f5d061c0 Mon Sep 17 00:00:00 2001 +From: Johnson Li <johnson.li@intel.com> +Date: Fri, 8 Sep 2017 17:35:16 +0800 +Subject: [PATCH] Add VES agent configuration for vG-MUX + +Signed-off-by: Johnson Li <johnson.li@intel.com> + +diff --git a/pom.xml b/pom.xml +index 538a5d98..581bedfc 100644 +--- a/pom.xml ++++ b/pom.xml +@@ -44,13 +44,14 @@ + <module>nat</module> + <module>lisp</module> + <module>release-notes</module> +- <module>vpp-integration</module> + <module>acl</module> + <module>dhcp</module> ++ <module>ves</module> + <module>samples</module> + <module>vpp-classifier</module> + <module>l3</module> + <module>vpp-management</module> ++ <module>vpp-integration</module> + <module>it</module> + </modules> + </project> +\ No newline at end of file +diff --git a/ves/asciidoc/Readme.adoc b/ves/asciidoc/Readme.adoc +new file mode 100644 +index 00000000..682e7555 +--- /dev/null ++++ b/ves/asciidoc/Readme.adoc +@@ -0,0 +1,3 @@ ++= ves-agent ++ ++Overview of ves-agent +diff --git a/ves/pom.xml b/ves/pom.xml +new file mode 100644 +index 00000000..1ded0109 +--- /dev/null ++++ b/ves/pom.xml +@@ -0,0 +1,56 @@ ++<?xml version="1.0" encoding="UTF-8"?> ++<!-- ++ Copyright (c) 2017 Cisco and/or its affiliates. ++ Licensed under the Apache License, Version 2.0 (the "License"); ++ you may not use this file except in compliance with the License. ++ You may obtain a copy of the License at: ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, ++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ See the License for the specific language governing permissions and ++ limitations under the License. ++--><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> ++ ++ <parent> ++ <groupId>io.fd.hc2vpp.common</groupId> ++ <artifactId>hc2vpp-parent</artifactId> ++ <version>1.17.04.1-SNAPSHOT</version> ++ <relativePath>../common/hc2vpp-parent</relativePath> ++ </parent> ++ ++ <groupId>io.fd.hc2vpp.ves</groupId> ++ <artifactId>ves-agent</artifactId> ++ <version>1.17.04.1-SNAPSHOT</version> ++ <name>ves-agent</name> ++ <packaging>pom</packaging> ++ <modelVersion>4.0.0</modelVersion> ++ <description>Agent for VNF Event Stream plugin</description> ++ ++ <modules> ++ <module>ves-api</module> ++ <module>ves-impl</module> ++ </modules> ++ ++ <!-- DO NOT install or deploy the repo root pom as it's only needed to initiate a build --> ++ <build> ++ <plugins> ++ <plugin> ++ <groupId>org.apache.maven.plugins</groupId> ++ <artifactId>maven-deploy-plugin</artifactId> ++ <configuration> ++ <skip>true</skip> ++ </configuration> ++ </plugin> ++ <plugin> ++ <groupId>org.apache.maven.plugins</groupId> ++ <artifactId>maven-install-plugin</artifactId> ++ <configuration> ++ <skip>true</skip> ++ </configuration> ++ </plugin> ++ </plugins> ++ </build> ++</project> +diff --git a/ves/ves-api/asciidoc/Readme.adoc b/ves/ves-api/asciidoc/Readme.adoc +new file mode 100644 +index 00000000..b561268c +--- /dev/null ++++ b/ves/ves-api/asciidoc/Readme.adoc +@@ -0,0 +1,3 @@ ++= vesagent-api ++ ++Overview of vesagent-api +\ No newline at end of file +diff --git a/ves/ves-api/pom.xml b/ves/ves-api/pom.xml +new file mode 100644 +index 00000000..78bf47b9 +--- /dev/null ++++ b/ves/ves-api/pom.xml +@@ -0,0 +1,52 @@ ++<?xml version="1.0" encoding="UTF-8"?> ++<!-- ++ Copyright (c) 2017 Cisco and/or its affiliates. ++ Licensed under the Apache License, Version 2.0 (the "License"); ++ you may not use this file except in compliance with the License. ++ You may obtain a copy of the License at: ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, ++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ See the License for the specific language governing permissions and ++ limitations under the License. ++--><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> ++ <parent> ++ <groupId>io.fd.hc2vpp.common</groupId> ++ <artifactId>api-parent</artifactId> ++ <version>1.17.04.1-SNAPSHOT</version> ++ <relativePath>../../common/api-parent</relativePath> ++ </parent> ++ ++ <modelVersion>4.0.0</modelVersion> ++ <groupId>io.fd.hc2vpp.ves</groupId> ++ <artifactId>ves-api</artifactId> ++ <name>ves-api</name> ++ <version>1.17.04.1-SNAPSHOT</version> ++ <packaging>bundle</packaging> ++ ++ <dependencies> ++ <dependency> ++ <groupId>org.opendaylight.mdsal.model</groupId> ++ <artifactId>iana-if-type-2014-05-08</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>org.opendaylight.mdsal.model</groupId> ++ <artifactId>ietf-yang-types-20130715</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>org.opendaylight.mdsal.model</groupId> ++ <artifactId>ietf-interfaces</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>org.opendaylight.mdsal.model</groupId> ++ <artifactId>ietf-inet-types-2013-07-15</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>org.opendaylight.mdsal.model</groupId> ++ <artifactId>yang-ext</artifactId> ++ </dependency> ++ </dependencies> ++</project> +diff --git a/ves/ves-api/src/main/yang/vesagent.yang b/ves/ves-api/src/main/yang/vesagent.yang +new file mode 100644 +index 00000000..a3c79797 +--- /dev/null ++++ b/ves/ves-api/src/main/yang/vesagent.yang +@@ -0,0 +1,71 @@ ++module vesagent { ++ ++ yang-version 1; ++ namespace "urn:opendaylight:params:xml:ns:yang:vpp:vesagent"; ++ prefix "vesagent"; ++ ++ description ++ "This YANG module defines the generic configuration and ++ operational data for VES Agent in VPP"; ++ ++ revision "2017-08-01" { ++ description ++ "Initial revision of VES Agent model"; ++ } ++ ++ import ietf-inet-types { ++ prefix inet; ++ } ++ ++ grouping vesagent-attributes { ++ container config { ++ description ++ "VNF Event Stream Agent configuration"; ++ ++ leaf server-addr { ++ type inet:ipv4-address; ++ description ++ "VES Collector's IP address."; ++ } ++ ++ leaf server-port { ++ type uint32; ++ description ++ "VES Collector's Server Port."; ++ } ++ ++ leaf read-interval { ++ type uint32; ++ description ++ "Seconds of time period for each loop."; ++ } ++ ++ leaf is-add { ++ type uint32; ++ description ++ "0-Delete VES agent, NonZero-Start VES agent."; ++ } ++ } ++ ++ container mode { ++ description ++ "VNF Event Stream Agent Working Mode."; ++ ++ leaf base-packet-loss { ++ type uint32; ++ description ++ "Base packet Loss for Demo Mode"; ++ } ++ ++ leaf working-mode { ++ type string; ++ description ++ "VES Working Mode, Demo Or Real Only."; ++ } ++ } ++ } ++ ++ container vesagent { ++ uses vesagent-attributes; ++ } ++} +diff --git a/ves/ves-impl/asciidoc/Readme.adoc b/ves/ves-impl/asciidoc/Readme.adoc +new file mode 100644 +index 00000000..e07fb05f +--- /dev/null ++++ b/ves/ves-impl/asciidoc/Readme.adoc +@@ -0,0 +1,3 @@ ++= vesagent-impl ++ ++Overview of vesagent-impl +\ No newline at end of file +diff --git a/ves/ves-impl/pom.xml b/ves/ves-impl/pom.xml +new file mode 100644 +index 00000000..5ed2c1b4 +--- /dev/null ++++ b/ves/ves-impl/pom.xml +@@ -0,0 +1,157 @@ ++<?xml version="1.0" encoding="UTF-8"?> ++<!-- ++ Copyright (c) 2017 Cisco and/or its affiliates. ++ Licensed under the Apache License, Version 2.0 (the "License"); ++ you may not use this file except in compliance with the License. ++ You may obtain a copy of the License at: ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, ++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ See the License for the specific language governing permissions and ++ limitations under the License. ++--><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> ++ <parent> ++ <groupId>io.fd.hc2vpp.common</groupId> ++ <artifactId>vpp-impl-parent</artifactId> ++ <version>1.17.04.1-SNAPSHOT</version> ++ <relativePath>../../vpp-common/vpp-impl-parent</relativePath> ++ </parent> ++ ++ <modelVersion>4.0.0</modelVersion> ++ <groupId>io.fd.hc2vpp.ves</groupId> ++ <artifactId>ves-impl</artifactId> ++ <name>${project.artifactId}</name> ++ <version>1.17.04.1-SNAPSHOT</version> ++ <packaging>bundle</packaging> ++ ++ <properties> ++ <honeycomb.infra.version>1.17.04.1-SNAPSHOT</honeycomb.infra.version> ++ <hc2vpp.common.version>1.17.04.1-SNAPSHOT</hc2vpp.common.version> ++ </properties> ++ ++ <dependencies> ++ <dependency> ++ <groupId>${project.groupId}</groupId> ++ <artifactId>ves-api</artifactId> ++ <version>${project.version}</version> ++ </dependency> ++ ++ <!--VPP common--> ++ <dependency> ++ <groupId>io.fd.hc2vpp.common</groupId> ++ <artifactId>vpp-translate-utils</artifactId> ++ </dependency> ++ ++ <!-- JVPP --> ++ <dependency> ++ <groupId>io.fd.vpp</groupId> ++ <artifactId>jvpp-registry</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>io.fd.vpp</groupId> ++ <artifactId>jvpp-ves</artifactId> ++ <version>17.04.2-SNAPSHOT</version> ++ </dependency> ++ ++ <!-- Honeycomb infrastructure--> ++ <dependency> ++ <groupId>io.fd.honeycomb</groupId> ++ <artifactId>minimal-distribution</artifactId> ++ <version>${honeycomb.infra.version}</version> ++ </dependency> ++ ++ <dependency> ++ <groupId>io.fd.honeycomb</groupId> ++ <artifactId>translate-api</artifactId> ++ <version>${honeycomb.infra.version}</version> ++ </dependency> ++ ++ <dependency> ++ <groupId>io.fd.honeycomb</groupId> ++ <artifactId>translate-spi</artifactId> ++ <version>${honeycomb.infra.version}</version> ++ </dependency> ++ ++ <dependency> ++ <groupId>io.fd.honeycomb</groupId> ++ <artifactId>cfg-init</artifactId> ++ <version>${honeycomb.infra.version}</version> ++ </dependency> ++ ++ <!-- Translation --> ++ <dependency> ++ <groupId>io.fd.hc2vpp.common</groupId> ++ <artifactId>vpp-translate-utils</artifactId> ++ </dependency> ++ ++ <!-- DI --> ++ <dependency> ++ <groupId>com.google.inject</groupId> ++ <artifactId>guice</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>net.jmob</groupId> ++ <artifactId>guice.conf</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>com.google.inject.extensions</groupId> ++ <artifactId>guice-multibindings</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>io.fd.honeycomb</groupId> ++ <artifactId>translate-impl</artifactId> ++ <version>1.17.04.1-SNAPSHOT</version> ++ </dependency> ++ ++ ++ <!-- Testing dependencies--> ++ <dependency> ++ <groupId>com.google.inject</groupId> ++ <artifactId>guice</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>net.jmob</groupId> ++ <artifactId>guice.conf</artifactId> ++ </dependency> ++ <dependency> ++ <groupId>com.google.inject.extensions</groupId> ++ <artifactId>guice-multibindings</artifactId> ++ </dependency> ++ ++ <dependency> ++ <groupId>junit</groupId> ++ <artifactId>junit</artifactId> ++ <scope>test</scope> ++ </dependency> ++ <dependency> ++ <groupId>io.fd.hc2vpp.common</groupId> ++ <artifactId>vpp-translate-test</artifactId> ++ <version>${hc2vpp.common.version}</version> ++ <scope>test</scope> ++ </dependency> ++ <dependency> ++ <groupId>org.mockito</groupId> ++ <artifactId>mockito-core</artifactId> ++ <scope>test</scope> ++ </dependency> ++ <dependency> ++ <groupId>com.google.inject.extensions</groupId> ++ <artifactId>guice-testlib</artifactId> ++ <scope>test</scope> ++ </dependency> ++ <dependency> ++ <groupId>org.hamcrest</groupId> ++ <artifactId>hamcrest-all</artifactId> ++ <scope>test</scope> ++ </dependency> ++ <dependency> ++ <groupId>io.fd.honeycomb.infra</groupId> ++ <artifactId>test-tools</artifactId> ++ <version>${project.version}</version> ++ <scope>test</scope> ++ </dependency> ++ </dependencies> ++</project> +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/VesModule.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/VesModule.java +new file mode 100644 +index 00000000..0cd60068 +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/VesModule.java +@@ -0,0 +1,67 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves; ++ ++import com.google.common.annotations.VisibleForTesting; ++import com.google.inject.AbstractModule; ++import com.google.inject.Provider; ++import com.google.inject.Singleton; ++import com.google.inject.multibindings.Multibinder; ++import io.fd.hc2vpp.ves.jvpp.JVppVesProvider; ++import io.fd.hc2vpp.ves.read.VesReaderFactory; ++import io.fd.hc2vpp.ves.write.VesWriterFactory; ++import io.fd.honeycomb.translate.read.ReaderFactory; ++import io.fd.honeycomb.translate.write.WriterFactory; ++import io.fd.vpp.jvpp.ves.future.FutureJVppVesFacade; ++import org.slf4j.Logger; ++import org.slf4j.LoggerFactory; ++ ++/** ++ * VesModule class instantiating ves plugin components. ++ */ ++public final class VesModule extends AbstractModule { ++ ++ private static final Logger LOG = LoggerFactory.getLogger(VesModule.class); ++ private final Class<? extends Provider<FutureJVppVesFacade>> jvppVesProviderClass; ++ ++ public VesModule() { ++ this(JVppVesProvider.class); ++ } ++ ++ @VisibleForTesting ++ VesModule(Class<? extends Provider<FutureJVppVesFacade>> jvppVesProvider) { ++ this.jvppVesProviderClass = jvppVesProvider; ++ } ++ ++ @Override ++ protected void configure() { ++ LOG.info("Installing VES Agent module"); ++ ++ // Bind to Plugin's JVPP ++ bind(FutureJVppVesFacade.class).toProvider(jvppVesProviderClass).in(Singleton.class); ++ ++ LOG.info("Injecting writers factories"); ++ final Multibinder<WriterFactory> writerFactoryBinder = Multibinder.newSetBinder(binder(), WriterFactory.class); ++ writerFactoryBinder.addBinding().to(VesWriterFactory.class); ++ ++ LOG.info("Injecting readers factories"); ++ final Multibinder<ReaderFactory> readerFactoryBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class); ++ readerFactoryBinder.addBinding().to(VesReaderFactory.class); ++ ++ LOG.info("Module VES Agent successfully configured"); ++ } ++} +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/jvpp/JVppVesProvider.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/jvpp/JVppVesProvider.java +new file mode 100644 +index 00000000..8afed84e +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/jvpp/JVppVesProvider.java +@@ -0,0 +1,59 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves.jvpp; ++ ++import com.google.inject.Inject; ++import io.fd.honeycomb.infra.distro.ProviderTrait; ++import io.fd.vpp.jvpp.JVppRegistry; ++import io.fd.vpp.jvpp.ves.JVppVesImpl; ++import io.fd.vpp.jvpp.ves.future.FutureJVppVesFacade; ++import java.io.IOException; ++import org.slf4j.Logger; ++import org.slf4j.LoggerFactory; ++ ++/** ++ * Provides future API for jvpp-ves plugin. Must be a singleton due to shutdown hook usage. ++ * Registers shutdown hook to free plugin's resources on shutdown. ++ */ ++public final class JVppVesProvider extends ProviderTrait<FutureJVppVesFacade> { ++ ++ private static final Logger LOG = LoggerFactory.getLogger(JVppVesProvider.class); ++ ++ @Inject ++ private JVppRegistry registry; ++ ++ @Override ++ protected FutureJVppVesFacade create() { ++ try { ++ final JVppVesImpl jvppVes = new JVppVesImpl(); ++ Runtime.getRuntime().addShutdownHook(new Thread() { ++ @Override ++ public void run() { ++ LOG.info("Unloading jvpp-ves plugin"); ++ jvppVes.close(); ++ LOG.info("Successfully unloaded jvpp-ves plugin"); ++ } ++ }); ++ ++ LOG.info("Successfully loaded jvpp-ves plugin"); ++ return new FutureJVppVesFacade(registry, jvppVes); ++ } catch (IOException e) { ++ throw new IllegalStateException("Unable to open VPP management connection", e); ++ } ++ } ++} ++ +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/read/VesReaderFactory.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/read/VesReaderFactory.java +new file mode 100644 +index 00000000..bef652fd +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/read/VesReaderFactory.java +@@ -0,0 +1,50 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves.read; ++ ++import com.google.inject.Inject; ++import io.fd.honeycomb.translate.read.ReaderFactory; ++import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder; ++import io.fd.vpp.jvpp.core.future.FutureJVppCore; ++import javax.annotation.Nonnull; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.Vesagent; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.VesagentBuilder; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Config; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.ConfigBuilder; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Mode; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.ModeBuilder; ++import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; ++ ++/** ++ * Factory producing writers for VES Agent plugin's data. ++ */ ++public final class VesReaderFactory implements ReaderFactory { ++ ++ private static final InstanceIdentifier<Vesagent> VESAGENT_ID = InstanceIdentifier.create(Vesagent.class); ++ private static final InstanceIdentifier<Config> CONFIG_ID = InstanceIdentifier.create(Config.class); ++ private static final InstanceIdentifier<Mode> MODE_ID = InstanceIdentifier.create(Mode.class); ++ ++ @Inject ++ private FutureJVppCore vppApi; ++ ++ @Override ++ public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { ++ registry.addStructuralReader(VESAGENT_ID, VesagentBuilder.class); ++ registry.addStructuralReader(CONFIG_ID, ConfigBuilder.class); ++ registry.addStructuralReader(MODE_ID, ModeBuilder.class); ++ } ++} +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesConfigCustomizer.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesConfigCustomizer.java +new file mode 100644 +index 00000000..e06afa73 +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesConfigCustomizer.java +@@ -0,0 +1,127 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves.write; ++ ++import static com.google.common.base.Preconditions.checkArgument; ++ ++import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; ++import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; ++import io.fd.hc2vpp.common.translate.util.Ipv4Translator; ++import io.fd.hc2vpp.common.translate.util.Ipv6Translator; ++import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; ++import io.fd.honeycomb.translate.spi.write.WriterCustomizer; ++import io.fd.honeycomb.translate.write.WriteContext; ++import io.fd.honeycomb.translate.write.WriteFailedException; ++import io.fd.vpp.jvpp.core.future.FutureJVppCore; ++//import io.fd.vpp.jvpp.ves.future.FutureJVppVes; ++import io.fd.vpp.jvpp.ves.dto.VesAgentConfig; ++import io.fd.vpp.jvpp.ves.future.FutureJVppVesFacade; ++import javax.annotation.Nonnull; ++//import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.Vesagent; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Config; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.ConfigBuilder; ++import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; ++import org.slf4j.Logger; ++import org.slf4j.LoggerFactory; ++ ++final class VesConfigCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Config>, ++ JvppReplyConsumer, ByteDataTranslator, Ipv6Translator, Ipv4Translator { ++ private static final Logger LOG = LoggerFactory.getLogger(VesConfigCustomizer.class); ++ ++ private final FutureJVppVesFacade jvppVes; ++ ++ VesConfigCustomizer(final FutureJVppCore vppApi, final FutureJVppVesFacade jvppVes) { ++ super(vppApi); ++ this.jvppVes = jvppVes; ++ } ++ ++ @Override ++ public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> iid, @Nonnull final Config dataAfter, ++ @Nonnull final WriteContext writeContext) throws WriteFailedException { ++ ConfigBuilder configBuilder = new ConfigBuilder(); ++ InstanceIdentifier<Config> id = iid; ++ ++ LOG.debug("Writing VES Agent Config {} dataAfter={}", id, dataAfter); ++ checkArgument(dataAfter.getServerAddr() != null && dataAfter.getServerAddr().getValue() != null ++ && dataAfter.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ ++ configBuilder.setServerAddr(dataAfter.getServerAddr()) ++ .setServerPort(dataAfter.getServerPort()) ++ .setReadInterval(dataAfter.getReadInterval()) ++ .setIsAdd(1L); ++ ++ setVesAgentConfig(id, configBuilder.build()); ++ } ++ ++ @Override ++ public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Config> iid, @Nonnull final Config dataBefore, ++ @Nonnull final Config dataAfter, @Nonnull final WriteContext writeContext) ++ throws WriteFailedException { ++ ConfigBuilder configBuilder = new ConfigBuilder(); ++ InstanceIdentifier<Config> id = iid; ++ ++ checkArgument(dataBefore.getServerAddr() != null && dataBefore.getServerAddr().getValue() != null ++ && dataBefore.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ checkArgument(dataAfter.getServerAddr() != null && dataAfter.getServerAddr().getValue() != null ++ && dataAfter.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ ++ // remove old configuration: ++ configBuilder.setServerAddr(dataBefore.getServerAddr()) ++ .setServerPort(dataBefore.getServerPort()) ++ .setReadInterval(dataBefore.getReadInterval()) ++ .setIsAdd(0L); ++ setVesAgentConfig(id, configBuilder.build()); ++ ++ // and add new one: ++ configBuilder.setServerAddr(dataAfter.getServerAddr()) ++ .setServerPort(dataAfter.getServerPort()) ++ .setReadInterval(dataAfter.getReadInterval()) ++ .setIsAdd(1L); ++ setVesAgentConfig(id, configBuilder.build()); ++ } ++ ++ @Override ++ public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> iid, @Nonnull final Config dataBefore, ++ @Nonnull final WriteContext writeContext) throws WriteFailedException { ++ ConfigBuilder configBuilder = new ConfigBuilder(); ++ InstanceIdentifier<Config> id = iid; ++ LOG.debug("Removing VES Agent {} dataBefore={}", id, dataBefore); ++ ++ checkArgument(dataBefore.getServerAddr() != null && dataBefore.getServerAddr().getValue() != null ++ && dataBefore.getServerPort() != 0, "VES Server Address and Port need to be dataBeforeured"); ++ ++ configBuilder.setServerAddr(dataBefore.getServerAddr()) ++ .setServerPort(dataBefore.getServerPort()) ++ .setReadInterval(dataBefore.getReadInterval()) ++ .setIsAdd(0L); ++ ++ setVesAgentConfig(id, configBuilder.build()); ++ } ++ ++ private void setVesAgentConfig(final InstanceIdentifier<Config> id, final Config config) ++ throws WriteFailedException { ++ final VesAgentConfig request = new VesAgentConfig(); ++ ++ request.serverPort = config.getServerPort().byteValue(); ++ request.readInterval = config.getReadInterval().byteValue(); ++ request.isAdd = config.getIsAdd().byteValue(); ++ request.serverAddr = ipv4AddressNoZoneToArray(config.getServerAddr().getValue()); ++ ++ LOG.debug("VES agent config change id={} request={}", id, request); ++ getReplyForWrite(jvppVes.vesAgentConfig(request).toCompletableFuture(), id); ++ } ++} +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesModeCustomizer.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesModeCustomizer.java +new file mode 100644 +index 00000000..8b6d5a9a +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesModeCustomizer.java +@@ -0,0 +1,97 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves.write; ++ ++import static com.google.common.base.Preconditions.checkArgument; ++ ++import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; ++import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; ++import io.fd.hc2vpp.common.translate.util.Ipv4Translator; ++import io.fd.hc2vpp.common.translate.util.Ipv6Translator; ++import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; ++import io.fd.honeycomb.translate.spi.write.WriterCustomizer; ++import io.fd.honeycomb.translate.write.WriteContext; ++import io.fd.honeycomb.translate.write.WriteFailedException; ++import io.fd.vpp.jvpp.core.future.FutureJVppCore; ++//import io.fd.vpp.jvpp.ves.future.FutureJVppVes; ++import io.fd.vpp.jvpp.ves.dto.VesAgentMode; ++import io.fd.vpp.jvpp.ves.future.FutureJVppVesFacade; ++import javax.annotation.Nonnull; ++//import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.Vesagent; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Mode; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.ModeBuilder; ++import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; ++import org.slf4j.Logger; ++import org.slf4j.LoggerFactory; ++ ++final class VesModeCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Mode>, ++ JvppReplyConsumer, ByteDataTranslator, Ipv6Translator, Ipv4Translator { ++ private static final Logger LOG = LoggerFactory.getLogger(VesModeCustomizer.class); ++ ++ private final FutureJVppVesFacade jvppVes; ++ ++ VesModeCustomizer(final FutureJVppCore vppApi, final FutureJVppVesFacade jvppVes) { ++ super(vppApi); ++ this.jvppVes = jvppVes; ++ } ++ ++ @Override ++ public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Mode> iid, @Nonnull final Mode dataAfter, ++ @Nonnull final WriteContext writeContext) throws WriteFailedException { ++ LOG.debug("Writing VES Agent Working Mode {} dataAfter={}", iid, dataAfter); ++ ++ checkArgument(dataAfter.getWorkingMode() != null && dataAfter.getBasePacketLoss() <= 100, ++ "VES Agent Working Mode need to be correctly configured."); ++ ++ setVesAgentMode(iid, dataAfter); ++ } ++ ++ @Override ++ public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Mode> iid, @Nonnull final Mode dataBefore, ++ @Nonnull final Mode dataAfter, @Nonnull final WriteContext writeContext) ++ throws WriteFailedException { ++ LOG.debug("Writing VES Agent Working Mode {} {}-->{}", iid, dataBefore, dataAfter); ++ ++ checkArgument(dataAfter.getWorkingMode() != null && dataAfter.getBasePacketLoss() <= 100, ++ "VES Agent Working Mode need to be correctly configured."); ++ ++ setVesAgentMode(iid, dataAfter); ++ } ++ ++ @Override ++ public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Mode> iid, @Nonnull final Mode dataBefore, ++ @Nonnull final WriteContext writeContext) throws WriteFailedException { ++ ModeBuilder modeBuilder = new ModeBuilder(); ++ LOG.debug("Restoring VES Mode {} dataBefore={} to default.", iid, dataBefore); ++ ++ modeBuilder.setWorkingMode("Real") ++ .setBasePacketLoss(0L); ++ ++ setVesAgentMode(iid, modeBuilder.build()); ++ } ++ ++ private void setVesAgentMode(final InstanceIdentifier<Mode> id, final Mode mode) ++ throws WriteFailedException { ++ final VesAgentMode request = new VesAgentMode(); ++ ++ request.pktLossRate = mode.getBasePacketLoss().byteValue(); ++ request.workMode = mode.getWorkingMode().getBytes(); ++ ++ LOG.debug("VES agent working mode change id={} request={}", id, request); ++ getReplyForWrite(jvppVes.vesAgentMode(request).toCompletableFuture(), id); ++ } ++} +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesWriterFactory.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesWriterFactory.java +new file mode 100644 +index 00000000..581f0460 +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesWriterFactory.java +@@ -0,0 +1,54 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves.write; ++ ++import com.google.common.collect.ImmutableSet; ++import com.google.inject.Inject; ++import io.fd.honeycomb.translate.impl.write.GenericWriter; ++import io.fd.honeycomb.translate.write.WriterFactory; ++import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder; ++import io.fd.vpp.jvpp.core.future.FutureJVppCore; ++import io.fd.vpp.jvpp.ves.future.FutureJVppVesFacade; ++import javax.annotation.Nonnull; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.Vesagent; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Config; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Mode; ++import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; ++ ++/** ++ * Factory producing writers for VES Agent plugin's data. ++ */ ++public final class VesWriterFactory implements WriterFactory { ++ ++ private static final InstanceIdentifier<Vesagent> VESAGENT_ID = InstanceIdentifier.create(Vesagent.class); ++ ++ @Inject ++ private FutureJVppCore vppApi; ++ ++ @Inject ++ protected FutureJVppVesFacade futureVesFacade; ++ ++ @Override ++ public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { ++ registry.add(new GenericWriter<>(VESAGENT_ID, ++ new VesagentCustomizer(vppApi, futureVesFacade))); ++ registry.add(new GenericWriter<>(VESAGENT_ID.child(Config.class), ++ new VesConfigCustomizer(vppApi, futureVesFacade))); ++ registry.add(new GenericWriter<>(VESAGENT_ID.child(Mode.class), ++ new VesModeCustomizer(vppApi, futureVesFacade))); ++ } ++} +diff --git a/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesagentCustomizer.java b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesagentCustomizer.java +new file mode 100644 +index 00000000..62e46cdb +--- /dev/null ++++ b/ves/ves-impl/src/main/java/io/fd/hc2vpp/ves/write/VesagentCustomizer.java +@@ -0,0 +1,131 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++package io.fd.hc2vpp.ves.write; ++ ++import static com.google.common.base.Preconditions.checkArgument; ++ ++import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; ++import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; ++import io.fd.hc2vpp.common.translate.util.Ipv4Translator; ++import io.fd.hc2vpp.common.translate.util.Ipv6Translator; ++import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; ++import io.fd.honeycomb.translate.spi.write.WriterCustomizer; ++import io.fd.honeycomb.translate.write.WriteContext; ++import io.fd.honeycomb.translate.write.WriteFailedException; ++import io.fd.vpp.jvpp.core.future.FutureJVppCore; ++//import io.fd.vpp.jvpp.ves.future.FutureJVppVes; ++import io.fd.vpp.jvpp.ves.dto.VesAgentConfig; ++import io.fd.vpp.jvpp.ves.future.FutureJVppVesFacade; ++import javax.annotation.Nonnull; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.Vesagent; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.Config; ++import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vesagent.rev170801.vesagent.attributes.ConfigBuilder; ++import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; ++import org.slf4j.Logger; ++import org.slf4j.LoggerFactory; ++ ++final class VesagentCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Vesagent>, ++ JvppReplyConsumer, ByteDataTranslator, Ipv6Translator, Ipv4Translator { ++ private static final Logger LOG = LoggerFactory.getLogger(VesagentCustomizer.class); ++ ++ private final FutureJVppVesFacade jvppVes; ++ ++ VesagentCustomizer(final FutureJVppCore vppApi, final FutureJVppVesFacade jvppVes) { ++ super(vppApi); ++ this.jvppVes = jvppVes; ++ } ++ ++ @Override ++ public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Vesagent> iid, @Nonnull final Vesagent dataAfter, ++ @Nonnull final WriteContext writeContext) throws WriteFailedException { ++ Config config = dataAfter.getConfig(); ++ ConfigBuilder configBuilder = new ConfigBuilder(); ++ InstanceIdentifier<Config> id = iid.child(Config.class); ++ ++ LOG.debug("Writing VES Agent Config {} dataAfter={}", id, config); ++ checkArgument(config.getServerAddr() != null && config.getServerAddr().getValue() != null ++ && config.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ ++ configBuilder.setServerAddr(config.getServerAddr()) ++ .setServerPort(config.getServerPort()) ++ .setReadInterval(config.getReadInterval()) ++ .setIsAdd(1L); ++ ++ setVesAgentConfig(id, configBuilder.build()); ++ } ++ ++ @Override ++ public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Vesagent> iid, @Nonnull final Vesagent dataBefore, ++ @Nonnull final Vesagent dataAfter, @Nonnull final WriteContext writeContext) ++ throws WriteFailedException { ++ Config configBefore = dataBefore.getConfig(); ++ Config configAfter = dataAfter.getConfig(); ++ ConfigBuilder configBuilder = new ConfigBuilder(); ++ InstanceIdentifier<Config> id = iid.child(Config.class); ++ ++ checkArgument(configBefore.getServerAddr() != null && configBefore.getServerAddr().getValue() != null ++ && configBefore.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ checkArgument(configAfter.getServerAddr() != null && configAfter.getServerAddr().getValue() != null ++ && configAfter.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ ++ // remove old configuration: ++ configBuilder.setServerAddr(configBefore.getServerAddr()) ++ .setServerPort(configBefore.getServerPort()) ++ .setReadInterval(configBefore.getReadInterval()) ++ .setIsAdd(0L); ++ setVesAgentConfig(id, configBuilder.build()); ++ ++ // and add new one: ++ configBuilder.setServerAddr(configAfter.getServerAddr()) ++ .setServerPort(configAfter.getServerPort()) ++ .setReadInterval(configAfter.getReadInterval()) ++ .setIsAdd(1L); ++ setVesAgentConfig(id, configBuilder.build()); ++ } ++ ++ @Override ++ public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vesagent> iid, @Nonnull final Vesagent dataBefore, ++ @Nonnull final WriteContext writeContext) throws WriteFailedException { ++ Config config = dataBefore.getConfig(); ++ InstanceIdentifier<Config> id = iid.child(Config.class); ++ LOG.debug("Removing VES Agent {} dataBefore={}", id, config); ++ ++ checkArgument(config.getServerAddr() != null && config.getServerAddr().getValue() != null ++ && config.getServerPort() != 0, "VES Server Address and Port need to be configured"); ++ ++ ConfigBuilder configBuilder = new ConfigBuilder(); ++ configBuilder.setServerAddr(config.getServerAddr()) ++ .setServerPort(config.getServerPort()) ++ .setReadInterval(config.getReadInterval()) ++ .setIsAdd(0L); ++ ++ setVesAgentConfig(id, configBuilder.build()); ++ } ++ ++ private void setVesAgentConfig(final InstanceIdentifier<Config> id, final Config config) ++ throws WriteFailedException { ++ final VesAgentConfig request = new VesAgentConfig(); ++ ++ request.serverPort = config.getServerPort().byteValue(); ++ request.readInterval = config.getReadInterval().byteValue(); ++ request.isAdd = config.getIsAdd().byteValue(); ++ request.serverAddr = ipv4AddressNoZoneToArray(config.getServerAddr().getValue()); ++ ++ LOG.debug("VES agent config change id={} request={}", id, request); ++ getReplyForWrite(jvppVes.vesAgentConfig(request).toCompletableFuture(), id); ++ } ++} +diff --git a/vpp-integration/minimal-distribution/pom.xml b/vpp-integration/minimal-distribution/pom.xml +index e126114a..ca0e5b24 100644 +--- a/vpp-integration/minimal-distribution/pom.xml ++++ b/vpp-integration/minimal-distribution/pom.xml +@@ -40,6 +40,7 @@ + <routing.version>1.17.04.1-SNAPSHOT</routing.version> + <acl.version>1.17.04.1-SNAPSHOT</acl.version> + <dhcp.version>1.17.04.1-SNAPSHOT</dhcp.version> ++ <vesagent.version>1.17.04.1-SNAPSHOT</vesagent.version> + <vpp.classifier.version>1.17.04.1-SNAPSHOT</vpp.classifier.version> + <l3-impl.version>1.17.04.1-SNAPSHOT</l3-impl.version> + <vpp-management-impl.version>1.17.04.1-SNAPSHOT</vpp-management-impl.version> +@@ -63,6 +64,7 @@ + io.fd.hc2vpp.routing.RoutingModule, + io.fd.hc2vpp.acl.AclModule, + io.fd.hc2vpp.dhcp.DhcpModule, ++ io.fd.hc2vpp.ves.VesModule, + io.fd.hc2vpp.policer.PolicerModule, + // io.fd.hc2vpp.vppnsh.impl.VppNshModule, + <!-- Nsh module by default disabled, because it needs vpp-nsh plugin, which is not part of vpp codebase.--> +@@ -151,6 +153,11 @@ + <version>${dhcp.version}</version> + </dependency> + <dependency> ++ <groupId>io.fd.hc2vpp.ves</groupId> ++ <artifactId>ves-impl</artifactId> ++ <version>${vesagent.version}</version> ++ </dependency> ++ <dependency> + <groupId>io.fd.hc2vpp.management</groupId> + <artifactId>vpp-management-impl</artifactId> + <version>${vpp-management-impl.version}</version> +-- +2.12.2.windows.2 + diff --git a/vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Vpp-Add-VES-agent-for-vG-MUX.patch b/vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Vpp-Add-VES-agent-for-vG-MUX.patch new file mode 100644 index 00000000..d305edc9 --- /dev/null +++ b/vnfs/vCPE/vpp-ves-agent-for-vgmux/src/patches/Vpp-Add-VES-agent-for-vG-MUX.patch @@ -0,0 +1,12192 @@ +From 63b26bdf990ebf0105a0a4bc6977555820c70c5e Mon Sep 17 00:00:00 2001 +From: Johnson Li <johnson.li@intel.com> +Date: Fri, 8 Sep 2017 17:25:02 +0800 +Subject: [PATCH] Add VES agent for vG-MUX + +Signed-off-by: Johnson Li <johnson.li@intel.com> + +diff --git a/src/configure.ac b/src/configure.ac +index fb2ead6d..ea641525 100644 +--- a/src/configure.ac ++++ b/src/configure.ac +@@ -154,6 +154,7 @@ PLUGIN_ENABLED(lb) + PLUGIN_ENABLED(memif) + PLUGIN_ENABLED(sixrd) + PLUGIN_ENABLED(snat) ++PLUGIN_ENABLED(ves) + + ############################################################################### + # Dependency checks +diff --git a/src/plugins/Makefile.am b/src/plugins/Makefile.am +index 623892e7..84513755 100644 +--- a/src/plugins/Makefile.am ++++ b/src/plugins/Makefile.am +@@ -69,6 +69,10 @@ if ENABLE_SNAT_PLUGIN + include snat.am + endif + ++if ENABLE_VES_PLUGIN ++include ves.am ++endif ++ + include ../suffix-rules.mk + + # Remove *.la files +diff --git a/src/plugins/ves.am b/src/plugins/ves.am +new file mode 100644 +index 00000000..faaa1126 +--- /dev/null ++++ b/src/plugins/ves.am +@@ -0,0 +1,35 @@ ++# Copyright (c) 2017 Intel and/or its affiliates. ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at: ++# ++# http://www.apache.org/licenses/LICENSE-2.0 ++# ++# Unless required by applicable law or agreed to in writing, software ++# distributed under the License is distributed on an "AS IS" BASIS, ++# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++# See the License for the specific language governing permissions and ++# limitations under the License. ++ ++vppplugins_LTLIBRARIES += ves_plugin.la ++ ++LIBS_DIR=$(CURDIR)/ves/libs ++ves_plugin_la_LDFLAGS = $(AM_LDFLAGS) -L$(LIBS_DIR) ++ves_plugin_la_LDFLAGS += -Wl,--whole-archive -level -Wl,--no-whole-archive ++ves_plugin_la_LDFLAGS += -Wl,-lpthread,-lcurl ++ ++ves_plugin_la_SOURCES = ves/ves_node.c \ ++ ves/ves_api.c ++ ++BUILT_SOURCES += \ ++ ves/ves.api.h \ ++ ves/ves.api.json ++ ++API_FILES += ves/ves.api ++ ++nobase_apiinclude_HEADERS += \ ++ ves/ves_all_api_h.h \ ++ ves/ves_msg_enum.h \ ++ ves/ves.api.h ++ ++# vi:syntax=automake +diff --git a/src/plugins/ves/include/double_list.h b/src/plugins/ves/include/double_list.h +new file mode 100644 +index 00000000..3bfae4c6 +--- /dev/null ++++ b/src/plugins/ves/include/double_list.h +@@ -0,0 +1,56 @@ ++#ifndef DOUBLE_LIST_INCLUDED ++#define DOUBLE_LIST_INCLUDED ++ ++/**************************************************************************//** ++ * @file ++ * A simple double-linked list. ++ * ++ * @note No thread protection so you will need to use appropriate ++ * synchronization if use spans multiple threads. ++ * ++ * License ++ * ------- ++ * ++ * Copyright © 2017 AT&T Intellectual Property. All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ * ++ ****************************************************************************/ ++ ++typedef struct dlist_item ++{ ++ struct dlist_item * previous; ++ struct dlist_item * next; ++ void * item; ++} DLIST_ITEM; ++ ++/**************************************************************************//** ++ * Double-linked list structure ++ *****************************************************************************/ ++typedef struct dlist ++{ ++ DLIST_ITEM * head; ++ DLIST_ITEM * tail; ++} DLIST; ++ ++ ++void dlist_initialize(DLIST * list); ++void * dlist_pop_last(DLIST * list); ++void dlist_push_first(DLIST * list, void * item); ++void dlist_push_last(DLIST * list, void * item); ++DLIST_ITEM * dlist_get_first(DLIST * list); ++DLIST_ITEM * dlist_get_last(DLIST * list); ++DLIST_ITEM * dlist_get_next(DLIST_ITEM * item); ++int dlist_is_empty(DLIST * list); ++int dlist_count(DLIST * list); ++ ++#endif +diff --git a/src/plugins/ves/include/evel.h b/src/plugins/ves/include/evel.h +new file mode 100644 +index 00000000..817785ef +--- /dev/null ++++ b/src/plugins/ves/include/evel.h +@@ -0,0 +1,3662 @@ ++#ifndef EVEL_INCLUDED ++#define EVEL_INCLUDED ++/**************************************************************************//** ++ * @file ++ * Header for EVEL library ++ * ++ * This file implements the EVEL library which is intended to provide a ++ * simple wrapper around the complexity of AT&T's Vendor Event Listener API so ++ * that VNFs can use it without worrying about details of the API transport. ++ * ++ * Zero return value is success (::EVEL_SUCCESS), non-zero is failure and will ++ * be one of ::EVEL_ERR_CODES. ++ * ++ * License ++ * ------- ++ * ++ * Copyright © 2017 AT&T Intellectual Property. All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ *****************************************************************************/ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include <stdbool.h> ++#include <stdio.h> ++#include <stdarg.h> ++#include <time.h> ++ ++#include "double_list.h" ++ ++/*****************************************************************************/ ++/* Supported API version. */ ++/*****************************************************************************/ ++#define EVEL_API_MAJOR_VERSION 3 ++#define EVEL_API_MINOR_VERSION 0 ++ ++/**************************************************************************//** ++ * Error codes ++ * ++ * Error codes for EVEL low level interface ++ *****************************************************************************/ ++typedef enum { ++ EVEL_SUCCESS, /** The operation was successful. */ ++ EVEL_ERR_GEN_FAIL, /** Non-specific failure. */ ++ EVEL_CURL_LIBRARY_FAIL, /** A cURL library operation failed. */ ++ EVEL_PTHREAD_LIBRARY_FAIL, /** A Posix threads operation failed. */ ++ EVEL_OUT_OF_MEMORY, /** A memory allocation failure occurred. */ ++ EVEL_EVENT_BUFFER_FULL, /** Too many events in the ring-buffer. */ ++ EVEL_EVENT_HANDLER_INACTIVE, /** Attempt to raise event when inactive. */ ++ EVEL_NO_METADATA, /** Failed to retrieve OpenStack metadata. */ ++ EVEL_BAD_METADATA, /** OpenStack metadata invalid format. */ ++ EVEL_BAD_JSON_FORMAT, /** JSON failed to parse correctly. */ ++ EVEL_JSON_KEY_NOT_FOUND, /** Failed to find the specified JSON key. */ ++ EVEL_MAX_ERROR_CODES /** Maximum number of valid error codes. */ ++} EVEL_ERR_CODES; ++ ++/**************************************************************************//** ++ * Logging levels ++ * ++ * Variable levels of verbosity in the logging functions. ++ *****************************************************************************/ ++typedef enum { ++ EVEL_LOG_MIN = 0, ++ EVEL_LOG_SPAMMY = 30, ++ EVEL_LOG_DEBUG = 40, ++ EVEL_LOG_INFO = 50, ++ EVEL_LOG_ERROR = 60, ++ EVEL_LOG_MAX = 101 ++} EVEL_LOG_LEVELS; ++ ++/*****************************************************************************/ ++/* Maximum string lengths. */ ++/*****************************************************************************/ ++#define EVEL_MAX_STRING_LEN 4096 ++#define EVEL_MAX_JSON_BODY 16000 ++#define EVEL_MAX_ERROR_STRING_LEN 255 ++#define EVEL_MAX_URL_LEN 511 ++ ++/**************************************************************************//** ++ * This value represents there being no restriction on the reporting interval. ++ *****************************************************************************/ ++static const int EVEL_MEASUREMENT_INTERVAL_UKNOWN = 0; ++ ++/**************************************************************************//** ++ * How many events can be backed-up before we start dropping events on the ++ * floor. ++ * ++ * @note This value should be tuned in accordance with expected burstiness of ++ * the event load and the expected response time of the ECOMP event ++ * listener so that the probability of the buffer filling is suitably ++ * low. ++ *****************************************************************************/ ++static const int EVEL_EVENT_BUFFER_DEPTH = 100; ++ ++/*****************************************************************************/ ++/* How many different IP Types-of-Service are supported. */ ++/*****************************************************************************/ ++#define EVEL_TOS_SUPPORTED 256 ++ ++/**************************************************************************//** ++ * Event domains for the various events we support. ++ * JSON equivalent field: domain ++ *****************************************************************************/ ++typedef enum { ++ EVEL_DOMAIN_INTERNAL, /** Internal event, not for external routing. */ ++ EVEL_DOMAIN_HEARTBEAT, /** A Heartbeat event (event header only). */ ++ EVEL_DOMAIN_FAULT, /** A Fault event. */ ++ EVEL_DOMAIN_MEASUREMENT, /** A Measurement for VF Scaling event. */ ++ EVEL_DOMAIN_MOBILE_FLOW, /** A Mobile Flow event. */ ++ EVEL_DOMAIN_REPORT, /** A Measurement for VF Reporting event. */ ++ EVEL_DOMAIN_SERVICE, /** A Service event. */ ++ EVEL_DOMAIN_SIGNALING, /** A Signaling event. */ ++ EVEL_DOMAIN_STATE_CHANGE, /** A State Change event. */ ++ EVEL_DOMAIN_SYSLOG, /** A Syslog event. */ ++ EVEL_DOMAIN_OTHER, /** Another event. */ ++ EVEL_MAX_DOMAINS /** Maximum number of recognized Event types. */ ++} EVEL_EVENT_DOMAINS; ++ ++/**************************************************************************//** ++ * Event priorities. ++ * JSON equivalent field: priority ++ *****************************************************************************/ ++typedef enum { ++ EVEL_PRIORITY_HIGH, ++ EVEL_PRIORITY_MEDIUM, ++ EVEL_PRIORITY_NORMAL, ++ EVEL_PRIORITY_LOW, ++ EVEL_MAX_PRIORITIES ++} EVEL_EVENT_PRIORITIES; ++ ++/**************************************************************************//** ++ * Fault / Threshold severities. ++ * JSON equivalent field: eventSeverity ++ *****************************************************************************/ ++typedef enum { ++ EVEL_SEVERITY_CRITICAL, ++ EVEL_SEVERITY_MAJOR, ++ EVEL_SEVERITY_MINOR, ++ EVEL_SEVERITY_WARNING, ++ EVEL_SEVERITY_NORMAL, ++ EVEL_MAX_SEVERITIES ++} EVEL_SEVERITIES; ++ ++/**************************************************************************//** ++ * Fault source types. ++ * JSON equivalent field: eventSourceType ++ *****************************************************************************/ ++typedef enum { ++ EVEL_SOURCE_OTHER, ++ EVEL_SOURCE_ROUTER, ++ EVEL_SOURCE_SWITCH, ++ EVEL_SOURCE_HOST, ++ EVEL_SOURCE_CARD, ++ EVEL_SOURCE_PORT, ++ EVEL_SOURCE_SLOT_THRESHOLD, ++ EVEL_SOURCE_PORT_THRESHOLD, ++ EVEL_SOURCE_VIRTUAL_MACHINE, ++ EVEL_SOURCE_VIRTUAL_NETWORK_FUNCTION, ++ /***************************************************************************/ ++ /* START OF VENDOR-SPECIFIC VALUES */ ++ /* */ ++ /* Vendor-specific values should be added here, and handled appropriately */ ++ /* in evel_event.c. */ ++ /***************************************************************************/ ++ ++ /***************************************************************************/ ++ /* END OF VENDOR-SPECIFIC VALUES */ ++ /***************************************************************************/ ++ EVEL_MAX_SOURCE_TYPES ++} EVEL_SOURCE_TYPES; ++ ++/**************************************************************************//** ++ * Fault VNF Status. ++ * JSON equivalent field: vfStatus ++ *****************************************************************************/ ++typedef enum { ++ EVEL_VF_STATUS_ACTIVE, ++ EVEL_VF_STATUS_IDLE, ++ EVEL_VF_STATUS_PREP_TERMINATE, ++ EVEL_VF_STATUS_READY_TERMINATE, ++ EVEL_VF_STATUS_REQ_TERMINATE, ++ EVEL_MAX_VF_STATUSES ++} EVEL_VF_STATUSES; ++ ++/**************************************************************************//** ++ * Counter criticalities. ++ * JSON equivalent field: criticality ++ *****************************************************************************/ ++typedef enum { ++ EVEL_COUNTER_CRITICALITY_CRIT, ++ EVEL_COUNTER_CRITICALITY_MAJ, ++ EVEL_MAX_COUNTER_CRITICALITIES ++} EVEL_COUNTER_CRITICALITIES; ++ ++/**************************************************************************//** ++ * Alert actions. ++ * JSON equivalent field: alertAction ++ *****************************************************************************/ ++typedef enum { ++ EVEL_ALERT_ACTION_CLEAR, ++ EVEL_ALERT_ACTION_CONT, ++ EVEL_ALERT_ACTION_SET, ++ EVEL_MAX_ALERT_ACTIONS ++} EVEL_ALERT_ACTIONS; ++ ++/**************************************************************************//** ++ * Alert types. ++ * JSON equivalent field: alertType ++ *****************************************************************************/ ++typedef enum { ++ EVEL_ALERT_TYPE_CARD, ++ EVEL_ALERT_TYPE_ELEMENT, ++ EVEL_ALERT_TYPE_INTERFACE, ++ EVEL_ALERT_TYPE_SERVICE, ++ EVEL_MAX_ALERT_TYPES ++} EVEL_ALERT_TYPES; ++ ++/**************************************************************************//** ++ * Alert types. ++ * JSON equivalent fields: newState, oldState ++ *****************************************************************************/ ++typedef enum { ++ EVEL_ENTITY_STATE_IN_SERVICE, ++ EVEL_ENTITY_STATE_MAINTENANCE, ++ EVEL_ENTITY_STATE_OUT_OF_SERVICE, ++ EVEL_MAX_ENTITY_STATES ++} EVEL_ENTITY_STATE; ++ ++/**************************************************************************//** ++ * Syslog facilities. ++ * JSON equivalent field: syslogFacility ++ *****************************************************************************/ ++typedef enum { ++ EVEL_SYSLOG_FACILITY_KERNEL, ++ EVEL_SYSLOG_FACILITY_USER, ++ EVEL_SYSLOG_FACILITY_MAIL, ++ EVEL_SYSLOG_FACILITY_SYSTEM_DAEMON, ++ EVEL_SYSLOG_FACILITY_SECURITY_AUTH, ++ EVEL_SYSLOG_FACILITY_INTERNAL, ++ EVEL_SYSLOG_FACILITY_LINE_PRINTER, ++ EVEL_SYSLOG_FACILITY_NETWORK_NEWS, ++ EVEL_SYSLOG_FACILITY_UUCP, ++ EVEL_SYSLOG_FACILITY_CLOCK_DAEMON, ++ EVEL_SYSLOG_FACILITY_SECURITY_AUTH2, ++ EVEL_SYSLOG_FACILITY_FTP_DAEMON, ++ EVEL_SYSLOG_FACILITY_NTP, ++ EVEL_SYSLOG_FACILITY_LOG_AUDIT, ++ EVEL_SYSLOG_FACILITY_LOG_ALERT, ++ EVEL_SYSLOG_FACILITY_CLOCK_DAEMON2, ++ EVEL_SYSLOG_FACILITY_LOCAL0, ++ EVEL_SYSLOG_FACILITY_LOCAL1, ++ EVEL_SYSLOG_FACILITY_LOCAL2, ++ EVEL_SYSLOG_FACILITY_LOCAL3, ++ EVEL_SYSLOG_FACILITY_LOCAL4, ++ EVEL_SYSLOG_FACILITY_LOCAL5, ++ EVEL_SYSLOG_FACILITY_LOCAL6, ++ EVEL_SYSLOG_FACILITY_LOCAL7, ++ EVEL_MAX_SYSLOG_FACILITIES ++} EVEL_SYSLOG_FACILITIES; ++ ++/**************************************************************************//** ++ * TCP flags. ++ * JSON equivalent fields: tcpFlagCountList, tcpFlagList ++ *****************************************************************************/ ++typedef enum { ++ EVEL_TCP_NS, ++ EVEL_TCP_CWR, ++ EVEL_TCP_ECE, ++ EVEL_TCP_URG, ++ EVEL_TCP_ACK, ++ EVEL_TCP_PSH, ++ EVEL_TCP_RST, ++ EVEL_TCP_SYN, ++ EVEL_TCP_FIN, ++ EVEL_MAX_TCP_FLAGS ++} EVEL_TCP_FLAGS; ++ ++/**************************************************************************//** ++ * Mobile QCI Classes of Service. ++ * JSON equivalent fields: mobileQciCosCountList, mobileQciCosList ++ *****************************************************************************/ ++typedef enum { ++ ++ /***************************************************************************/ ++ /* UMTS Classes of Service. */ ++ /***************************************************************************/ ++ EVEL_QCI_COS_UMTS_CONVERSATIONAL, ++ EVEL_QCI_COS_UMTS_STREAMING, ++ EVEL_QCI_COS_UMTS_INTERACTIVE, ++ EVEL_QCI_COS_UMTS_BACKGROUND, ++ ++ /***************************************************************************/ ++ /* LTE Classes of Service. */ ++ /***************************************************************************/ ++ EVEL_QCI_COS_LTE_1, ++ EVEL_QCI_COS_LTE_2, ++ EVEL_QCI_COS_LTE_3, ++ EVEL_QCI_COS_LTE_4, ++ EVEL_QCI_COS_LTE_65, ++ EVEL_QCI_COS_LTE_66, ++ EVEL_QCI_COS_LTE_5, ++ EVEL_QCI_COS_LTE_6, ++ EVEL_QCI_COS_LTE_7, ++ EVEL_QCI_COS_LTE_8, ++ EVEL_QCI_COS_LTE_9, ++ EVEL_QCI_COS_LTE_69, ++ EVEL_QCI_COS_LTE_70, ++ EVEL_MAX_QCI_COS_TYPES ++} EVEL_QCI_COS_TYPES; ++ ++/**************************************************************************//** ++ * Service Event endpoint description ++ * JSON equivalent field: endpointDesc ++ *****************************************************************************/ ++typedef enum { ++ EVEL_SERVICE_ENDPOINT_CALLEE, ++ EVEL_SERVICE_ENDPOINT_CALLER, ++ EVEL_MAX_SERVICE_ENDPOINT_DESC ++} EVEL_SERVICE_ENDPOINT_DESC; ++ ++/**************************************************************************//** ++ * Boolean type for EVEL library. ++ *****************************************************************************/ ++typedef enum { ++ EVEL_FALSE, ++ EVEL_TRUE ++} EVEL_BOOLEAN; ++ ++/**************************************************************************//** ++ * Optional parameter holder for double. ++ *****************************************************************************/ ++typedef struct evel_option_double ++{ ++ double value; ++ EVEL_BOOLEAN is_set; ++} EVEL_OPTION_DOUBLE; ++ ++/**************************************************************************//** ++ * Optional parameter holder for string. ++ *****************************************************************************/ ++typedef struct evel_option_string ++{ ++ char * value; ++ EVEL_BOOLEAN is_set; ++} EVEL_OPTION_STRING; ++ ++/**************************************************************************//** ++ * Optional parameter holder for int. ++ *****************************************************************************/ ++typedef struct evel_option_int ++{ ++ int value; ++ EVEL_BOOLEAN is_set; ++} EVEL_OPTION_INT; ++ ++/**************************************************************************//** ++ * Optional parameter holder for unsigned long long. ++ *****************************************************************************/ ++typedef struct evel_option_ull ++{ ++ unsigned long long value; ++ EVEL_BOOLEAN is_set; ++} EVEL_OPTION_ULL; ++ ++/**************************************************************************//** ++ * Optional parameter holder for time_t. ++ *****************************************************************************/ ++typedef struct evel_option_time ++{ ++ time_t value; ++ EVEL_BOOLEAN is_set; ++} EVEL_OPTION_TIME; ++ ++/*****************************************************************************/ ++/* Supported Common Event Header version. */ ++/*****************************************************************************/ ++#define EVEL_HEADER_MAJOR_VERSION 1 ++#define EVEL_HEADER_MINOR_VERSION 2 ++ ++/**************************************************************************//** ++ * Event header. ++ * JSON equivalent field: commonEventHeader ++ *****************************************************************************/ ++typedef struct event_header { ++ /***************************************************************************/ ++ /* Version */ ++ /***************************************************************************/ ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ EVEL_EVENT_DOMAINS event_domain; ++ char * event_id; ++ char * source_name; ++ char * functional_role; ++ char * reporting_entity_name; ++ EVEL_EVENT_PRIORITIES priority; ++ unsigned long long start_epoch_microsec; ++ unsigned long long last_epoch_microsec; ++ int sequence; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING event_type; ++ EVEL_OPTION_STRING source_id; ++ EVEL_OPTION_STRING reporting_entity_id; ++ ++} EVENT_HEADER; ++ ++/*****************************************************************************/ ++/* Supported Fault version. */ ++/*****************************************************************************/ ++#define EVEL_FAULT_MAJOR_VERSION 1 ++#define EVEL_FAULT_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Fault. ++ * JSON equivalent field: faultFields ++ *****************************************************************************/ ++typedef struct event_fault { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ EVEL_SEVERITIES event_severity; ++ EVEL_SOURCE_TYPES event_source_type; ++ char * alarm_condition; ++ char * specific_problem; ++ EVEL_VF_STATUSES vf_status; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING alarm_interface_a; ++ DLIST additional_info; ++ ++} EVENT_FAULT; ++ ++/**************************************************************************//** ++ * Fault Additional Info. ++ * JSON equivalent field: alarmAdditionalInformation ++ *****************************************************************************/ ++typedef struct fault_additional_info { ++ char * name; ++ char * value; ++} FAULT_ADDL_INFO; ++ ++/*****************************************************************************/ ++/* Supported Measurement version. */ ++/*****************************************************************************/ ++#define EVEL_MEASUREMENT_MAJOR_VERSION 1 ++#define EVEL_MEASUREMENT_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Errors. ++ * JSON equivalent field: errors ++ *****************************************************************************/ ++typedef struct measurement_errors { ++ int receive_discards; ++ int receive_errors; ++ int transmit_discards; ++ int transmit_errors; ++} MEASUREMENT_ERRORS; ++ ++/**************************************************************************//** ++ * Measurement. ++ * JSON equivalent field: measurementsForVfScalingFields ++ *****************************************************************************/ ++typedef struct event_measurement { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ double measurement_interval; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ DLIST additional_measurements; ++ EVEL_OPTION_DOUBLE aggregate_cpu_usage; ++ DLIST codec_usage; ++ EVEL_OPTION_INT concurrent_sessions; ++ EVEL_OPTION_INT configured_entities; ++ DLIST cpu_usage; ++ MEASUREMENT_ERRORS * errors; ++ DLIST feature_usage; ++ DLIST filesystem_usage; ++ DLIST latency_distribution; ++ EVEL_OPTION_DOUBLE mean_request_latency; ++ EVEL_OPTION_DOUBLE memory_configured; ++ EVEL_OPTION_DOUBLE memory_used; ++ EVEL_OPTION_INT media_ports_in_use; ++ EVEL_OPTION_INT request_rate; ++ EVEL_OPTION_DOUBLE vnfc_scaling_metric; ++ DLIST vnic_usage; ++ ++} EVENT_MEASUREMENT; ++ ++/**************************************************************************//** ++ * CPU Usage. ++ * JSON equivalent field: cpuUsage ++ *****************************************************************************/ ++typedef struct measurement_cpu_use { ++ char * id; ++ double usage; ++} MEASUREMENT_CPU_USE; ++ ++/**************************************************************************//** ++ * Filesystem Usage. ++ * JSON equivalent field: filesystemUsage ++ *****************************************************************************/ ++typedef struct measurement_fsys_use { ++ char * filesystem_name; ++ double block_configured; ++ int block_iops; ++ double block_used; ++ double ephemeral_configured; ++ int ephemeral_iops; ++ double ephemeral_used; ++} MEASUREMENT_FSYS_USE; ++ ++/**************************************************************************//** ++ * Latency Bucket. ++ * JSON equivalent field: latencyBucketMeasure ++ *****************************************************************************/ ++typedef struct measurement_latency_bucket { ++ int count; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_DOUBLE high_end; ++ EVEL_OPTION_DOUBLE low_end; ++ ++} MEASUREMENT_LATENCY_BUCKET; ++ ++/**************************************************************************//** ++ * Virtual NIC usage. ++ * JSON equivalent field: vNicUsage ++ *****************************************************************************/ ++typedef struct measurement_vnic_use { ++ int bytes_in; ++ int bytes_out; ++ int packets_in; ++ int packets_out; ++ char * vnic_id; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_INT broadcast_packets_in; ++ EVEL_OPTION_INT broadcast_packets_out; ++ EVEL_OPTION_INT multicast_packets_in; ++ EVEL_OPTION_INT multicast_packets_out; ++ EVEL_OPTION_INT unicast_packets_in; ++ EVEL_OPTION_INT unicast_packets_out; ++ ++} MEASUREMENT_VNIC_USE; ++ ++/**************************************************************************//** ++ * Codec Usage. ++ * JSON equivalent field: codecsInUse ++ *****************************************************************************/ ++typedef struct measurement_codec_use { ++ char * codec_id; ++ int number_in_use; ++} MEASUREMENT_CODEC_USE; ++ ++/**************************************************************************//** ++ * Feature Usage. ++ * JSON equivalent field: featuresInUse ++ *****************************************************************************/ ++typedef struct measurement_feature_use { ++ char * feature_id; ++ int feature_utilization; ++} MEASUREMENT_FEATURE_USE; ++ ++/**************************************************************************//** ++ * Measurement Group. ++ * JSON equivalent field: additionalMeasurements ++ *****************************************************************************/ ++typedef struct measurement_group { ++ char * name; ++ DLIST measurements; ++} MEASUREMENT_GROUP; ++ ++/**************************************************************************//** ++ * Custom Defined Measurement. ++ * JSON equivalent field: measurements ++ *****************************************************************************/ ++typedef struct custom_measurement { ++ char * name; ++ char * value; ++} CUSTOM_MEASUREMENT; ++ ++/*****************************************************************************/ ++/* Supported Report version. */ ++/*****************************************************************************/ ++#define EVEL_REPORT_MAJOR_VERSION 1 ++#define EVEL_REPORT_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Report. ++ * JSON equivalent field: measurementsForVfReportingFields ++ * ++ * @note This is an experimental event type and is not currently a formal part ++ * of AT&T's specification. ++ *****************************************************************************/ ++typedef struct event_report { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ double measurement_interval; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ DLIST feature_usage; ++ DLIST measurement_groups; ++ ++} EVENT_REPORT; ++ ++/**************************************************************************//** ++ * Mobile GTP Per Flow Metrics. ++ * JSON equivalent field: gtpPerFlowMetrics ++ *****************************************************************************/ ++typedef struct mobile_gtp_per_flow_metrics { ++ double avg_bit_error_rate; ++ double avg_packet_delay_variation; ++ int avg_packet_latency; ++ int avg_receive_throughput; ++ int avg_transmit_throughput; ++ int flow_activation_epoch; ++ int flow_activation_microsec; ++ int flow_deactivation_epoch; ++ int flow_deactivation_microsec; ++ time_t flow_deactivation_time; ++ char * flow_status; ++ int max_packet_delay_variation; ++ int num_activation_failures; ++ int num_bit_errors; ++ int num_bytes_received; ++ int num_bytes_transmitted; ++ int num_dropped_packets; ++ int num_l7_bytes_received; ++ int num_l7_bytes_transmitted; ++ int num_lost_packets; ++ int num_out_of_order_packets; ++ int num_packet_errors; ++ int num_packets_received_excl_retrans; ++ int num_packets_received_incl_retrans; ++ int num_packets_transmitted_incl_retrans; ++ int num_retries; ++ int num_timeouts; ++ int num_tunneled_l7_bytes_received; ++ int round_trip_time; ++ int time_to_first_byte; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_INT ip_tos_counts[EVEL_TOS_SUPPORTED]; ++ EVEL_OPTION_INT tcp_flag_counts[EVEL_MAX_TCP_FLAGS]; ++ EVEL_OPTION_INT qci_cos_counts[EVEL_MAX_QCI_COS_TYPES]; ++ EVEL_OPTION_INT dur_connection_failed_status; ++ EVEL_OPTION_INT dur_tunnel_failed_status; ++ EVEL_OPTION_STRING flow_activated_by; ++ EVEL_OPTION_TIME flow_activation_time; ++ EVEL_OPTION_STRING flow_deactivated_by; ++ EVEL_OPTION_STRING gtp_connection_status; ++ EVEL_OPTION_STRING gtp_tunnel_status; ++ EVEL_OPTION_INT large_packet_rtt; ++ EVEL_OPTION_DOUBLE large_packet_threshold; ++ EVEL_OPTION_INT max_receive_bit_rate; ++ EVEL_OPTION_INT max_transmit_bit_rate; ++ EVEL_OPTION_INT num_gtp_echo_failures; ++ EVEL_OPTION_INT num_gtp_tunnel_errors; ++ EVEL_OPTION_INT num_http_errors; ++ ++} MOBILE_GTP_PER_FLOW_METRICS; ++ ++/*****************************************************************************/ ++/* Supported Mobile Flow version. */ ++/*****************************************************************************/ ++#define EVEL_MOBILE_FLOW_MAJOR_VERSION 1 ++#define EVEL_MOBILE_FLOW_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Mobile Flow. ++ * JSON equivalent field: mobileFlow ++ *****************************************************************************/ ++typedef struct event_mobile_flow { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ char * flow_direction; ++ MOBILE_GTP_PER_FLOW_METRICS * gtp_per_flow_metrics; ++ char * ip_protocol_type; ++ char * ip_version; ++ char * other_endpoint_ip_address; ++ int other_endpoint_port; ++ char * reporting_endpoint_ip_addr; ++ int reporting_endpoint_port; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING application_type; ++ EVEL_OPTION_STRING app_protocol_type; ++ EVEL_OPTION_STRING app_protocol_version; ++ EVEL_OPTION_STRING cid; ++ EVEL_OPTION_STRING connection_type; ++ EVEL_OPTION_STRING ecgi; ++ EVEL_OPTION_STRING gtp_protocol_type; ++ EVEL_OPTION_STRING gtp_version; ++ EVEL_OPTION_STRING http_header; ++ EVEL_OPTION_STRING imei; ++ EVEL_OPTION_STRING imsi; ++ EVEL_OPTION_STRING lac; ++ EVEL_OPTION_STRING mcc; ++ EVEL_OPTION_STRING mnc; ++ EVEL_OPTION_STRING msisdn; ++ EVEL_OPTION_STRING other_functional_role; ++ EVEL_OPTION_STRING rac; ++ EVEL_OPTION_STRING radio_access_technology; ++ EVEL_OPTION_STRING sac; ++ EVEL_OPTION_INT sampling_algorithm; ++ EVEL_OPTION_STRING tac; ++ EVEL_OPTION_STRING tunnel_id; ++ EVEL_OPTION_STRING vlan_id; ++ ++} EVENT_MOBILE_FLOW; ++ ++/**************************************************************************//** ++ * Other. ++ * JSON equivalent field: otherFields ++ *****************************************************************************/ ++typedef struct event_other { ++ EVENT_HEADER header; ++ DLIST other_fields; ++ ++} EVENT_OTHER; ++ ++/**************************************************************************//** ++ * Other Field. ++ * JSON equivalent field: otherFields ++ *****************************************************************************/ ++typedef struct other_field { ++ char * name; ++ char * value; ++} OTHER_FIELD; ++ ++/**************************************************************************//** ++ * Event Instance Identifier ++ * JSON equivalent field: eventInstanceIdentifier ++ *****************************************************************************/ ++typedef struct evel_event_instance_id { ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ char * vendor_id; /* JSON: vendorId */ ++ char * event_id; /* JSON: eventId */ ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING product_id; /* JSON: productId */ ++ EVEL_OPTION_STRING subsystem_id; /* JSON: subsystemId */ ++ EVEL_OPTION_STRING event_friendly_name; /* JSON: eventFriendlyName */ ++ ++} EVEL_EVENT_INSTANCE_ID; ++ ++/*****************************************************************************/ ++/* Supported Service Events version. */ ++/*****************************************************************************/ ++#define EVEL_SERVICE_MAJOR_VERSION 1 ++#define EVEL_SERVICE_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Service Events. ++ * JSON equivalent field: serviceEventsFields ++ *****************************************************************************/ ++typedef struct event_service { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ EVEL_EVENT_INSTANCE_ID instance_id; /* JSON: eventInstanceIdentifier */ ++ ++ /***************************************************************************/ ++ /* Optional fields. */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING correlator; /* JSON: correlator */ ++ DLIST additional_fields; /* JSON: additionalFields */ ++ ++ /***************************************************************************/ ++ /* Optional fields within JSON equivalent object: codecSelected */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING codec; /* JSON: codec */ ++ ++ /***************************************************************************/ ++ /* Optional fields within JSON equivalent object: codecSelectedTranscoding */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING callee_side_codec; /* JSON: calleeSideCodec */ ++ EVEL_OPTION_STRING caller_side_codec; /* JSON: callerSideCodec */ ++ ++ /***************************************************************************/ ++ /* Optional fields within JSON equivalent object: midCallRtcp */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING rtcp_data; /* JSON: rtcpData */ ++ ++ /***************************************************************************/ ++ /* Optional fields within JSON equivalent object: endOfCallVqmSummaries */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING adjacency_name; /* JSON: adjacencyName */ ++ EVEL_OPTION_STRING endpoint_description; /* JSON: endpointDescription */ ++ EVEL_OPTION_INT endpoint_jitter; /* JSON: endpointJitter */ ++ EVEL_OPTION_INT endpoint_rtp_oct_disc; /* JSON: endpointRtpOctetsDiscarded */ ++ EVEL_OPTION_INT endpoint_rtp_oct_recv; /* JSON: endpointRtpOctetsReceived */ ++ EVEL_OPTION_INT endpoint_rtp_oct_sent; /* JSON: endpointRtpOctetsSent */ ++ EVEL_OPTION_INT endpoint_rtp_pkt_disc;/* JSON: endpointRtpPacketsDiscarded */ ++ EVEL_OPTION_INT endpoint_rtp_pkt_recv; /* JSON: endpointRtpPacketsReceived */ ++ EVEL_OPTION_INT endpoint_rtp_pkt_sent; /* JSON: endpointRtpPacketsSent */ ++ EVEL_OPTION_INT local_jitter; /* JSON: localJitter */ ++ EVEL_OPTION_INT local_rtp_oct_disc; /* JSON: localRtpOctetsDiscarded */ ++ EVEL_OPTION_INT local_rtp_oct_recv; /* JSON: localRtpOctetsReceived */ ++ EVEL_OPTION_INT local_rtp_oct_sent; /* JSON: localRtpOctetsSent */ ++ EVEL_OPTION_INT local_rtp_pkt_disc; /* JSON: localRtpPacketsDiscarded */ ++ EVEL_OPTION_INT local_rtp_pkt_recv; /* JSON: localRtpPacketsReceived */ ++ EVEL_OPTION_INT local_rtp_pkt_sent; /* JSON: localRtpPacketsSent */ ++ EVEL_OPTION_DOUBLE mos_cqe; /* JSON: mosCqe */ ++ EVEL_OPTION_INT packets_lost; /* JSON: packetsLost */ ++ EVEL_OPTION_DOUBLE packet_loss_percent; /* JSON: packetLossPercent */ ++ EVEL_OPTION_INT r_factor; /* JSON: rFactor */ ++ EVEL_OPTION_INT round_trip_delay; /* JSON: roundTripDelay */ ++ ++ /***************************************************************************/ ++ /* Optional fields within JSON equivalent object: marker */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING phone_number; /* JSON: phoneNumber */ ++ ++} EVENT_SERVICE; ++ ++/*****************************************************************************/ ++/* Supported Signaling version. */ ++/*****************************************************************************/ ++#define EVEL_SIGNALING_MAJOR_VERSION 1 ++#define EVEL_SIGNALING_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Signaling. ++ * JSON equivalent field: signalingFields ++ *****************************************************************************/ ++typedef struct event_signaling { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ EVEL_EVENT_INSTANCE_ID instance_id; /* JSON: eventInstanceIdentifier */ ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ EVEL_OPTION_STRING correlator; /* JSON: correlator */ ++ EVEL_OPTION_STRING local_ip_address; /* JSON: localIpAddress */ ++ EVEL_OPTION_STRING local_port; /* JSON: localPort */ ++ EVEL_OPTION_STRING remote_ip_address; /* JSON: remoteIpAddress */ ++ EVEL_OPTION_STRING remote_port; /* JSON: remotePort */ ++ EVEL_OPTION_STRING compressed_sip; /* JSON: compressedSip */ ++ EVEL_OPTION_STRING summary_sip; /* JSON: summarySip */ ++ ++} EVENT_SIGNALING; ++ ++/*****************************************************************************/ ++/* Supported State Change version. */ ++/*****************************************************************************/ ++#define EVEL_STATE_CHANGE_MAJOR_VERSION 1 ++#define EVEL_STATE_CHANGE_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * State Change. ++ * JSON equivalent field: stateChangeFields ++ *****************************************************************************/ ++typedef struct event_state_change { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ EVEL_ENTITY_STATE new_state; ++ EVEL_ENTITY_STATE old_state; ++ char * state_interface; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ DLIST additional_fields; ++ ++} EVENT_STATE_CHANGE; ++ ++/**************************************************************************//** ++ * State Change Additional Field. ++ * JSON equivalent field: additionalFields ++ *****************************************************************************/ ++typedef struct state_change_additional_field { ++ char * name; ++ char * value; ++} STATE_CHANGE_ADDL_FIELD; ++ ++/*****************************************************************************/ ++/* Supported Syslog version. */ ++/*****************************************************************************/ ++#define EVEL_SYSLOG_MAJOR_VERSION 1 ++#define EVEL_SYSLOG_MINOR_VERSION 1 ++ ++/**************************************************************************//** ++ * Syslog. ++ * JSON equivalent field: syslogFields ++ *****************************************************************************/ ++typedef struct event_syslog { ++ /***************************************************************************/ ++ /* Header and version */ ++ /***************************************************************************/ ++ EVENT_HEADER header; ++ int major_version; ++ int minor_version; ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /***************************************************************************/ ++ EVEL_SOURCE_TYPES event_source_type; ++ char * syslog_msg; ++ char * syslog_tag; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /***************************************************************************/ ++ DLIST additional_fields; ++ EVEL_OPTION_STRING event_source_host; ++ EVEL_OPTION_INT syslog_facility; ++ EVEL_OPTION_STRING syslog_proc; ++ EVEL_OPTION_INT syslog_proc_id; ++ EVEL_OPTION_STRING syslog_s_data; ++ EVEL_OPTION_INT syslog_ver; ++ ++} EVENT_SYSLOG; ++ ++/**************************************************************************//** ++ * Syslog Additional Field. ++ * JSON equivalent field: additionalFields ++ *****************************************************************************/ ++typedef struct syslog_additional_field { ++ char * name; ++ char * value; ++} SYSLOG_ADDL_FIELD; ++ ++/**************************************************************************//** ++ * Copyright. ++ * JSON equivalent object: attCopyrightNotice ++ *****************************************************************************/ ++typedef struct copyright { ++ char * useAndRedistribution; ++ char * condition1; ++ char * condition2; ++ char * condition3; ++ char * condition4; ++ char * disclaimerLine1; ++ char * disclaimerLine2; ++ char * disclaimerLine3; ++ char * disclaimerLine4; ++} COPYRIGHT; ++ ++/**************************************************************************//** ++ * Library initialization. ++ * ++ * Initialize the EVEL library. ++ * ++ * @note This function initializes the cURL library. Applications making use ++ * of libcurl may need to pull the initialization out of here. Note ++ * also that this function is not threadsafe as a result - refer to ++ * libcurl's API documentation for relevant warnings. ++ * ++ * @sa Matching Term function. ++ * ++ * @param fqdn The API's FQDN or IP address. ++ * @param port The API's port. ++ * @param path The optional path (may be NULL). ++ * @param topic The optional topic part of the URL (may be NULL). ++ * @param secure Whether to use HTTPS (0=HTTP, 1=HTTPS). ++ * @param username Username for Basic Authentication of requests. ++ * @param password Password for Basic Authentication of requests. ++ * @param source_type The kind of node we represent. ++ * @param role The role this node undertakes. ++ * @param verbosity 0 for normal operation, positive values for chattier ++ * logs. ++ * ++ * @returns Status code ++ * @retval EVEL_SUCCESS On success ++ * @retval ::EVEL_ERR_CODES On failure. ++ *****************************************************************************/ ++EVEL_ERR_CODES evel_initialize(const char * const fqdn, ++ int port, ++ const char * const path, ++ const char * const topic, ++ int secure, ++ const char * const username, ++ const char * const password, ++ EVEL_SOURCE_TYPES source_type, ++ const char * const role, ++ int verbosity ++ ); ++ ++/**************************************************************************//** ++ * Clean up the EVEL library. ++ * ++ * @note that at present don't expect Init/Term cycling not to leak memory! ++ * ++ * @returns Status code ++ * @retval EVEL_SUCCESS On success ++ * @retval "One of ::EVEL_ERR_CODES" On failure. ++ *****************************************************************************/ ++EVEL_ERR_CODES evel_terminate(void); ++ ++EVEL_ERR_CODES evel_post_event(EVENT_HEADER * event); ++const char * evel_error_string(void); ++ ++ ++/**************************************************************************//** ++ * Free an event. ++ * ++ * Free off the event supplied. Will free all the contained allocated memory. ++ * ++ * @note It is safe to free a NULL pointer. ++ *****************************************************************************/ ++void evel_free_event(void * event); ++ ++/**************************************************************************//** ++ * Encode the event as a JSON event object according to AT&T's schema. ++ * ++ * @param json Pointer to where to store the JSON encoded data. ++ * @param max_size Size of storage available in json_body. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ * @returns Number of bytes actually written. ++ *****************************************************************************/ ++int evel_json_encode_event(char * json, ++ int max_size, ++ EVENT_HEADER * event); ++ ++/**************************************************************************//** ++ * Callback function to provide returned data. ++ * ++ * Copy data into the supplied buffer, write_callback::ptr, checking size ++ * limits. ++ * ++ * @returns Number of bytes placed into write_callback::ptr. 0 for EOF. ++ *****************************************************************************/ ++size_t evel_write_callback(void *contents, ++ size_t size, ++ size_t nmemb, ++ void *userp); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* HEARTBEAT - (includes common header, too) */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new heartbeat event. ++ * ++ * @note that the heartbeat is just a "naked" commonEventHeader! ++ * ++ * @returns pointer to the newly manufactured ::EVENT_HEADER. If the event is ++ * not used it must be released using ::evel_free_event ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_HEADER * evel_new_heartbeat(void); ++ ++/**************************************************************************//** ++ * Free an event header. ++ * ++ * Free off the event header supplied. Will free all the contained allocated ++ * memory. ++ * ++ * @note It does not free the header itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_header(EVENT_HEADER * const event); ++ ++/**************************************************************************//** ++ * Initialize a newly created event header. ++ * ++ * @param header Pointer to the header being initialized. ++ *****************************************************************************/ ++void evel_init_header(EVENT_HEADER * const header); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the event header. ++ * ++ * @param header Pointer to the ::EVENT_HEADER. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_header_type_set(EVENT_HEADER * const header, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Start Epoch property of the event header. ++ * ++ * @note The Start Epoch defaults to the time of event creation. ++ * ++ * @param header Pointer to the ::EVENT_HEADER. ++ * @param start_epoch_microsec ++ * The start epoch to set, in microseconds. ++ *****************************************************************************/ ++void evel_start_epoch_set(EVENT_HEADER * const header, ++ const unsigned long long start_epoch_microsec); ++ ++/**************************************************************************//** ++ * Set the Last Epoch property of the event header. ++ * ++ * @note The Last Epoch defaults to the time of event creation. ++ * ++ * @param header Pointer to the ::EVENT_HEADER. ++ * @param last_epoch_microsec ++ * The last epoch to set, in microseconds. ++ *****************************************************************************/ ++void evel_last_epoch_set(EVENT_HEADER * const header, ++ const unsigned long long last_epoch_microsec); ++ ++/**************************************************************************//** ++ * Set the Reporting Entity Name property of the event header. ++ * ++ * @note The Reporting Entity Name defaults to the OpenStack VM Name. ++ * ++ * @param header Pointer to the ::EVENT_HEADER. ++ * @param entity_name The entity name to set. ++ *****************************************************************************/ ++void evel_reporting_entity_name_set(EVENT_HEADER * const header, ++ const char * const entity_name); ++ ++/**************************************************************************//** ++ * Set the Reporting Entity Id property of the event header. ++ * ++ * @note The Reporting Entity Id defaults to the OpenStack VM UUID. ++ * ++ * @param header Pointer to the ::EVENT_HEADER. ++ * @param entity_id The entity id to set. ++ *****************************************************************************/ ++void evel_reporting_entity_id_set(EVENT_HEADER * const header, ++ const char * const entity_id); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* FAULT */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new fault event. ++ * ++ * ++ * @returns pointer to the newly manufactured ::EVENT_FAULT. If the event is ++ * not used it must be released using ::evel_free_fault ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_FAULT * evel_new_fault(const char * const condition, ++ const char * const specific_problem, ++ EVEL_EVENT_PRIORITIES priority, ++ EVEL_SEVERITIES severity); ++ ++/**************************************************************************//** ++ * Free a Fault. ++ * ++ * Free off the Fault supplied. Will free all the contained allocated memory. ++ * ++ * @note It does not free the Fault itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_fault(EVENT_FAULT * event); ++ ++ ++/**************************************************************************//** ++ * Set the Alarm Interface A property of the Fault. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param fault Pointer to the fault. ++ * @param interface The Alarm Interface A to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_fault_interface_set(EVENT_FAULT * fault, ++ const char * const interface); ++ ++/**************************************************************************//** ++ * Add an additional value name/value pair to the Fault. ++ * ++ * The name and value are null delimited ASCII strings. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param fault Pointer to the fault. ++ * @param name ASCIIZ string with the attribute's name. ++ * @param value ASCIIZ string with the attribute's value. ++ *****************************************************************************/ ++void evel_fault_addl_info_add(EVENT_FAULT * fault, char * name, char * value); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Fault. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param fault Pointer to the fault. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_fault_type_set(EVENT_FAULT * fault, const char * const type); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* MEASUREMENT */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new Measurement event. ++ * ++ * @note The mandatory fields on the Measurement must be supplied to this ++ * factory function and are immutable once set. Optional fields have ++ * explicit setter functions, but again values may only be set once so ++ * that the Measurement has immutable properties. ++ * ++ * @param measurement_interval ++ * ++ * @returns pointer to the newly manufactured ::EVENT_MEASUREMENT. If the ++ * event is not used (i.e. posted) it must be released using ++ * ::evel_free_event. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_MEASUREMENT * evel_new_measurement(double measurement_interval); ++ ++/**************************************************************************//** ++ * Free a Measurement. ++ * ++ * Free off the Measurement supplied. Will free all the contained allocated ++ * memory. ++ * ++ * @note It does not free the Measurement itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_measurement(EVENT_MEASUREMENT * event); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_measurement_type_set(EVENT_MEASUREMENT * measurement, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Concurrent Sessions property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param concurrent_sessions The Concurrent Sessions to be set. ++ *****************************************************************************/ ++void evel_measurement_conc_sess_set(EVENT_MEASUREMENT * measurement, ++ int concurrent_sessions); ++ ++/**************************************************************************//** ++ * Set the Configured Entities property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param configured_entities The Configured Entities to be set. ++ *****************************************************************************/ ++void evel_measurement_cfg_ents_set(EVENT_MEASUREMENT * measurement, ++ int configured_entities); ++ ++/**************************************************************************//** ++ * Add an additional set of Errors to the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param receive_discards The number of receive discards. ++ * @param receive_errors The number of receive errors. ++ * @param transmit_discards The number of transmit discards. ++ * @param transmit_errors The number of transmit errors. ++ *****************************************************************************/ ++void evel_measurement_errors_set(EVENT_MEASUREMENT * measurement, ++ int receive_discards, ++ int receive_errors, ++ int transmit_discards, ++ int transmit_errors); ++ ++/**************************************************************************//** ++ * Set the Mean Request Latency property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param mean_request_latency The Mean Request Latency to be set. ++ *****************************************************************************/ ++void evel_measurement_mean_req_lat_set(EVENT_MEASUREMENT * measurement, ++ double mean_request_latency); ++ ++/**************************************************************************//** ++ * Set the Memory Configured property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param memory_configured The Memory Configured to be set. ++ *****************************************************************************/ ++void evel_measurement_mem_cfg_set(EVENT_MEASUREMENT * measurement, ++ double memory_configured); ++ ++/**************************************************************************//** ++ * Set the Memory Used property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param memory_used The Memory Used to be set. ++ *****************************************************************************/ ++void evel_measurement_mem_used_set(EVENT_MEASUREMENT * measurement, ++ double memory_used); ++ ++/**************************************************************************//** ++ * Set the Request Rate property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param request_rate The Request Rate to be set. ++ *****************************************************************************/ ++void evel_measurement_request_rate_set(EVENT_MEASUREMENT * measurement, ++ int request_rate); ++ ++/**************************************************************************//** ++ * Add an additional CPU usage value name/value pair to the Measurement. ++ * ++ * The name and value are null delimited ASCII strings. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param id ASCIIZ string with the CPU's identifier. ++ * @param usage CPU utilization. ++ *****************************************************************************/ ++void evel_measurement_cpu_use_add(EVENT_MEASUREMENT * measurement, ++ char * id, double usage); ++ ++/**************************************************************************//** ++ * Add an additional File System usage value name/value pair to the ++ * Measurement. ++ * ++ * The filesystem_name is null delimited ASCII string. The library takes a ++ * copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param filesystem_name ASCIIZ string with the file-system's UUID. ++ * @param block_configured Block storage configured. ++ * @param block_used Block storage in use. ++ * @param block_iops Block storage IOPS. ++ * @param ephemeral_configured Ephemeral storage configured. ++ * @param ephemeral_used Ephemeral storage in use. ++ * @param ephemeral_iops Ephemeral storage IOPS. ++ *****************************************************************************/ ++void evel_measurement_fsys_use_add(EVENT_MEASUREMENT * measurement, ++ char * filesystem_name, ++ double block_configured, ++ double block_used, ++ int block_iops, ++ double ephemeral_configured, ++ double ephemeral_used, ++ int ephemeral_iops); ++ ++/**************************************************************************//** ++ * Add a Feature usage value name/value pair to the Measurement. ++ * ++ * The name is null delimited ASCII string. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param feature ASCIIZ string with the feature's name. ++ * @param utilization Utilization of the feature. ++ *****************************************************************************/ ++void evel_measurement_feature_use_add(EVENT_MEASUREMENT * measurement, ++ char * feature, ++ int utilization); ++ ++/**************************************************************************//** ++ * Add a Additional Measurement value name/value pair to the Measurement. ++ * ++ * The name is null delimited ASCII string. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param measurement Pointer to the Measurement. ++ * @param group ASCIIZ string with the measurement group's name. ++ * @param name ASCIIZ string containing the measurement's name. ++ * @param name ASCIIZ string containing the measurement's value. ++ *****************************************************************************/ ++void evel_measurement_custom_measurement_add(EVENT_MEASUREMENT * measurement, ++ const char * const group, ++ const char * const name, ++ const char * const value); ++ ++/**************************************************************************//** ++ * Add a Codec usage value name/value pair to the Measurement. ++ * ++ * The name is null delimited ASCII string. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param codec ASCIIZ string with the codec's name. ++ * @param utilization Utilization of the feature. ++ *****************************************************************************/ ++void evel_measurement_codec_use_add(EVENT_MEASUREMENT * measurement, ++ char * codec, ++ int utilization); ++ ++/**************************************************************************//** ++} ++ * Set the Aggregate CPU Use property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param cpu_use The CPU use to set. ++ *****************************************************************************/ ++void evel_measurement_agg_cpu_use_set(EVENT_MEASUREMENT * measurement, ++ double cpu_use); ++ ++/**************************************************************************//** ++ * Set the Media Ports in Use property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param media_ports_in_use The media port usage to set. ++ *****************************************************************************/ ++void evel_measurement_media_port_use_set(EVENT_MEASUREMENT * measurement, ++ int media_ports_in_use); ++ ++/**************************************************************************//** ++ * Set the VNFC Scaling Metric property of the Measurement. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param scaling_metric The scaling metric to set. ++ *****************************************************************************/ ++void evel_measurement_vnfc_scaling_metric_set(EVENT_MEASUREMENT * measurement, ++ double scaling_metric); ++ ++/**************************************************************************//** ++ * Create a new Latency Bucket to be added to a Measurement event. ++ * ++ * @note The mandatory fields on the ::MEASUREMENT_LATENCY_BUCKET must be ++ * supplied to this factory function and are immutable once set. ++ * Optional fields have explicit setter functions, but again values ++ * may only be set once so that the ::MEASUREMENT_LATENCY_BUCKET has ++ * immutable properties. ++ * ++ * @param count Count of events in this bucket. ++ * ++ * @returns pointer to the newly manufactured ::MEASUREMENT_LATENCY_BUCKET. ++ * @retval NULL Failed to create the Latency Bucket. ++ *****************************************************************************/ ++MEASUREMENT_LATENCY_BUCKET * evel_new_meas_latency_bucket(const int count); ++ ++/**************************************************************************//** ++ * Set the High End property of the Measurement Latency Bucket. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param bucket Pointer to the Measurement Latency Bucket. ++ * @param high_end High end of the bucket's range. ++ *****************************************************************************/ ++void evel_meas_latency_bucket_high_end_set( ++ MEASUREMENT_LATENCY_BUCKET * const bucket, ++ const double high_end); ++ ++/**************************************************************************//** ++ * Set the Low End property of the Measurement Latency Bucket. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param bucket Pointer to the Measurement Latency Bucket. ++ * @param low_end Low end of the bucket's range. ++ *****************************************************************************/ ++void evel_meas_latency_bucket_low_end_set( ++ MEASUREMENT_LATENCY_BUCKET * const bucket, ++ const double low_end); ++ ++/**************************************************************************//** ++ * Add an additional Measurement Latency Bucket to the specified event. ++ * ++ * @param measurement Pointer to the Measurement event. ++ * @param bucket Pointer to the Measurement Latency Bucket to add. ++ *****************************************************************************/ ++void evel_meas_latency_bucket_add(EVENT_MEASUREMENT * const measurement, ++ MEASUREMENT_LATENCY_BUCKET * const bucket); ++ ++/**************************************************************************//** ++ * Add an additional Latency Distribution bucket to the Measurement. ++ * ++ * This function implements the previous API, purely for convenience. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param low_end Low end of the bucket's range. ++ * @param high_end High end of the bucket's range. ++ * @param count Count of events in this bucket. ++ *****************************************************************************/ ++void evel_measurement_latency_add(EVENT_MEASUREMENT * const measurement, ++ const double low_end, ++ const double high_end, ++ const int count); ++ ++/**************************************************************************//** ++ * Create a new vNIC Use to be added to a Measurement event. ++ * ++ * @note The mandatory fields on the ::MEASUREMENT_VNIC_USE must be supplied ++ * to this factory function and are immutable once set. Optional ++ * fields have explicit setter functions, but again values may only be ++ * set once so that the ::MEASUREMENT_VNIC_USE has immutable ++ * properties. ++ * ++ * @param vnic_id ASCIIZ string with the vNIC's ID. ++ * @param packets_in Total packets received. ++ * @param packets_out Total packets transmitted. ++ * @param bytes_in Total bytes received. ++ * @param bytes_out Total bytes transmitted. ++ * ++ * @returns pointer to the newly manufactured ::MEASUREMENT_VNIC_USE. ++ * If the structure is not used it must be released using ++ * ::evel_free_measurement_vnic_use. ++ * @retval NULL Failed to create the vNIC Use. ++ *****************************************************************************/ ++MEASUREMENT_VNIC_USE * evel_new_measurement_vnic_use(char * const vnic_id, ++ const int packets_in, ++ const int packets_out, ++ const int bytes_in, ++ const int bytes_out); ++ ++/**************************************************************************//** ++ * Free a vNIC Use. ++ * ++ * Free off the ::MEASUREMENT_VNIC_USE supplied. Will free all the contained ++ * allocated memory. ++ * ++ * @note It does not free the vNIC Use itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_measurement_vnic_use(MEASUREMENT_VNIC_USE * const vnic_use); ++ ++/**************************************************************************//** ++ * Set the Broadcast Packets Received property of the vNIC Use. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param vnic_use Pointer to the vNIC Use. ++ * @param broadcast_packets_in ++ * Broadcast packets received. ++ *****************************************************************************/ ++void evel_vnic_use_bcast_pkt_in_set(MEASUREMENT_VNIC_USE * const vnic_use, ++ const int broadcast_packets_in); ++ ++/**************************************************************************//** ++ * Set the Broadcast Packets Transmitted property of the vNIC Use. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param vnic_use Pointer to the vNIC Use. ++ * @param broadcast_packets_out ++ * Broadcast packets transmitted. ++ *****************************************************************************/ ++void evel_vnic_use_bcast_pkt_out_set(MEASUREMENT_VNIC_USE * const vnic_use, ++ const int broadcast_packets_out); ++ ++/**************************************************************************//** ++ * Set the Multicast Packets Received property of the vNIC Use. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param vnic_use Pointer to the vNIC Use. ++ * @param multicast_packets_in ++ * Multicast packets received. ++ *****************************************************************************/ ++void evel_vnic_use_mcast_pkt_in_set(MEASUREMENT_VNIC_USE * const vnic_use, ++ const int multicast_packets_in); ++ ++/**************************************************************************//** ++ * Set the Multicast Packets Transmitted property of the vNIC Use. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param vnic_use Pointer to the vNIC Use. ++ * @param multicast_packets_out ++ * Multicast packets transmitted. ++ *****************************************************************************/ ++void evel_vnic_use_mcast_pkt_out_set(MEASUREMENT_VNIC_USE * const vnic_use, ++ const int multicast_packets_out); ++ ++/**************************************************************************//** ++ * Set the Unicast Packets Received property of the vNIC Use. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param vnic_use Pointer to the vNIC Use. ++ * @param unicast_packets_in ++ * Unicast packets received. ++ *****************************************************************************/ ++void evel_vnic_use_ucast_pkt_in_set(MEASUREMENT_VNIC_USE * const vnic_use, ++ const int unicast_packets_in); ++ ++/**************************************************************************//** ++ * Set the Unicast Packets Transmitted property of the vNIC Use. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param vnic_use Pointer to the vNIC Use. ++ * @param unicast_packets_out ++ * Unicast packets transmitted. ++ *****************************************************************************/ ++void evel_vnic_use_ucast_pkt_out_set(MEASUREMENT_VNIC_USE * const vnic_use, ++ const int unicast_packets_out); ++ ++/**************************************************************************//** ++ * Add an additional vNIC Use to the specified Measurement event. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param vnic_use Pointer to the vNIC Use to add. ++ *****************************************************************************/ ++void evel_meas_vnic_use_add(EVENT_MEASUREMENT * const measurement, ++ MEASUREMENT_VNIC_USE * const vnic_use); ++ ++/**************************************************************************//** ++ * Add an additional vNIC usage record Measurement. ++ * ++ * This function implements the previous API, purely for convenience. ++ * ++ * The ID is null delimited ASCII string. The library takes a copy so the ++ * caller does not have to preserve values after the function returns. ++ * ++ * @param measurement Pointer to the measurement. ++ * @param vnic_id ASCIIZ string with the vNIC's ID. ++ * @param packets_in Total packets received. ++ * @param packets_out Total packets transmitted. ++ * @param broadcast_packets_in Broadcast packets received. ++ * @param broadcast_packets_out Broadcast packets transmitted. ++ * @param bytes_in Total bytes received. ++ * @param bytes_out Total bytes transmitted. ++ * @param multicast_packets_in Multicast packets received. ++ * @param multicast_packets_out Multicast packets transmitted. ++ * @param unicast_packets_in Unicast packets received. ++ * @param unicast_packets_out Unicast packets transmitted. ++ *****************************************************************************/ ++void evel_measurement_vnic_use_add(EVENT_MEASUREMENT * const measurement, ++ char * const vnic_id, ++ const int packets_in, ++ const int packets_out, ++ const int broadcast_packets_in, ++ const int broadcast_packets_out, ++ const int bytes_in, ++ const int bytes_out, ++ const int multicast_packets_in, ++ const int multicast_packets_out, ++ const int unicast_packets_in, ++ const int unicast_packets_out); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* REPORT */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new Report event. ++ * ++ * @note The mandatory fields on the Report must be supplied to this ++ * factory function and are immutable once set. Optional fields have ++ * explicit setter functions, but again values may only be set once so ++ * that the Report has immutable properties. ++ * ++ * @param measurement_interval ++ * ++ * @returns pointer to the newly manufactured ::EVENT_REPORT. If the event is ++ * not used (i.e. posted) it must be released using ++ * ::evel_free_report. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_REPORT * evel_new_report(double measurement_interval); ++ ++/**************************************************************************//** ++ * Free a Report. ++ * ++ * Free off the Report supplied. Will free all the contained allocated memory. ++ * ++ * @note It does not free the Report itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_report(EVENT_REPORT * event); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Report. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param report Pointer to the Report. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_report_type_set(EVENT_REPORT * report, const char * const type); ++ ++/**************************************************************************//** ++ * Add a Feature usage value name/value pair to the Report. ++ * ++ * The name is null delimited ASCII string. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param report Pointer to the report. ++ * @param feature ASCIIZ string with the feature's name. ++ * @param utilization Utilization of the feature. ++ *****************************************************************************/ ++void evel_report_feature_use_add(EVENT_REPORT * report, ++ char * feature, ++ int utilization); ++ ++/**************************************************************************//** ++ * Add a Additional Measurement value name/value pair to the Report. ++ * ++ * The name is null delimited ASCII string. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param report Pointer to the report. ++ * @param group ASCIIZ string with the measurement group's name. ++ * @param name ASCIIZ string containing the measurement's name. ++ * @param value ASCIIZ string containing the measurement's value. ++ *****************************************************************************/ ++void evel_report_custom_measurement_add(EVENT_REPORT * report, ++ const char * const group, ++ const char * const name, ++ const char * const value); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* MOBILE_FLOW */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new Mobile Flow event. ++ * ++ * @note The mandatory fields on the Mobile Flow must be supplied to this ++ * factory function and are immutable once set. Optional fields have ++ * explicit setter functions, but again values may only be set once so ++ * that the Mobile Flow has immutable properties. ++ * ++ * @param flow_direction ++ * @param gtp_per_flow_metrics ++ * @param ip_protocol_type ++ * @param ip_version ++ * @param other_endpoint_ip_address ++ * @param other_endpoint_port ++ * @param reporting_endpoint_ip_addr ++ * @param reporting_endpoint_port ++ * ++ * @returns pointer to the newly manufactured ::EVENT_MOBILE_FLOW. If the ++ * event is not used (i.e. posted) it must be released using ++ * ::evel_free_mobile_flow. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_MOBILE_FLOW * evel_new_mobile_flow( ++ const char * const flow_direction, ++ MOBILE_GTP_PER_FLOW_METRICS * gtp_per_flow_metrics, ++ const char * const ip_protocol_type, ++ const char * const ip_version, ++ const char * const other_endpoint_ip_address, ++ int other_endpoint_port, ++ const char * const reporting_endpoint_ip_addr, ++ int reporting_endpoint_port); ++ ++/**************************************************************************//** ++ * Free a Mobile Flow. ++ * ++ * Free off the Mobile Flow supplied. Will free all the contained allocated ++ * memory. ++ * ++ * @note It does not free the Mobile Flow itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_mobile_flow(EVENT_MOBILE_FLOW * event); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_mobile_flow_type_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Application Type property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param type The Application Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_mobile_flow_app_type_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Application Protocol Type property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param type The Application Protocol Type to be set. ASCIIZ string. ++ * The caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_app_prot_type_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Application Protocol Version property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param version The Application Protocol Version to be set. ASCIIZ ++ * string. The caller does not need to preserve the value ++ * once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_app_prot_ver_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const version); ++ ++/**************************************************************************//** ++ * Set the CID property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param cid The CID to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_cid_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const cid); ++ ++/**************************************************************************//** ++ * Set the Connection Type property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param type The Connection Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_mobile_flow_con_type_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the ECGI property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param ecgi The ECGI to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_ecgi_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const ecgi); ++ ++/**************************************************************************//** ++ * Set the GTP Protocol Type property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param type The GTP Protocol Type to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_gtp_prot_type_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the GTP Protocol Version property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param version The GTP Protocol Version to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_gtp_prot_ver_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const version); ++ ++/**************************************************************************//** ++ * Set the HTTP Header property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param header The HTTP header to be set. ASCIIZ string. The caller does ++ * not need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_http_header_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const header); ++ ++/**************************************************************************//** ++ * Set the IMEI property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param imei The IMEI to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_imei_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const imei); ++ ++/**************************************************************************//** ++ * Set the IMSI property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param imsi The IMSI to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_imsi_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const imsi); ++ ++/**************************************************************************//** ++ * Set the LAC property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param lac The LAC to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_lac_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const lac); ++ ++/**************************************************************************//** ++ * Set the MCC property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param mcc The MCC to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_mcc_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const mcc); ++ ++/**************************************************************************//** ++ * Set the MNC property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param mnc The MNC to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_mnc_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const mnc); ++ ++/**************************************************************************//** ++ * Set the MSISDN property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param msisdn The MSISDN to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_msisdn_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const msisdn); ++ ++/**************************************************************************//** ++ * Set the Other Functional Role property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param role The Other Functional Role to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_other_func_role_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const role); ++ ++/**************************************************************************//** ++ * Set the RAC property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param rac The RAC to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_rac_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const rac); ++ ++/**************************************************************************//** ++ * Set the Radio Access Technology property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param tech The Radio Access Technology to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_radio_acc_tech_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const tech); ++ ++/**************************************************************************//** ++ * Set the SAC property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param sac The SAC to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_sac_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const sac); ++ ++/**************************************************************************//** ++ * Set the Sampling Algorithm property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param algorithm The Sampling Algorithm to be set. ++ *****************************************************************************/ ++void evel_mobile_flow_samp_alg_set(EVENT_MOBILE_FLOW * mobile_flow, ++ int algorithm); ++ ++/**************************************************************************//** ++ * Set the TAC property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param tac The TAC to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_tac_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const tac); ++ ++/**************************************************************************//** ++ * Set the Tunnel ID property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param tunnel_id The Tunnel ID to be set. ASCIIZ string. The caller does ++ * not need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_tunnel_id_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const tunnel_id); ++ ++/**************************************************************************//** ++ * Set the VLAN ID property of the Mobile Flow. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param mobile_flow Pointer to the Mobile Flow. ++ * @param vlan_id The VLAN ID to be set. ASCIIZ string. The caller does ++ * not need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_mobile_flow_vlan_id_set(EVENT_MOBILE_FLOW * mobile_flow, ++ const char * const vlan_id); ++ ++/**************************************************************************//** ++ * Create a new Mobile GTP Per Flow Metrics. ++ * ++ * @note The mandatory fields on the Mobile GTP Per Flow Metrics must be ++ * supplied to this factory function and are immutable once set. ++ * Optional fields have explicit setter functions, but again values ++ * may only be set once so that the Mobile GTP Per Flow Metrics has ++ * immutable properties. ++ * ++ * @param avg_bit_error_rate ++ * @param avg_packet_delay_variation ++ * @param avg_packet_latency ++ * @param avg_receive_throughput ++ * @param avg_transmit_throughput ++ * @param flow_activation_epoch ++ * @param flow_activation_microsec ++ * @param flow_deactivation_epoch ++ * @param flow_deactivation_microsec ++ * @param flow_deactivation_time ++ * @param flow_status ++ * @param max_packet_delay_variation ++ * @param num_activation_failures ++ * @param num_bit_errors ++ * @param num_bytes_received ++ * @param num_bytes_transmitted ++ * @param num_dropped_packets ++ * @param num_l7_bytes_received ++ * @param num_l7_bytes_transmitted ++ * @param num_lost_packets ++ * @param num_out_of_order_packets ++ * @param num_packet_errors ++ * @param num_packets_received_excl_retrans ++ * @param num_packets_received_incl_retrans ++ * @param num_packets_transmitted_incl_retrans ++ * @param num_retries ++ * @param num_timeouts ++ * @param num_tunneled_l7_bytes_received ++ * @param round_trip_time ++ * @param time_to_first_byte ++ * ++ * @returns pointer to the newly manufactured ::MOBILE_GTP_PER_FLOW_METRICS. ++ * If the structure is not used it must be released using ++ * ::evel_free_mobile_gtp_flow_metrics. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++MOBILE_GTP_PER_FLOW_METRICS * evel_new_mobile_gtp_flow_metrics( ++ double avg_bit_error_rate, ++ double avg_packet_delay_variation, ++ int avg_packet_latency, ++ int avg_receive_throughput, ++ int avg_transmit_throughput, ++ int flow_activation_epoch, ++ int flow_activation_microsec, ++ int flow_deactivation_epoch, ++ int flow_deactivation_microsec, ++ time_t flow_deactivation_time, ++ const char * const flow_status, ++ int max_packet_delay_variation, ++ int num_activation_failures, ++ int num_bit_errors, ++ int num_bytes_received, ++ int num_bytes_transmitted, ++ int num_dropped_packets, ++ int num_l7_bytes_received, ++ int num_l7_bytes_transmitted, ++ int num_lost_packets, ++ int num_out_of_order_packets, ++ int num_packet_errors, ++ int num_packets_received_excl_retrans, ++ int num_packets_received_incl_retrans, ++ int num_packets_transmitted_incl_retrans, ++ int num_retries, ++ int num_timeouts, ++ int num_tunneled_l7_bytes_received, ++ int round_trip_time, ++ int time_to_first_byte); ++ ++/**************************************************************************//** ++ * Free a Mobile GTP Per Flow Metrics. ++ * ++ * Free off the Mobile GTP Per Flow Metrics supplied. Will free all the ++ * contained allocated memory. ++ * ++ * @note It does not free the Mobile GTP Per Flow Metrics itself, since that ++ * may be part of a larger structure. ++ *****************************************************************************/ ++void evel_free_mobile_gtp_flow_metrics(MOBILE_GTP_PER_FLOW_METRICS * metrics); ++ ++/**************************************************************************//** ++ * Set the Duration of Connection Failed Status property of the Mobile GTP Per ++ * Flow Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param duration The Duration of Connection Failed Status to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_dur_con_fail_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int duration); ++ ++/**************************************************************************//** ++ * Set the Duration of Tunnel Failed Status property of the Mobile GTP Per Flow ++ * Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param duration The Duration of Tunnel Failed Status to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_dur_tun_fail_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int duration); ++ ++/**************************************************************************//** ++ * Set the Activated By property of the Mobile GTP Per Flow metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param act_by The Activated By to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_act_by_set(MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ const char * const act_by); ++ ++/**************************************************************************//** ++ * Set the Activation Time property of the Mobile GTP Per Flow metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param act_time The Activation Time to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_act_time_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ time_t act_time); ++ ++/**************************************************************************//** ++ * Set the Deactivated By property of the Mobile GTP Per Flow metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param deact_by The Deactivated By to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_deact_by_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ const char * const deact_by); ++ ++/**************************************************************************//** ++ * Set the GTP Connection Status property of the Mobile GTP Per Flow metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param status The GTP Connection Status to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_con_status_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ const char * const status); ++ ++/**************************************************************************//** ++ * Set the GTP Tunnel Status property of the Mobile GTP Per Flow metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param status The GTP Tunnel Status to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_tun_status_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ const char * const status); ++ ++/**************************************************************************//** ++ * Set an IP Type-of-Service count property of the Mobile GTP Per Flow metrics. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param index The index of the IP Type-of-Service. ++ * @param count The count. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_iptos_set(MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int index, ++ int count); ++ ++/**************************************************************************//** ++ * Set the Large Packet Round-Trip Time property of the Mobile GTP Per Flow ++ * Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param rtt The Large Packet Round-Trip Time to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_large_pkt_rtt_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int rtt); ++ ++/**************************************************************************//** ++ * Set the Large Packet Threshold property of the Mobile GTP Per Flow Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param threshold The Large Packet Threshold to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_large_pkt_thresh_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ double threshold); ++ ++/**************************************************************************//** ++ * Set the Max Receive Bit Rate property of the Mobile GTP Per Flow Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param rate The Max Receive Bit Rate to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_max_rcv_bit_rate_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int rate); ++ ++/**************************************************************************//** ++ * Set the Max Transmit Bit Rate property of the Mobile GTP Per Flow Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param rate The Max Transmit Bit Rate to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_max_trx_bit_rate_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int rate); ++ ++/**************************************************************************//** ++ * Set the Number of GTP Echo Failures property of the Mobile GTP Per Flow ++ * Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param num The Number of GTP Echo Failures to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_num_echo_fail_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int num); ++ ++/**************************************************************************//** ++ * Set the Number of GTP Tunnel Errors property of the Mobile GTP Per Flow ++ * Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param num The Number of GTP Tunnel Errors to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_num_tun_fail_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int num); ++ ++/**************************************************************************//** ++ * Set the Number of HTTP Errors property of the Mobile GTP Per Flow Metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param num The Number of HTTP Errors to be set. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_num_http_errors_set( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ int num); ++ ++/**************************************************************************//** ++ * Add a TCP flag count to the metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param tcp_flag The TCP flag count to be updated. ++ * @param count The associated flag count. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_tcp_flag_count_add( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ const EVEL_TCP_FLAGS tcp_flag, ++ const int count); ++ ++/**************************************************************************//** ++ * Add a QCI COS count to the metrics. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param metrics Pointer to the Mobile GTP Per Flow Metrics. ++ * @param qci_cos The QCI COS count to be updated. ++ * @param count The associated QCI COS count. ++ *****************************************************************************/ ++void evel_mobile_gtp_metrics_qci_cos_count_add( ++ MOBILE_GTP_PER_FLOW_METRICS * metrics, ++ const EVEL_QCI_COS_TYPES qci_cos, ++ const int count); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* SERVICE EVENTS */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new Service event. ++ * ++ * @note The mandatory fields on the Service must be supplied to ++ * this factory function and are immutable once set. Optional fields ++ * have explicit setter functions, but again values may only be set ++ * once so that the event has immutable properties. ++ * @param vendor_id The vendor id to encode in the event instance id. ++ * @param event_id The vendor event id to encode in the event instance id. ++ * @returns pointer to the newly manufactured ::EVENT_SERVICE. If the event ++ * is not used (i.e. posted) it must be released using ++ * ::evel_free_service. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_SERVICE * evel_new_service(const char * const vendor_id, ++ const char * const event_id); ++ ++/**************************************************************************//** ++ * Free a Service Events event. ++ * ++ * Free off the event supplied. Will free all the contained allocated memory. ++ * ++ * @note It does not free the event itself, since that may be part of a larger ++ * structure. ++ *****************************************************************************/ ++void evel_free_service(EVENT_SERVICE * const event); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_service_type_set(EVENT_SERVICE * const event, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Product Id property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param product_id The vendor product id to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_service_product_id_set(EVENT_SERVICE * const event, ++ const char * const product_id); ++ ++/**************************************************************************//** ++ * Set the Subsystem Id property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param subsystem_id The vendor subsystem id to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_service_subsystem_id_set(EVENT_SERVICE * const event, ++ const char * const subsystem_id); ++ ++/**************************************************************************//** ++ * Set the Friendly Name property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param friendly_name The vendor friendly name to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_service_friendly_name_set(EVENT_SERVICE * const event, ++ const char * const friendly_name); ++ ++/**************************************************************************//** ++ * Set the correlator property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param correlator The correlator to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_service_correlator_set(EVENT_SERVICE * const event, ++ const char * const correlator); ++ ++/**************************************************************************//** ++ * Set the Codec property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param codec The codec to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_service_codec_set(EVENT_SERVICE * const event, ++ const char * const codec); ++ ++/**************************************************************************//** ++ * Set the Callee Side Codec property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param codec The codec to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_service_callee_codec_set(EVENT_SERVICE * const event, ++ const char * const codec); ++ ++/**************************************************************************//** ++ * Set the Caller Side Codec property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param codec The codec to be set. ASCIIZ string. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_service_caller_codec_set(EVENT_SERVICE * const event, ++ const char * const codec); ++ ++/**************************************************************************//** ++ * Set the RTCP Data property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtcp_data The RTCP Data to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_service_rtcp_data_set(EVENT_SERVICE * const event, ++ const char * const rtcp_data); ++ ++/**************************************************************************//** ++ * Set the Adjacency Name property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param adjacency_name ++ * The adjacency name to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_service_adjacency_name_set(EVENT_SERVICE * const event, ++ const char * const adjacency_name); ++ ++/**************************************************************************//** ++ * Set the Endpoint Descriptor property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param endpoint_desc The endpoint descriptor to be set. ++ *****************************************************************************/ ++void evel_service_endpoint_desc_set( ++ EVENT_SERVICE * const event, ++ const EVEL_SERVICE_ENDPOINT_DESC endpoint_desc); ++ ++/**************************************************************************//** ++ * Set the Endpoint Jitter property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param jitter The jitter to be set. ++ *****************************************************************************/ ++void evel_service_endpoint_jitter_set(EVENT_SERVICE * const event, ++ const int jitter); ++ ++/**************************************************************************//** ++ * Set the Endpoint Rtp Octets Discarded property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_oct_disc The discard count. ++ *****************************************************************************/ ++void evel_service_endpoint_rtp_oct_disc_set(EVENT_SERVICE * const event, ++ const int rtp_oct_disc); ++ ++/**************************************************************************//** ++ * Set the Endpoint Rtp Octets Received property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_oct_recv The receive count. ++ *****************************************************************************/ ++void evel_service_endpoint_rtp_oct_recv_set(EVENT_SERVICE * const event, ++ const int rtp_oct_recv); ++ ++/**************************************************************************//** ++ * Set the Endpoint Rtp Octets Sent property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_oct_sent The send count. ++ *****************************************************************************/ ++void evel_service_endpoint_rtp_oct_sent_set(EVENT_SERVICE * const event, ++ const int rtp_oct_sent); ++ ++/**************************************************************************//** ++ * Set the Endpoint Rtp Packets Discarded property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_pkt_disc The discard count. ++ *****************************************************************************/ ++void evel_service_endpoint_rtp_pkt_disc_set(EVENT_SERVICE * const event, ++ const int rtp_pkt_disc); ++ ++/**************************************************************************//** ++ * Set the Endpoint Rtp Packets Received property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_pkt_recv The receive count. ++ *****************************************************************************/ ++void evel_service_endpoint_rtp_pkt_recv_set(EVENT_SERVICE * const event, ++ const int rtp_pkt_recv); ++ ++/**************************************************************************//** ++ * Set the Endpoint Rtp Packets Sent property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_pkt_sent The send count. ++ *****************************************************************************/ ++void evel_service_endpoint_rtp_pkt_sent_set(EVENT_SERVICE * const event, ++ const int rtp_pkt_sent); ++ ++/**************************************************************************//** ++ * Set the Local Jitter property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param jitter The jitter to be set. ++ *****************************************************************************/ ++void evel_service_local_jitter_set(EVENT_SERVICE * const event, ++ const int jitter); ++ ++/**************************************************************************//** ++ * Set the Local Rtp Octets Discarded property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_oct_disc The discard count. ++ *****************************************************************************/ ++void evel_service_local_rtp_oct_disc_set(EVENT_SERVICE * const event, ++ const int rtp_oct_disc); ++ ++/**************************************************************************//** ++ * Set the Local Rtp Octets Received property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_oct_recv The receive count. ++ *****************************************************************************/ ++void evel_service_local_rtp_oct_recv_set(EVENT_SERVICE * const event, ++ const int rtp_oct_recv); ++ ++/**************************************************************************//** ++ * Set the Local Rtp Octets Sent property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_oct_sent The send count. ++ *****************************************************************************/ ++void evel_service_local_rtp_oct_sent_set(EVENT_SERVICE * const event, ++ const int rtp_oct_sent); ++ ++/**************************************************************************//** ++ * Set the Local Rtp Packets Discarded property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_pkt_disc The discard count. ++ *****************************************************************************/ ++void evel_service_local_rtp_pkt_disc_set(EVENT_SERVICE * const event, ++ const int rtp_pkt_disc); ++ ++/**************************************************************************//** ++ * Set the Local Rtp Packets Received property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_pkt_recv The receive count. ++ *****************************************************************************/ ++void evel_service_local_rtp_pkt_recv_set(EVENT_SERVICE * const event, ++ const int rtp_pkt_recv); ++ ++/**************************************************************************//** ++ * Set the Local Rtp Packets Sent property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param rtp_pkt_sent The send count. ++ *****************************************************************************/ ++void evel_service_local_rtp_pkt_sent_set(EVENT_SERVICE * const event, ++ const int rtp_pkt_sent); ++ ++/**************************************************************************//** ++ * Set the Mos Cqe property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param mos_cqe The mosCqe to be set. ++ *****************************************************************************/ ++void evel_service_mos_cqe_set(EVENT_SERVICE * const event, ++ const double mos_cqe); ++ ++/**************************************************************************//** ++ * Set the Packets Lost property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param packets_lost The number of packets lost to be set. ++ *****************************************************************************/ ++void evel_service_packets_lost_set(EVENT_SERVICE * const event, ++ const int packets_lost); ++ ++/**************************************************************************//** ++ * Set the packet Loss Percent property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param packet_loss_percent ++ * The packet loss in percent. ++ *****************************************************************************/ ++void evel_service_packet_loss_percent_set(EVENT_SERVICE * const event, ++ const double packet_loss_percent); ++ ++/**************************************************************************//** ++ * Set the R Factor property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param r_factor The R Factor to be set. ++ *****************************************************************************/ ++void evel_service_r_factor_set(EVENT_SERVICE * const event, ++ const int r_factor); ++ ++/**************************************************************************//** ++ * Set the Round Trip Delay property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param round_trip_delay ++ * The Round trip delay to be set. ++ *****************************************************************************/ ++void evel_service_round_trip_delay_set(EVENT_SERVICE * const event, ++ const int round_trip_delay); ++ ++/**************************************************************************//** ++ * Set the Phone Number property of the Service event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Service event. ++ * @param phone_number The Phone Number to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_service_phone_number_set(EVENT_SERVICE * const event, ++ const char * const phone_number); ++ ++/**************************************************************************//** ++ * Add a name/value pair to the Service, under the additionalFields array. ++ * ++ * The name and value are null delimited ASCII strings. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param event Pointer to the Service event. ++ * @param name ASCIIZ string with the field's name. The caller does not ++ * need to preserve the value once the function returns. ++ * @param value ASCIIZ string with the field's value. The caller does not ++ * need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_service_addl_field_add(EVENT_SERVICE * const event, ++ const char * const name, ++ const char * const value); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* SIGNALING */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new Signaling event. ++ * ++ * @note The mandatory fields on the Signaling must be supplied to ++ * this factory function and are immutable once set. Optional fields ++ * have explicit setter functions, but again values may only be set ++ * once so that the event has immutable properties. ++ * @param vendor_id The vendor id to encode in the event instance id. ++ * @param event_id The vendor event id to encode in the event instance id. ++ * @returns pointer to the newly manufactured ::EVENT_SIGNALING. If the event ++ * is not used (i.e. posted) it must be released using ++ * ::evel_free_signaling. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_SIGNALING * evel_new_signaling(const char * const vendor_id, ++ const char * const event_id); ++ ++/**************************************************************************//** ++ * Free a Signaling event. ++ * ++ * Free off the event supplied. Will free all the contained allocated memory. ++ * ++ * @note It does not free the event itself, since that may be part of a larger ++ * structure. ++ *****************************************************************************/ ++void evel_free_signaling(EVENT_SIGNALING * const event); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_signaling_type_set(EVENT_SIGNALING * const event, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Set the Product Id property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param product_id The vendor product id to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_signaling_product_id_set(EVENT_SIGNALING * const event, ++ const char * const product_id); ++ ++/**************************************************************************//** ++ * Set the Subsystem Id property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param subsystem_id The vendor subsystem id to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_signaling_subsystem_id_set(EVENT_SIGNALING * const event, ++ const char * const subsystem_id); ++ ++/**************************************************************************//** ++ * Set the Friendly Name property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param friendly_name The vendor friendly name to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_signaling_friendly_name_set(EVENT_SIGNALING * const event, ++ const char * const friendly_name); ++ ++/**************************************************************************//** ++ * Set the Correlator property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param correlator The correlator to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_signaling_correlator_set(EVENT_SIGNALING * const event, ++ const char * const correlator); ++ ++/**************************************************************************//** ++ * Set the Local Ip Address property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param local_ip_address ++ * The Local Ip Address to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_signaling_local_ip_address_set(EVENT_SIGNALING * const event, ++ const char * const local_ip_address); ++ ++/**************************************************************************//** ++ * Set the Local Port property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param local_port The Local Port to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_signaling_local_port_set(EVENT_SIGNALING * const event, ++ const char * const local_port); ++ ++/**************************************************************************//** ++ * Set the Remote Ip Address property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param remote_ip_address ++ * The Remote Ip Address to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_signaling_remote_ip_address_set(EVENT_SIGNALING * const event, ++ const char * const remote_ip_address); ++ ++/**************************************************************************//** ++ * Set the Remote Port property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param remote_port The Remote Port to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_signaling_remote_port_set(EVENT_SIGNALING * const event, ++ const char * const remote_port); ++ ++/**************************************************************************//** ++ * Set the Compressed SIP property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param compressed_sip ++ * The Compressed SIP to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_signaling_compressed_sip_set(EVENT_SIGNALING * const event, ++ const char * const compressed_sip); ++ ++/**************************************************************************//** ++ * Set the Summary SIP property of the Signaling event. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param event Pointer to the Signaling event. ++ * @param summary_sip The Summary SIP to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_signaling_summary_sip_set(EVENT_SIGNALING * const event, ++ const char * const summary_sip); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* STATE CHANGE */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new State Change event. ++ * ++ * @note The mandatory fields on the Syslog must be supplied to this factory ++ * function and are immutable once set. Optional fields have explicit ++ * setter functions, but again values may only be set once so that the ++ * Syslog has immutable properties. ++ * ++ * @param new_state The new state of the reporting entity. ++ * @param old_state The old state of the reporting entity. ++ * @param interface The card or port name of the reporting entity. ++ * ++ * @returns pointer to the newly manufactured ::EVENT_STATE_CHANGE. If the ++ * event is not used it must be released using ++ * ::evel_free_state_change ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_STATE_CHANGE * evel_new_state_change(const EVEL_ENTITY_STATE new_state, ++ const EVEL_ENTITY_STATE old_state, ++ const char * const interface); ++ ++/**************************************************************************//** ++ * Free a State Change. ++ * ++ * Free off the State Change supplied. Will free all the contained allocated ++ * memory. ++ * ++ * @note It does not free the State Change itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_state_change(EVENT_STATE_CHANGE * const state_change); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the State Change. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param state_change Pointer to the ::EVENT_STATE_CHANGE. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_state_change_type_set(EVENT_STATE_CHANGE * const state_change, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Add an additional field name/value pair to the State Change. ++ * ++ * The name and value are null delimited ASCII strings. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param state_change Pointer to the ::EVENT_STATE_CHANGE. ++ * @param name ASCIIZ string with the attribute's name. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ * @param value ASCIIZ string with the attribute's value. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_state_change_addl_field_add(EVENT_STATE_CHANGE * const state_change, ++ const char * const name, ++ const char * const value); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* SYSLOG */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new syslog event. ++ * ++ * @note The mandatory fields on the Syslog must be supplied to this factory ++ * function and are immutable once set. Optional fields have explicit ++ * setter functions, but again values may only be set once so that the ++ * Syslog has immutable properties. ++ * ++ * @param event_source_type ++ * @param syslog_msg ++ * @param syslog_tag ++ * ++ * @returns pointer to the newly manufactured ::EVENT_SYSLOG. If the event is ++ * not used it must be released using ::evel_free_syslog ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_SYSLOG * evel_new_syslog(EVEL_SOURCE_TYPES event_source_type, ++ const char * const syslog_msg, ++ const char * const syslog_tag); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the syslog. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_syslog_type_set(EVENT_SYSLOG * syslog, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Free a Syslog. ++ * ++ * Free off the Syslog supplied. Will free all the contained allocated memory. ++ * ++ * @note It does not free the Syslog itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_syslog(EVENT_SYSLOG * event); ++ ++/**************************************************************************//** ++ * Add an additional field name/value pair to the Syslog. ++ * ++ * The name and value are null delimited ASCII strings. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param syslog Pointer to the syslog. ++ * @param name ASCIIZ string with the attribute's name. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ * @param value ASCIIZ string with the attribute's value. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_syslog_addl_field_add(EVENT_SYSLOG * syslog, ++ char * name, ++ char * value); ++ ++/**************************************************************************//** ++ * Set the Event Source Host property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the Syslog. ++ * @param host The Event Source Host to be set. ASCIIZ string. The ++ * caller does not need to preserve the value once the ++ * function returns. ++ *****************************************************************************/ ++void evel_syslog_event_source_host_set(EVENT_SYSLOG * syslog, ++ const char * const host); ++ ++/**************************************************************************//** ++ * Set the Syslog Facility property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the Syslog. ++ * @param facility The Syslog Facility to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_syslog_facility_set(EVENT_SYSLOG * syslog, ++ EVEL_SYSLOG_FACILITIES facility); ++ ++/**************************************************************************//** ++ * Set the Process property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the Syslog. ++ * @param proc The Process to be set. ASCIIZ string. The caller does ++ * not need to preserve the value once the function returns. ++ *****************************************************************************/ ++void evel_syslog_proc_set(EVENT_SYSLOG * syslog, const char * const proc); ++ ++/**************************************************************************//** ++ * Set the Process ID property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the Syslog. ++ * @param proc_id The Process ID to be set. ++ *****************************************************************************/ ++void evel_syslog_proc_id_set(EVENT_SYSLOG * syslog, int proc_id); ++ ++/**************************************************************************//** ++ * Set the Version property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the Syslog. ++ * @param version The Version to be set. ++ *****************************************************************************/ ++void evel_syslog_version_set(EVENT_SYSLOG * syslog, int version); ++ ++/**************************************************************************//** ++ * Set the Structured Data property of the Syslog. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param syslog Pointer to the Syslog. ++ * @param s_data The Structured Data to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_syslog_s_data_set(EVENT_SYSLOG * syslog, const char * const s_data); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* OTHER */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Create a new other event. ++ * ++ * ++ * @returns pointer to the newly manufactured ::EVENT_OTHER. If the event is ++ * not used it must be released using ::evel_free_other. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_OTHER * evel_new_other(void); ++ ++/**************************************************************************//** ++ * Free an Other. ++ * ++ * Free off the Other supplied. Will free all the contained allocated memory. ++ * ++ * @note It does not free the Other itself, since that may be part of a ++ * larger structure. ++ *****************************************************************************/ ++void evel_free_other(EVENT_OTHER * event); ++ ++/**************************************************************************//** ++ * Set the Event Type property of the Other. ++ * ++ * @note The property is treated as immutable: it is only valid to call ++ * the setter once. However, we don't assert if the caller tries to ++ * overwrite, just ignoring the update instead. ++ * ++ * @param other Pointer to the Other. ++ * @param type The Event Type to be set. ASCIIZ string. The caller ++ * does not need to preserve the value once the function ++ * returns. ++ *****************************************************************************/ ++void evel_other_type_set(EVENT_OTHER * other, ++ const char * const type); ++ ++/**************************************************************************//** ++ * Add a value name/value pair to the Other. ++ * ++ * The name and value are null delimited ASCII strings. The library takes ++ * a copy so the caller does not have to preserve values after the function ++ * returns. ++ * ++ * @param other Pointer to the Other. ++ * @param name ASCIIZ string with the attribute's name. ++ * @param value ASCIIZ string with the attribute's value. ++ *****************************************************************************/ ++void evel_other_field_add(EVENT_OTHER * other, ++ char * name, ++ char * value); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* THROTTLING */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/**************************************************************************//** ++ * Return the current measurement interval provided by the Event Listener. ++ * ++ * @returns The current measurement interval ++ * @retval EVEL_MEASUREMENT_INTERVAL_UKNOWN (0) - interval has not been ++ * specified ++ *****************************************************************************/ ++int evel_get_measurement_interval(); ++ ++/*****************************************************************************/ ++/*****************************************************************************/ ++/* */ ++/* LOGGING */ ++/* */ ++/*****************************************************************************/ ++/*****************************************************************************/ ++ ++/*****************************************************************************/ ++/* Debug macros. */ ++/*****************************************************************************/ ++#define EVEL_DEBUG(FMT, ...) log_debug(EVEL_LOG_DEBUG, (FMT), ##__VA_ARGS__) ++#define EVEL_INFO(FMT, ...) log_debug(EVEL_LOG_INFO, (FMT), ##__VA_ARGS__) ++#define EVEL_SPAMMY(FMT, ...) log_debug(EVEL_LOG_SPAMMY, (FMT), ##__VA_ARGS__) ++#define EVEL_ERROR(FMT, ...) log_debug(EVEL_LOG_ERROR, "ERROR: " FMT, \ ++ ##__VA_ARGS__) ++#define EVEL_ENTER() \ ++ { \ ++ log_debug(EVEL_LOG_DEBUG, "Enter %s {", __FUNCTION__); \ ++ debug_indent += 2; \ ++ } ++#define EVEL_EXIT() \ ++ { \ ++ debug_indent -= 2; \ ++ log_debug(EVEL_LOG_DEBUG, "Exit %s }", __FUNCTION__); \ ++ } ++ ++#define INDENT_SEPARATORS \ ++ "| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | " ++ ++extern EVEL_LOG_LEVELS debug_level; ++extern int debug_indent; ++extern FILE * fout; ++ ++#define EVEL_DEBUG_ON() ((debug_level) >= EVEL_LOG_DEBUG) ++ ++/**************************************************************************//** ++ * Initialize logging ++ * ++ * @param[in] level The debugging level - one of ::EVEL_LOG_LEVELS. ++ * @param[in] ident The identifier for our logs. ++ *****************************************************************************/ ++void log_initialize(EVEL_LOG_LEVELS level, const char * ident); ++ ++/**************************************************************************//** ++ * Log debug information ++ * ++ * Logs debugging information in a platform independent manner. ++ * ++ * @param[in] level The debugging level - one of ::EVEL_LOG_LEVELS. ++ * @param[in] format Log formatting string in printf format. ++ * @param[in] ... Variable argument list. ++ *****************************************************************************/ ++void log_debug(EVEL_LOG_LEVELS level, char * format, ...); ++ ++/***************************************************************************//* ++ * Store the formatted string into the static error string and log the error. ++ * ++ * @param format Error string in standard printf format. ++ * @param ... Variable parameters to be substituted into the format string. ++ *****************************************************************************/ ++void log_error_state(char * format, ...); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/src/plugins/ves/include/evel_internal.h b/src/plugins/ves/include/evel_internal.h +new file mode 100644 +index 00000000..4608f751 +--- /dev/null ++++ b/src/plugins/ves/include/evel_internal.h +@@ -0,0 +1,852 @@ ++#ifndef EVEL_INTERNAL_INCLUDED ++#define EVEL_INTERNAL_INCLUDED ++ ++/**************************************************************************//** ++ * @file ++ * EVEL internal definitions. ++ * ++ * These are internal definitions which need to be shared between modules ++ * within the library but are not intended for external consumption. ++ * ++ * License ++ * ------- ++ * ++ * Copyright © 2017 AT&T Intellectual Property. All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ *****************************************************************************/ ++ ++#include "evel.h" ++ ++/*****************************************************************************/ ++/* Define some type-safe min/max macros. */ ++/*****************************************************************************/ ++#define max(a,b) \ ++ ({ __typeof__ (a) _a = (a); \ ++ __typeof__ (b) _b = (b); \ ++ _a > _b ? _a : _b; }) ++ ++#define min(a,b) \ ++ ({ __typeof__ (a) _a = (a); \ ++ __typeof__ (b) _b = (b); \ ++ _a < _b ? _a : _b; }) ++ ++ ++/**************************************************************************//** ++ * Compile-time assertion. ++ *****************************************************************************/ ++#define EVEL_CT_ASSERT(X) switch (0) {case 0: case (X):;} ++ ++/**************************************************************************//** ++ * The Functional Role of the equipment represented by this VNF. ++ *****************************************************************************/ ++extern char * functional_role; ++ ++/**************************************************************************//** ++ * The type of equipment represented by this VNF. ++ *****************************************************************************/ ++extern EVEL_SOURCE_TYPES event_source_type; ++ ++/**************************************************************************//** ++ * A chunk of memory used in the cURL functions. ++ *****************************************************************************/ ++typedef struct memory_chunk { ++ char * memory; ++ size_t size; ++} MEMORY_CHUNK; ++ ++/**************************************************************************//** ++ * Global commands that may be sent to the Event Handler thread. ++ *****************************************************************************/ ++typedef enum { ++ EVT_CMD_TERMINATE, ++ EVT_CMD_MAX_COMMANDS ++} EVT_HANDLER_COMMAND; ++ ++/**************************************************************************//** ++ * State of the Event Handler thread. ++ *****************************************************************************/ ++typedef enum { ++ EVT_HANDLER_UNINITIALIZED, /** The library cannot handle events. */ ++ EVT_HANDLER_INACTIVE, /** The event handler thread not started. */ ++ EVT_HANDLER_ACTIVE, /** The event handler thread is started. */ ++ EVT_HANDLER_REQUEST_TERMINATE, /** Initial stages of shutdown. */ ++ EVT_HANDLER_TERMINATING, /** The ring-buffer is being depleted. */ ++ EVT_HANDLER_TERMINATED, /** The library is exited. */ ++ EVT_HANDLER_MAX_STATES /** Maximum number of valid states. */ ++} EVT_HANDLER_STATE; ++ ++/**************************************************************************//** ++ * Internal event. ++ * Pseudo-event used for routing internal commands. ++ *****************************************************************************/ ++typedef struct event_internal { ++ EVENT_HEADER header; ++ EVT_HANDLER_COMMAND command; ++} EVENT_INTERNAL; ++ ++/**************************************************************************//** ++ * Suppressed NV pairs list entry. ++ * JSON equivalent field: suppressedNvPairs ++ *****************************************************************************/ ++typedef struct evel_suppressed_nv_pairs { ++ ++ /***************************************************************************/ ++ /* Mandatory fields */ ++ /* JSON equivalent field: nvPairFieldName */ ++ /***************************************************************************/ ++ char * nv_pair_field_name; ++ ++ /***************************************************************************/ ++ /* Optional fields */ ++ /* JSON equivalent field: suppressedNvPairNames */ ++ /* Type of each list entry: char * */ ++ /***************************************************************************/ ++ DLIST suppressed_nv_pair_names; ++ ++ /***************************************************************************/ ++ /* Hash table containing suppressed_nv_pair_names as keys. */ ++ /***************************************************************************/ ++ struct hsearch_data * hash_nv_pair_names; ++ ++} EVEL_SUPPRESSED_NV_PAIRS; ++ ++/**************************************************************************//** ++ * Event Throttling Specification for a domain which is in a throttled state. ++ * JSON equivalent object: eventThrottlingState ++ *****************************************************************************/ ++typedef struct evel_throttle_spec { ++ ++ /***************************************************************************/ ++ /* List of field names to be suppressed. */ ++ /* JSON equivalent field: suppressedFieldNames */ ++ /* Type of each list entry: char * */ ++ /***************************************************************************/ ++ DLIST suppressed_field_names; ++ ++ /***************************************************************************/ ++ /* List of name-value pairs to be suppressed. */ ++ /* JSON equivalent field: suppressedNvPairsList */ ++ /* Type of each list entry: EVEL_SUPPRESSED_NV_PAIRS * */ ++ /***************************************************************************/ ++ DLIST suppressed_nv_pairs_list; ++ ++ /***************************************************************************/ ++ /* Hash table containing suppressed_nv_pair_names as keys. */ ++ /***************************************************************************/ ++ struct hsearch_data * hash_field_names; ++ ++ /***************************************************************************/ ++ /* Hash table containing nv_pair_field_name as keys, and */ ++ /* suppressed_nv_pairs_list as values. */ ++ /***************************************************************************/ ++ struct hsearch_data * hash_nv_pairs_list; ++ ++} EVEL_THROTTLE_SPEC; ++ ++/*****************************************************************************/ ++/* RFC2822 format string for strftime. */ ++/*****************************************************************************/ ++#define EVEL_RFC2822_STRFTIME_FORMAT "%a, %d %b %Y %T %z" ++ ++/*****************************************************************************/ ++/* EVEL_JSON_BUFFER depth at which we throttle fields. */ ++/*****************************************************************************/ ++#define EVEL_THROTTLE_FIELD_DEPTH 3 ++ ++/**************************************************************************//** ++ * Initialize the event handler. ++ * ++ * Primarily responsible for getting cURL ready for use. ++ * ++ * @param[in] event_api_url ++ * The URL where the Vendor Event Listener API is expected ++ * to be. ++ * @param[in] throt_api_url ++ * The URL where the Throttling API is expected to be. ++ * @param[in] username The username for the Basic Authentication of requests. ++ * @param[in] password The password for the Basic Authentication of requests. ++ * @param verbosity 0 for normal operation, positive values for chattier ++ * logs. ++ *****************************************************************************/ ++EVEL_ERR_CODES event_handler_initialize(const char * const event_api_url, ++ const char * const throt_api_url, ++ const char * const username, ++ const char * const password, ++ int verbosity); ++ ++/**************************************************************************//** ++ * Terminate the event handler. ++ * ++ * Shuts down the event handler thread in as clean a way as possible. Sets the ++ * global exit flag and then signals the thread to interrupt it since it's ++ * most likely waiting on the ring-buffer. ++ * ++ * Having achieved an orderly shutdown of the event handler thread, clean up ++ * the cURL library's resources cleanly. ++ * ++ * @return Status code. ++ * @retval ::EVEL_SUCCESS if everything OK. ++ * @retval One of ::EVEL_ERR_CODES if there was a problem. ++ *****************************************************************************/ ++EVEL_ERR_CODES event_handler_terminate(); ++ ++/**************************************************************************//** ++ * Run the event handler. ++ * ++ * Spawns the thread responsible for handling events and sending them to the ++ * API. ++ * ++ * @return Status code. ++ * @retval ::EVEL_SUCCESS if everything OK. ++ * @retval One of ::EVEL_ERR_CODES if there was a problem. ++ *****************************************************************************/ ++EVEL_ERR_CODES event_handler_run(); ++ ++/**************************************************************************//** ++ * Create a new internal event. ++ * ++ * @note The mandatory fields on the Fault must be supplied to this factory ++ * function and are immutable once set. Optional fields have explicit ++ * setter functions, but again values may only be set once so that the ++ * Fault has immutable properties. ++ * @param command The condition indicated by the event. ++ * @returns pointer to the newly manufactured ::EVENT_INTERNAL. If the event ++ * is not used (i.e. posted) it must be released using ++ * ::evel_free_event. ++ * @retval NULL Failed to create the event. ++ *****************************************************************************/ ++EVENT_INTERNAL * evel_new_internal_event(EVT_HANDLER_COMMAND command); ++ ++/**************************************************************************//** ++ * Free an internal event. ++ * ++ * Free off the event supplied. Will free all the contained* allocated memory. ++ * ++ * @note It does not free the internal event itself, since that may be part of ++ * a larger structure. ++ *****************************************************************************/ ++void evel_free_internal_event(EVENT_INTERNAL * event); ++ ++/**************************************************************************//** ++ * Initialize an event instance id, typically embedded in an event. ++ * ++ * @param instance_id Pointer to the event instance id being initialized. ++ * @param vendor_id The vendor id to encode in the event instance id. ++ * @param event_id The event id to encode in the event instance id. ++ *****************************************************************************/ ++void evel_init_event_instance_id(EVEL_EVENT_INSTANCE_ID * const instance_id, ++ const char * const vendor_id, ++ const char * const event_id); ++ ++/**************************************************************************//** ++ * Free an event instance id. ++ * ++ * @param instance_id Pointer to the event instance id being initialized. ++ *****************************************************************************/ ++void evel_free_event_instance_id(EVEL_EVENT_INSTANCE_ID * const instance_id); ++ ++/*****************************************************************************/ ++/* Structure to hold JSON buffer and associated tracking, as it is written. */ ++/*****************************************************************************/ ++typedef struct evel_json_buffer ++{ ++ char * json; ++ int offset; ++ int max_size; ++ ++ /***************************************************************************/ ++ /* The working throttle specification, which can be NULL. */ ++ /***************************************************************************/ ++ EVEL_THROTTLE_SPEC * throttle_spec; ++ ++ /***************************************************************************/ ++ /* Current object/list nesting depth. */ ++ /***************************************************************************/ ++ int depth; ++ ++ /***************************************************************************/ ++ /* The checkpoint. */ ++ /***************************************************************************/ ++ int checkpoint; ++ ++} EVEL_JSON_BUFFER; ++ ++/**************************************************************************//** ++ * Encode the event as a JSON event object according to AT&T's schema. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_header(EVEL_JSON_BUFFER * jbuf, ++ EVENT_HEADER * event); ++ ++/**************************************************************************//** ++ * Encode the instance id as a JSON object according to AT&T's schema. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param instance_id Pointer to the ::EVEL_EVENT_INSTANCE_ID to encode. ++ *****************************************************************************/ ++void evel_json_encode_instance_id(EVEL_JSON_BUFFER * jbuf, ++ EVEL_EVENT_INSTANCE_ID * instance_id); ++ ++/**************************************************************************//** ++ * Encode the fault in JSON according to AT&T's schema for the fault type. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_fault(EVEL_JSON_BUFFER * jbuf, ++ EVENT_FAULT * event); ++ ++/**************************************************************************//** ++ * Encode the measurement as a JSON measurement. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_measurement(EVEL_JSON_BUFFER * jbuf, ++ EVENT_MEASUREMENT * event); ++ ++/**************************************************************************//** ++ * Encode the Mobile Flow in JSON according to AT&T's schema for the event ++ * type. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_mobile_flow(EVEL_JSON_BUFFER * jbuf, ++ EVENT_MOBILE_FLOW * event); ++ ++/**************************************************************************//** ++ * Encode the report as a JSON report. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_report(EVEL_JSON_BUFFER * jbuf, ++ EVENT_REPORT * event); ++ ++/**************************************************************************//** ++ * Encode the Service Event in JSON according to AT&T's schema for the event ++ * type. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_service(EVEL_JSON_BUFFER * const jbuf, ++ EVENT_SERVICE * const event); ++ ++/**************************************************************************//** ++ * Encode the Signaling in JSON according to AT&T's schema for the event type. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_signaling(EVEL_JSON_BUFFER * const jbuf, ++ EVENT_SIGNALING * const event); ++ ++/**************************************************************************//** ++ * Encode the state change as a JSON state change. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param state_change Pointer to the ::EVENT_STATE_CHANGE to encode. ++ *****************************************************************************/ ++void evel_json_encode_state_change(EVEL_JSON_BUFFER * jbuf, ++ EVENT_STATE_CHANGE * state_change); ++ ++/**************************************************************************//** ++ * Encode the Syslog in JSON according to AT&T's schema for the event type. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_syslog(EVEL_JSON_BUFFER * jbuf, ++ EVENT_SYSLOG * event); ++ ++/**************************************************************************//** ++ * Encode the Other in JSON according to AT&T's schema for the event type. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to encode into. ++ * @param event Pointer to the ::EVENT_HEADER to encode. ++ *****************************************************************************/ ++void evel_json_encode_other(EVEL_JSON_BUFFER * jbuf, ++ EVENT_OTHER * event); ++ ++/**************************************************************************//** ++ * Set the next event_sequence to use. ++ * ++ * @param sequence The next sequence number to use. ++ *****************************************************************************/ ++void evel_set_next_event_sequence(const int sequence); ++ ++/**************************************************************************//** ++ * Handle a JSON response from the listener, contained in a ::MEMORY_CHUNK. ++ * ++ * Tokenize the response, and decode any tokens found. ++ * ++ * @param chunk The memory chunk containing the response. ++ * @param post The memory chunk in which to place any resulting POST. ++ *****************************************************************************/ ++void evel_handle_event_response(const MEMORY_CHUNK * const chunk, ++ MEMORY_CHUNK * const post); ++ ++/**************************************************************************//** ++ * Initialize a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to the ::EVEL_JSON_BUFFER to initialise. ++ * @param json Pointer to the underlying working buffer to use. ++ * @param max_size Size of storage available in the JSON buffer. ++ * @param throttle_spec Pointer to throttle specification. Can be NULL. ++ *****************************************************************************/ ++void evel_json_buffer_init(EVEL_JSON_BUFFER * jbuf, ++ char * const json, ++ const int max_size, ++ EVEL_THROTTLE_SPEC * throttle_spec); ++ ++/**************************************************************************//** ++ * Encode a string key and string value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param option Pointer to holder of the corresponding value to encode. ++ * @return true if the key, value was added, false if it was suppressed. ++ *****************************************************************************/ ++bool evel_enc_kv_opt_string(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const EVEL_OPTION_STRING * const option); ++ ++/**************************************************************************//** ++ * Encode a string key and string value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param value Pointer to the corresponding value to encode. ++ *****************************************************************************/ ++void evel_enc_kv_string(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const char * const value); ++ ++/**************************************************************************//** ++ * Encode a string key and integer value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param option Pointer to holder of the corresponding value to encode. ++ * @return true if the key, value was added, false if it was suppressed. ++ *****************************************************************************/ ++bool evel_enc_kv_opt_int(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const EVEL_OPTION_INT * const option); ++ ++/**************************************************************************//** ++ * Encode a string key and integer value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param value The corresponding value to encode. ++ *****************************************************************************/ ++void evel_enc_kv_int(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const int value); ++ ++/**************************************************************************//** ++ * Encode a string key and double value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param option Pointer to holder of the corresponding value to encode. ++ * @return true if the key, value was added, false if it was suppressed. ++ *****************************************************************************/ ++bool evel_enc_kv_opt_double(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const EVEL_OPTION_DOUBLE * const option); ++ ++/**************************************************************************//** ++ * Encode a string key and double value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param value The corresponding value to encode. ++ *****************************************************************************/ ++void evel_enc_kv_double(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const double value); ++ ++/**************************************************************************//** ++ * Encode a string key and unsigned long long value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param option Pointer to holder of the corresponding value to encode. ++ * @return true if the key, value was added, false if it was suppressed. ++ *****************************************************************************/ ++bool evel_enc_kv_opt_ull(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const EVEL_OPTION_ULL * const option); ++ ++/**************************************************************************//** ++ * Encode a string key and unsigned long long value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param value The corresponding value to encode. ++ *****************************************************************************/ ++void evel_enc_kv_ull(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const unsigned long long value); ++ ++/**************************************************************************//** ++ * Encode a string key and time value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param option Pointer to holder of the corresponding value to encode. ++ * @return true if the key, value was added, false if it was suppressed. ++ *****************************************************************************/ ++bool evel_enc_kv_opt_time(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const EVEL_OPTION_TIME * const option); ++ ++/**************************************************************************//** ++ * Encode a string key and time value to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param time Pointer to the time to encode. ++ *****************************************************************************/ ++void evel_enc_kv_time(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const time_t * time); ++ ++/**************************************************************************//** ++ * Encode a key and version. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @param major_version The major version to encode. ++ * @param minor_version The minor version to encode. ++ *****************************************************************************/ ++void evel_enc_version(EVEL_JSON_BUFFER * jbuf, ++ const char * const key, ++ const int major_version, ++ const int minor_version); ++ ++/**************************************************************************//** ++ * Add the key and opening bracket of an optional named list to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @return true if the list was opened, false if it was suppressed. ++ *****************************************************************************/ ++bool evel_json_open_opt_named_list(EVEL_JSON_BUFFER * jbuf, ++ const char * const key); ++ ++/**************************************************************************//** ++ * Add the key and opening bracket of a named list to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ *****************************************************************************/ ++void evel_json_open_named_list(EVEL_JSON_BUFFER * jbuf, ++ const char * const key); ++ ++/**************************************************************************//** ++ * Add the closing bracket of a list to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ *****************************************************************************/ ++void evel_json_close_list(EVEL_JSON_BUFFER * jbuf); ++ ++/**************************************************************************//** ++ * Encode a list item with format and param list to a ::EVEL_JSON_BUFFER. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param format Format string in standard printf format. ++ * @param ... Variable parameters for format string. ++ *****************************************************************************/ ++void evel_enc_list_item(EVEL_JSON_BUFFER * jbuf, ++ const char * const format, ++ ...); ++ ++/**************************************************************************//** ++ * Add the opening bracket of an optional named object to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ *****************************************************************************/ ++bool evel_json_open_opt_named_object(EVEL_JSON_BUFFER * jbuf, ++ const char * const key); ++ ++/**************************************************************************//** ++ * Add the opening bracket of an object to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ * @param key Pointer to the key to encode. ++ * @return true if the object was opened, false if it was suppressed. ++ *****************************************************************************/ ++void evel_json_open_named_object(EVEL_JSON_BUFFER * jbuf, ++ const char * const key); ++ ++/**************************************************************************//** ++ * Add the opening bracket of an object to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ *****************************************************************************/ ++void evel_json_open_object(EVEL_JSON_BUFFER * jbuf); ++ ++/**************************************************************************//** ++ * Add the closing bracket of an object to a JSON buffer. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ *****************************************************************************/ ++void evel_json_close_object(EVEL_JSON_BUFFER * jbuf); ++ ++/**************************************************************************//** ++ * Add a checkpoint - a stake in the ground to which we can rewind. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ *****************************************************************************/ ++void evel_json_checkpoint(EVEL_JSON_BUFFER * jbuf); ++ ++/**************************************************************************//** ++ * Rewind to the latest checkoint. ++ * ++ * @param jbuf Pointer to working ::EVEL_JSON_BUFFER. ++ *****************************************************************************/ ++void evel_json_rewind(EVEL_JSON_BUFFER * jbuf); ++ ++/**************************************************************************//** ++ * Free the underlying resources of an ::EVEL_OPTION_STRING. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_STRING. ++ *****************************************************************************/ ++void evel_free_option_string(EVEL_OPTION_STRING * const option); ++ ++/**************************************************************************//** ++ * Initialize an ::EVEL_OPTION_STRING to a not-set state. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_STRING. ++ *****************************************************************************/ ++void evel_init_option_string(EVEL_OPTION_STRING * const option); ++ ++/**************************************************************************//** ++ * Set the value of an ::EVEL_OPTION_STRING. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_STRING. ++ * @param value The value to set. ++ * @param description Description to be used in logging. ++ *****************************************************************************/ ++void evel_set_option_string(EVEL_OPTION_STRING * const option, ++ const char * const value, ++ const char * const description); ++ ++/**************************************************************************//** ++ * Force the value of an ::EVEL_OPTION_STRING. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_STRING. ++ * @param value The value to set. ++ *****************************************************************************/ ++void evel_force_option_string(EVEL_OPTION_STRING * const option, ++ const char * const value); ++ ++/**************************************************************************//** ++ * Initialize an ::EVEL_OPTION_INT to a not-set state. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_INT. ++ *****************************************************************************/ ++void evel_init_option_int(EVEL_OPTION_INT * const option); ++ ++/**************************************************************************//** ++ * Force the value of an ::EVEL_OPTION_INT. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_INT. ++ * @param value The value to set. ++ *****************************************************************************/ ++void evel_force_option_int(EVEL_OPTION_INT * const option, ++ const int value); ++ ++/**************************************************************************//** ++ * Set the value of an ::EVEL_OPTION_INT. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_INT. ++ * @param value The value to set. ++ * @param description Description to be used in logging. ++ *****************************************************************************/ ++void evel_set_option_int(EVEL_OPTION_INT * const option, ++ const int value, ++ const char * const description); ++ ++/**************************************************************************//** ++ * Initialize an ::EVEL_OPTION_DOUBLE to a not-set state. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_DOUBLE. ++ *****************************************************************************/ ++void evel_init_option_double(EVEL_OPTION_DOUBLE * const option); ++ ++/**************************************************************************//** ++ * Force the value of an ::EVEL_OPTION_DOUBLE. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_DOUBLE. ++ * @param value The value to set. ++ *****************************************************************************/ ++void evel_force_option_double(EVEL_OPTION_DOUBLE * const option, ++ const double value); ++ ++/**************************************************************************//** ++ * Set the value of an ::EVEL_OPTION_DOUBLE. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_DOUBLE. ++ * @param value The value to set. ++ * @param description Description to be used in logging. ++ *****************************************************************************/ ++void evel_set_option_double(EVEL_OPTION_DOUBLE * const option, ++ const double value, ++ const char * const description); ++ ++/**************************************************************************//** ++ * Initialize an ::EVEL_OPTION_ULL to a not-set state. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_ULL. ++ *****************************************************************************/ ++void evel_init_option_ull(EVEL_OPTION_ULL * const option); ++ ++/**************************************************************************//** ++ * Force the value of an ::EVEL_OPTION_ULL. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_ULL. ++ * @param value The value to set. ++ *****************************************************************************/ ++void evel_force_option_ull(EVEL_OPTION_ULL * const option, ++ const unsigned long long value); ++ ++/**************************************************************************//** ++ * Set the value of an ::EVEL_OPTION_ULL. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_ULL. ++ * @param value The value to set. ++ * @param description Description to be used in logging. ++ *****************************************************************************/ ++void evel_set_option_ull(EVEL_OPTION_ULL * const option, ++ const unsigned long long value, ++ const char * const description); ++ ++/**************************************************************************//** ++ * Initialize an ::EVEL_OPTION_TIME to a not-set state. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_TIME. ++ *****************************************************************************/ ++void evel_init_option_time(EVEL_OPTION_TIME * const option); ++ ++/**************************************************************************//** ++ * Force the value of an ::EVEL_OPTION_TIME. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_TIME. ++ * @param value The value to set. ++ *****************************************************************************/ ++void evel_force_option_time(EVEL_OPTION_TIME * const option, ++ const time_t value); ++ ++/**************************************************************************//** ++ * Set the value of an ::EVEL_OPTION_TIME. ++ * ++ * @param option Pointer to the ::EVEL_OPTION_TIME. ++ * @param value The value to set. ++ * @param description Description to be used in logging. ++ *****************************************************************************/ ++void evel_set_option_time(EVEL_OPTION_TIME * const option, ++ const time_t value, ++ const char * const description); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_COUNTER_CRITICALITIES enum value to the equivalent string. ++ * ++ * @param criticality The criticality to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_criticality(const EVEL_COUNTER_CRITICALITIES criticality); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_SEVERITIES enum value to the equivalent string. ++ * ++ * @param severity The severity to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_severity(const EVEL_SEVERITIES severity); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_ALERT_ACTIONS enum value to the equivalent string. ++ * ++ * @param alert_action The alert_action to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_alert_action(const EVEL_ALERT_ACTIONS alert_action); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_ALERT_TYPES enum value to the equivalent string. ++ * ++ * @param alert_type The alert_type to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_alert_type(const EVEL_ALERT_TYPES alert_type); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_EVENT_DOMAINS enum value to the equivalent string. ++ * ++ * @param domain The domain to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_event_domain(const EVEL_EVENT_DOMAINS domain); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_EVENT_PRIORITIES enum value to the equivalent string. ++ * ++ * @param priority The priority to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_event_priority(const EVEL_EVENT_PRIORITIES priority); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_SOURCE_TYPES enum value to the equivalent string. ++ * ++ * @param source_type The source type to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_source_type(const EVEL_SOURCE_TYPES source_type); ++ ++/**************************************************************************//** ++ * Map an ::EVEL_VF_STATUSES enum value to the equivalent string. ++ * ++ * @param vf_status The vf_status to convert. ++ * @returns The equivalent string. ++ *****************************************************************************/ ++char * evel_vf_status(const EVEL_VF_STATUSES vf_status); ++ ++/**************************************************************************//** ++ * Convert a ::EVEL_ENTITY_STATE to it's string form for JSON encoding. ++ * ++ * @param state The entity state to encode. ++ * ++ * @returns the corresponding string ++ *****************************************************************************/ ++char * evel_entity_state(const EVEL_ENTITY_STATE state); ++ ++/**************************************************************************//** ++ * Convert a ::EVEL_SERVICE_ENDPOINT_DESC to string form for JSON encoding. ++ * ++ * @param endpoint_desc endpoint description to encode. ++ * ++ * @returns the corresponding string ++ *****************************************************************************/ ++char * evel_service_endpoint_desc(const EVEL_ENTITY_STATE endpoint_desc); ++ ++#endif +diff --git a/src/plugins/ves/include/evel_throttle.h b/src/plugins/ves/include/evel_throttle.h +new file mode 100644 +index 00000000..70371410 +--- /dev/null ++++ b/src/plugins/ves/include/evel_throttle.h +@@ -0,0 +1,213 @@ ++#ifndef EVEL_THROTTLE_INCLUDED ++#define EVEL_THROTTLE_INCLUDED ++ ++/**************************************************************************//** ++ * @file ++ * EVEL throttle definitions. ++ * ++ * These are internal definitions related to throttling specicications, which ++ * are required within the library but are not intended for external ++ * consumption. ++ * ++ * License ++ * ------- ++ * ++ * Copyright © 2017 AT&T Intellectual Property. All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ *****************************************************************************/ ++ ++#include "evel_internal.h" ++#include "jsmn.h" ++ ++/*****************************************************************************/ ++/* Maximum depth of JSON response that we can handle. */ ++/*****************************************************************************/ ++#define EVEL_JSON_STACK_DEPTH 10 ++ ++/**************************************************************************//** ++ * Maximum number of tokens that we allow for in a JSON response. ++ *****************************************************************************/ ++#define EVEL_MAX_RESPONSE_TOKENS 1024 ++ ++/**************************************************************************//** ++ * The nature of the next token that we are iterating through. Within an ++ * object, we alternate between collecting keys and values. Within an array, ++ * we only collect items. ++ *****************************************************************************/ ++typedef enum { ++ EVEL_JSON_KEY, ++ EVEL_JSON_VALUE, ++ EVEL_JSON_ITEM ++} EVEL_JSON_STATE; ++ ++/**************************************************************************//** ++ * States which we move through during JSON processing, tracking our way ++ * through the supported JSON structure. ++ *****************************************************************************/ ++typedef enum ++{ ++ /***************************************************************************/ ++ /* Initial state. */ ++ /***************************************************************************/ ++ EVEL_JCS_START, ++ ++ /***************************************************************************/ ++ /* {"commandList": [ */ ++ /***************************************************************************/ ++ EVEL_JCS_COMMAND_LIST, ++ ++ /***************************************************************************/ ++ /* {"commandList": [{ */ ++ /***************************************************************************/ ++ EVEL_JCS_COMMAND_LIST_ENTRY, ++ ++ /***************************************************************************/ ++ /* {"commandList": [{"command": { */ ++ /***************************************************************************/ ++ EVEL_JCS_COMMAND, ++ ++ /***************************************************************************/ ++ /* ... "eventDomainThrottleSpecification": { */ ++ /***************************************************************************/ ++ EVEL_JCS_SPEC, ++ ++ /***************************************************************************/ ++ /* ... "suppressedFieldNames": [ */ ++ /***************************************************************************/ ++ EVEL_JCS_FIELD_NAMES, ++ ++ /***************************************************************************/ ++ /* ... "suppressedNvPairsList": [ */ ++ /***************************************************************************/ ++ EVEL_JCS_PAIRS_LIST, ++ ++ /***************************************************************************/ ++ /* ... "suppressedNvPairsList": [{ */ ++ /***************************************************************************/ ++ EVEL_JCS_PAIRS_LIST_ENTRY, ++ ++ /***************************************************************************/ ++ /* ... "suppressedNvPairNames": [ */ ++ /***************************************************************************/ ++ EVEL_JCS_NV_PAIR_NAMES, ++ ++ EVEL_JCS_MAX ++} EVEL_JSON_COMMAND_STATE; ++ ++/**************************************************************************//** ++ * An entry in the JSON stack. ++ *****************************************************************************/ ++typedef struct evel_json_stack_entry { ++ ++ /***************************************************************************/ ++ /* The number of elements required at this level. */ ++ /***************************************************************************/ ++ int num_required; ++ ++ /***************************************************************************/ ++ /* The number of elements collected at this level. */ ++ /***************************************************************************/ ++ int json_count; ++ ++ /***************************************************************************/ ++ /* The collection state at this level in the JSON stack. */ ++ /***************************************************************************/ ++ EVEL_JSON_STATE json_state; ++ ++ /***************************************************************************/ ++ /* The key being collected (if json_state is EVEL_JSON_VALUE), or NULL. */ ++ /***************************************************************************/ ++ char * json_key; ++ ++} EVEL_JSON_STACK_ENTRY; ++ ++/**************************************************************************//** ++ * The JSON stack. ++ *****************************************************************************/ ++typedef struct evel_json_stack { ++ ++ /***************************************************************************/ ++ /* The current position of the stack - starting at zero. */ ++ /***************************************************************************/ ++ int level; ++ ++ /***************************************************************************/ ++ /* The stack itself. */ ++ /***************************************************************************/ ++ EVEL_JSON_STACK_ENTRY entry[EVEL_JSON_STACK_DEPTH]; ++ ++ /***************************************************************************/ ++ /* The underlying memory chunk. */ ++ /***************************************************************************/ ++ const MEMORY_CHUNK * chunk; ++ ++} EVEL_JSON_STACK; ++ ++/**************************************************************************//** ++ * Initialize event throttling to the default state. ++ * ++ * Called from ::evel_initialize. ++ *****************************************************************************/ ++void evel_throttle_initialize(); ++ ++/**************************************************************************//** ++ * Clean up event throttling. ++ * ++ * Called from ::evel_terminate. ++ *****************************************************************************/ ++void evel_throttle_terminate(); ++ ++/**************************************************************************//** ++ * Handle a JSON response from the listener, as a list of tokens from JSMN. ++ * ++ * @param chunk Memory chunk containing the JSON buffer. ++ * @param json_tokens Array of tokens to handle. ++ * @param num_tokens The number of tokens to handle. ++ * @param post The memory chunk in which to place any resulting POST. ++ * @return true if the command was handled, false otherwise. ++ *****************************************************************************/ ++bool evel_handle_command_list(const MEMORY_CHUNK * const chunk, ++ const jsmntok_t * const json_tokens, ++ const int num_tokens, ++ MEMORY_CHUNK * const post); ++ ++/**************************************************************************//** ++ * Return the ::EVEL_THROTTLE_SPEC for a given domain. ++ * ++ * @param domain The domain for which to return state. ++ *****************************************************************************/ ++EVEL_THROTTLE_SPEC * evel_get_throttle_spec(EVEL_EVENT_DOMAINS domain); ++ ++/**************************************************************************//** ++ * Determine whether a field_name should be suppressed. ++ * ++ * @param throttle_spec Throttle specification for the domain being encoded. ++ * @param field_name The field name to encoded or suppress. ++ * @return true if the field_name should be suppressed, false otherwise. ++ *****************************************************************************/ ++bool evel_throttle_suppress_field(EVEL_THROTTLE_SPEC * throttle_spec, ++ const char * const field_name); ++ ++/**************************************************************************//** ++ * Determine whether a name-value pair should be allowed (not suppressed). ++ * ++ * @param throttle_spec Throttle specification for the domain being encoded. ++ * @param field_name The field name holding the name-value pairs. ++ * @param name The name of the name-value pair to encoded or suppress. ++ * @return true if the name-value pair should be suppressed, false otherwise. ++ *****************************************************************************/ ++bool evel_throttle_suppress_nv_pair(EVEL_THROTTLE_SPEC * throttle_spec, ++ const char * const field_name, ++ const char * const name); ++ ++#endif +diff --git a/src/plugins/ves/include/jsmn.h b/src/plugins/ves/include/jsmn.h +new file mode 100644 +index 00000000..01ca99c8 +--- /dev/null ++++ b/src/plugins/ves/include/jsmn.h +@@ -0,0 +1,76 @@ ++#ifndef __JSMN_H_ ++#define __JSMN_H_ ++ ++#include <stddef.h> ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/** ++ * JSON type identifier. Basic types are: ++ * o Object ++ * o Array ++ * o String ++ * o Other primitive: number, boolean (true/false) or null ++ */ ++typedef enum { ++ JSMN_UNDEFINED = 0, ++ JSMN_OBJECT = 1, ++ JSMN_ARRAY = 2, ++ JSMN_STRING = 3, ++ JSMN_PRIMITIVE = 4 ++} jsmntype_t; ++ ++enum jsmnerr { ++ /* Not enough tokens were provided */ ++ JSMN_ERROR_NOMEM = -1, ++ /* Invalid character inside JSON string */ ++ JSMN_ERROR_INVAL = -2, ++ /* The string is not a full JSON packet, more bytes expected */ ++ JSMN_ERROR_PART = -3 ++}; ++ ++/** ++ * JSON token description. ++ * @param type type (object, array, string etc.) ++ * @param start start position in JSON data string ++ * @param end end position in JSON data string ++ */ ++typedef struct { ++ jsmntype_t type; ++ int start; ++ int end; ++ int size; ++#ifdef JSMN_PARENT_LINKS ++ int parent; ++#endif ++} jsmntok_t; ++ ++/** ++ * JSON parser. Contains an array of token blocks available. Also stores ++ * the string being parsed now and current position in that string ++ */ ++typedef struct { ++ unsigned int pos; /* offset in the JSON string */ ++ unsigned int toknext; /* next token to allocate */ ++ int toksuper; /* superior token node, e.g parent object or array */ ++} jsmn_parser; ++ ++/** ++ * Create JSON parser over an array of tokens ++ */ ++void jsmn_init(jsmn_parser *parser); ++ ++/** ++ * Run JSON parser. It parses a JSON data string into and array of tokens, each describing ++ * a single JSON object. ++ */ ++int jsmn_parse(jsmn_parser *parser, const char *js, size_t len, ++ jsmntok_t *tokens, unsigned int num_tokens); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* __JSMN_H_ */ +diff --git a/src/plugins/ves/include/metadata.h b/src/plugins/ves/include/metadata.h +new file mode 100644 +index 00000000..bddb8003 +--- /dev/null ++++ b/src/plugins/ves/include/metadata.h +@@ -0,0 +1,57 @@ ++#ifndef METADATA_INCLUDED ++#define METADATA_INCLUDED ++/**************************************************************************//** ++ * @file ++ * Wrap the OpenStack metadata service. ++ * ++ * License ++ * ------- ++ * ++ * Copyright © 2017 AT&T Intellectual Property. All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ *****************************************************************************/ ++ ++ ++#include "evel.h" ++ ++/**************************************************************************//** ++ * Download metadata from the OpenStack metadata service. ++ * ++ * @param verbosity Controls whether to generate debug to stdout. Zero: ++ * none. Non-zero: generate debug. ++ * @returns Status code ++ * @retval EVEL_SUCCESS On success ++ * @retval ::EVEL_ERR_CODES On failure. ++ *****************************************************************************/ ++EVEL_ERR_CODES openstack_metadata(int verbosity); ++ ++/**************************************************************************//** ++ * Initialize default values for vm_name and vm_uuid - for testing purposes. ++ *****************************************************************************/ ++void openstack_metadata_initialize(); ++ ++/**************************************************************************//** ++ * Get the VM name provided by the metadata service. ++ * ++ * @returns VM name ++ *****************************************************************************/ ++const char *openstack_vm_name(); ++ ++/**************************************************************************//** ++ * Get the VM UUID provided by the metadata service. ++ * ++ * @returns VM UUID ++ *****************************************************************************/ ++const char *openstack_vm_uuid(); ++ ++#endif +diff --git a/src/plugins/ves/include/ring_buffer.h b/src/plugins/ves/include/ring_buffer.h +new file mode 100644 +index 00000000..cc08c1ff +--- /dev/null ++++ b/src/plugins/ves/include/ring_buffer.h +@@ -0,0 +1,94 @@ ++#ifndef RING_BUFFER_INCLUDED ++#define RING_BUFFER_INCLUDED ++ ++/**************************************************************************//** ++ * @file ++ * A ring buffer. ++ * ++ * License ++ * ------- ++ * ++ * Copyright © 2017 AT&T Intellectual Property. All rights reserved. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ *****************************************************************************/ ++ ++#include <pthread.h> ++ ++/**************************************************************************//** ++ * Ring buffer structure. ++ *****************************************************************************/ ++typedef struct ring_buffer ++{ ++ int size; ++ int next_write; ++ int next_read; ++ void ** ring; ++ pthread_cond_t ring_cv; ++ pthread_mutex_t ring_mutex; ++} ring_buffer; ++ ++/**************************************************************************//** ++ * Ring buffer initialization. ++ * ++ * Initialize the buffer supplied to the specified size. ++ * ++ * @param buffer Pointer to the ring-buffer to be initialized. ++ * @param size How many elements to be stored in the ring-buffer. ++ * ++ * @returns Nothing ++******************************************************************************/ ++void ring_buffer_initialize(ring_buffer * buffer, int size); ++ ++/**************************************************************************//** ++ * Read an element from a ring_buffer. ++ * ++ * Reads an element from the ring_buffer, advancing the next-read position. ++ * Operation is synchronized and therefore MT-safe. Blocks if no data is ++ * available. ++ * ++ * @param buffer Pointer to the ring-buffer to be read. ++ * ++ * @returns Pointer to the element read from the buffer. ++******************************************************************************/ ++void * ring_buffer_read(ring_buffer * buffer); ++ ++/**************************************************************************//** ++ * Write an element into a ring_buffer. ++ * ++ * Writes an element into the ring_buffer, advancing the next-write position. ++ * Operation is synchronized and therefore MT-safe. Fails if the buffer is ++ * full without blocking. ++ * ++ * @param buffer Pointer to the ring-buffer to be written. ++ * @param msg Pointer to data to be stored in the ring_buffer. ++ * ++ * @returns Number of items written. ++ * @retval 1 The data was written successfully. ++ * @retval 0 The ring_buffer was full so no data written. ++******************************************************************************/ ++int ring_buffer_write(ring_buffer * buffer, void * msg); ++ ++/**************************************************************************//** ++ * Tests whether there is data in the ring_buffer. ++ * ++ * Tests whether there is currently data in the ring_buffer without blocking. ++ * ++ * @param buffer Pointer to the ring-buffer to be tested. ++ * ++ * @returns Whether there is data in the ring_buffer. ++ * @retval 0 There isn't any data in the ring_buffer. ++ * @retval 1 There is data in the ring_buffer. ++******************************************************************************/ ++int ring_buffer_is_empty(ring_buffer * buffer); ++ ++#endif +diff --git a/src/plugins/ves/libs/libevel.a b/src/plugins/ves/libs/libevel.a +new file mode 100644 +index 0000000000000000000000000000000000000000..a56ea84ecf054cbbb23bdaf3c323ce581549dce6 +GIT binary patch +literal 414098 +zcmeEvX<!u95^e_=341`JfD4gD<H8~kMHUH5WI)iMpa^0Tk^q5hWMNYv5P})vXhc9n +zR6vn{3%DQ<L;@;_f)Y?Kn@SYX89)t)5)kEmb*j4i^pJS(`}cmlzIW)ZI^U_PQ>RXy +zWjf=msKIyF3JNmJtG02MK~(uf=0r+CbB{}&3?tI$X4J*Mt&LU+YnNCM>*2?~wbiqE +zH;gbvla9;qaS!2g_mDP<Z{DA4ph&}LEO)6_3nbO^Nj;y`Gw&rN7?*huX40sGJAKNe +zJn-IDaORz`bVVP_N}%Wdwb;(U`&SJW%rNg}y`iW_cK)wdhyd>weKq-I6FC5vd6(v> +zwp{@}Svla|;f6b7_JxJVTF&TsP4BkXyioemwA2gA(z>V+0ZbS^<l@<3?Q`N5yjyGe +z?Cyi3XS~tB&VaC-D{2|h`9_X%SZl-8ykXng*OxRjf{fstT1H7&Sa`jLM$<vTK{=38 +zw{2|Wp^0nu<p&$f7X}ZDY}hGmc23KZvf6E3O~Y2cdVSEyr@D0wY95lasc~?4(89iM +zpKFs5bXlW@VIlX<n`>+c4r^_M#WpPn3mF=AS!B0cBZF%N*9tRoBI^bl*BEo_^r_>` +z42cc-X++TT?Yg#U6kMlu;$<xo);_a5_|_%2=hx2l<g5rX!iR;m4i0O)Ju)9Q_b<!| +zTEE_y6I3tK$gS1?hW5tz4lNhnR;SI_1MAve*EuM}h=dR4_X+!CrC~flzM$(4e7fP& +z9iJZf^up&Zd?N9os}DZ?@QK3bZhXvZ03HSkaWC%CW&!RG;4@6<hj1T>&m;JZ#wP|J +z^BRMP1bh<l8Hdk!e9SA!e31JDxy$fWR5Jce!6y};G<?$Wp=%O8nd-?fvgJMv_v!Nd +znA~ULo`cU^eDd(2>j`||O?7$XJ|B0lJk#wde4Y{dS=<-O^CH|A%kvVsKacwh_`HbE +z%feeBcl3k0UX}YQ++V||2%j~=TZ{Ya@=Uik@p%iMb@;5u$GqN_hj(y)51$QY0q*Z> +z&l~Z)N$AaTFP8fj+&{qQLwri`*^ZBS?U09$asLFLo%odE^C>=`;j;^$&++*JAM@IS +zhjM)O3F9l=|0B=)aX%o>2jzZP?%&A$JGs;C2tMEAa}=K+@i~SMT|eRD!^e-$34BiC +z^D925@S*E8KEJCc!#IQcpYnVb_jCAMz~>+01>yhr)WW9@J}!JN!zUP@did1Grx8AM +zHI_S5h7qFCmut^g;kkv-SL1#yKG)$BCOor#JJ2@@FC6!q@oA4w2jO+Z{Wf{-EcdQ* +zkC6NAxObE1?zs1mXH!Qn(0Ad}8=pvg`r^|MpD29j8X)(9xc}3B`qbZgz5mpzK6Rf; +zE_`!!`=tlBuD)^JoF`AW8Sucam`B?k9=YMwkYi;JM6`V}?YsUj^grnfzv=$+{_9`- +zyiJRCy;|M&L(r)cjehS_`Nb!FpWm>&%bYi3*Is#aM)}zDkprIksNSC0t5cixoVUrp +zX29AXpFH&Qm5(l8`fSklUwRzv+U>G=PtH5m>855s)}7gW_p(V>)M;kqbba|mxBh?5 +z`>WgKuXx>Y2_vp*_JZg0_*b9I{I$o`?H1%MeKew3!tCy=Hm<(o(f#8$j+r?5r-whD +zJiOhm8EZzKt^4WVWnXMLy5RAo-(SA<(|NuJUTApZUqf5fee|9$MvmO|RlOE36wLZ7 +z;g;WSXgd6gk8b^D+}-2$^tpM&ZS!5{r<|GbW4l>1+qC$k$GFDFLtlRF@QdLuw=3@O +z$G8@EUbFO@2?yT)=wOrWXXjtomNI?as6q4Jnw@cO|GjZXUkTfJf2U`|8};iFx2Ec~ +z15fA1F8}%B>bHj7zF|?b+5dR1Jy`tP#Ez-&M{nuZ#kb(K#b0jUw>9Iv$_;DoYFE7H +z_Pz7_MSXqpfr(*7SLDAv{qrwp9*T-C^@rR#B&PQrgCCtd^u4d9bhu_)S*zw7J{h<v +z?4339K0LSX(8POs|K0DMQ4_{rU#riUjYI06ees{%;a9kapI+VaKezvJ{PN@h56`dD +z(KvC#?Gx@Q-M*%M=d|Y<t(mg&$UnL1Wq;K@*0S~f=AC!ff2hTCx72@p;vGeA|I>c! +zuVY6aS<$0Q>ZG!$0hx!I?!V{S+A$mZURyhM!I+h^pWJ?S#QE0GjkxNuS8Kn}`<FLT +z7d0DmS@ODNqkAR&F)S!!)U7AJ{H^iC&57@wz9M4n<uBgc`^&bC){d$SJvH)hhd;Ka +z{ImDXN2VGBU)<bbRM_Tzw|49?v&D6Dn}-}N3ft^G)%fwOU8lEC$ok~+veC`9G&>)A +zZb6Hp@LGLuKKkvCWsTMqCrs!*Y~R71U0d{Cdv|>FFY`{N<(J2FefjupL7$&#FzUvj +zKMzj-ylCCmCI4B_WqQwP+n23<tf=U8&(H5%>%F?$#kl|UZ`ie4$W;d?jku=U8yUxw +zhxA@^ZghtRXN$jmXz%??9~~H4yUAC7|NQHUb{)UCBd61h%iijK(~aTTFVuQ%O@oui +zr%XS1^_)i+R=)7Ykwq2zT7K5KV^UF*`5S-zsK<$8w>~iFbichFU;Vu2n!|fOKC-9u +zLbEnapYQ!yY15$Bj=cZ+GY8-8G&C*eyTgyZH>ur&?K68^(|pX_POsnh%8ZBhd9Pl1 +zdsTSjl&R5+y8V6iZ*NSPzANjiyb+CZ@@hSPU!M#2bzAVk+G{_3t<l_|$<y1f`6jb* +zM&v_Zzts5s^DoUBIO6OxH@wrK?x3spWX+8KDfgetQ>Qn`%*kxox=G!qTU_7!;TJot +zdoQJYW1D-z*DiQ4XG!#|MmL>1I;n5=$)kHSH$A-MI@h5CeIDwye_KlE+fRMjuJ-JX +zgI{YD+hX?f=dYjJ>E}G}*|zVNEdJ?}GxhEm@<?g)_BQ#EU7MWCOBr$1UH88jvnO&) +zTG5_~2`%49JN4a<*W7ubAo!65nZJKtzw5UjL@(`F+Od7h3k^me9J(mx=&>Ir)Z#2t +z{lB%1dPYv1vupwKP%|e>QTH{ip5Gk{!0PY=Yv5lAX<^mKp9#Go)$r#uub#gV{Oa@u +zL2q?(#?)YcryArRufcxWUR0;|?i&2I=Bn!P@io|UwX1sk3izfvy~k?MTUi6Xah>Yr +zY^%Y}${Os1S|bdfORgIF<%1gdFW2DDuWR6+M?_cWhgLQ8<4)kKi-&bJ*;9ib9<IR; +zaW&}eTLV9}2L8?(^p1jq!!B_$)^|1FKdPZ!zt_M&SOcHdcGda$>l*yoxduDK(T~;n +z|N9!`KUqV+4+g$9K7rSc8t~&9ko^seuV~SX%UnC|2xk7le2QSm<eM?}TIOHY6%E8? +z;!mmZ(!ls_fnpnTxY+m`^+>*-HU_wsiX6A#=h0>b7p>{(s-?zt1LMi_Og9t!;82$H +zU>q~dJ;QJ$N|IkYm-)xJn$bhWVFTmZ=FERs<cyYfEu)PLu3N;;&swmYt&N#M{YqD) +z*fWVXPq-@7zlJdjolbhY(jpZXt)1zbfKDX-QMG6{jCYx>_Cv&9`zHfu3csn?d7n6v +z_5gGR<5Ym~SJK7>m+9vluM@r9op!!1{+Sxj^65N*u4fuC{%6`W;G%UkUDK~&{<bid +zbBx)>uUClt7zUbt4wZJjDS^;g{Pvr~PcUt=aG7>q5d1|k#PoB}Wh~!6m*r0udw!CB +zxxE!L%)P>Y8Z$ojXO>U<EV^<;?+>)m!)5BNC;l0Hr_(>-V$b@PEZ_9QMv0$qo?^af +z=bXz~@A&(ff0l2?Y>9_+i&<|G-;7@3&lA@<{aGRX^4Am=uuJ6BRrv(*aF7|-3qMr+ +z&~OC{raci|!^Hl3XhVpL_SbZ^7x~L$8EE#`pTh6)81oM?+-RioVFRPpv&=XB_Mr63 +zWZ4kX9*wS-guje7ez-2Ge+}cWChVWoFy==J{;1&l%VxBJ@Xty-8{e`3vmcWs{*Sa} +zpxN)=$oMLt1p_YH-_kWs`s)`N@8S+43GHfXG&lN>YNK#SFY0;)@el&OTlm5@2G(Qy +zbH$O*NriVM4}9Io89&?WGd^b<OECR*M(hct1tBie&dK73bCMWne@oY2((ij~v;1u2 +zWxBRX{5;#*89(tVZ#OU&<TDP#SzX_YoNx(DlYgD~bJvTk@U-9`mG-{$7c(Rs8+C-g +z^(Ds76FX1hPWflpGRD(616}><GQacZOfM3@k^cyP`7_K%_o=IqjMKF{m^S@(R_u(D +zgMbunwh<-$zL*XIaGCymP2{%|`7K$TI#;89_l<D&`*0bjE$9#hSEksX3`dcjD<lAq +za<S1w^4=>CG0>cMz7YR}Y-FHm|EChqPt<1oTOx<5ll*p>%t#adts;NJ2*!UZ{Pr@A +zuJbd)92cj>&Otvg-?Ve@)hxf~HO@F$AbE1}MaJL9YK;43y!Tnm4AcHyB7fZXPWj!W +zy*+PXd_$3QgY^5PL}q-3`gCOqzU6yNn|bD(#Q#HbaAcn2ye;uOU_Rqzd10)BSn}IK +z@msva)pqIkDbnwBPDxjP@k3E_ryq8U-m4`3#Vn&x<$<e=BN8Vp#W0#kyVk8`4(-$E +zy3v$#1Gm@AZ>uE_WPHdt)1T)=&POjZpU$c1`bXk<k$He6alQuuOzk}v>a>53#KSko +zxqcUs(^~v6+{^qqd^4VteDzC1mg5tCg4p@s2h1?-Tml&B{Yet@qay!;^vj+C#+!Ly +zpX9f?&oI!G^Nh6jWKY&B>W#N#o{Fl)cypc|D*0+4ZNzYiTaA9==Vfw8c^`{2s(>Lo +zZ~BJu&jLqRU&$vsKW5srr>U8TA7{Kdk5801@wQ;W<~nDnv^OsxuU;$s@_$&)eu=~V +z(l1A@WWG5sAD8v;UENr|X-}E(JKf>rH<WmIM<xVwysQy?>)W09&&1F7J;!>dN_<X{ +zd@^7p^Ud{MABn5c%~;Ma>?Y#|@!O`4oPOINan)PKS2w}Oikv~0vmDcJv0~43IpCcw +z{^=q4XZ?>Xz|3Qpi$7P(e0Q_RCw0`nQ7O!*K)$ByJ;~eeFJW5JqA>_&5WZChwx<r? +zjP8=(?pVZrFz1UU5{J*yp*gO1Se)^P#KZO1I@>i@{C`CR^UZ#|SJq>rUu6NkMep_E +zpX{d0Fvs0x!uN(a`8UdV>|V@rO!+Vq?P_R@h!nwM=i5!Wz0Y=F`+wz|u}AuSm<-$s +z!F!}#87*0k*<Y8-_==GME!zO&ZIKiH2n)Vd)ECIQamN_uzc2FNkbaMx$^3nSe+}~h +z^~+o_<f!0V$a?0ofc0=~8ArXvVP>4r`j_N9F_i^mLLXhr#1EV43kO_>)W7(iMEv~S +zmCp9QuHx;|^STE`@81FQ?5i>^Doa_g*)N}q-r1d4?>We&%P0AERTI{0_WK6$^CK@Z +zZk+fhSK{!P!E(%XLWZm#PRK%I7#FL3F!>?8iWwEc_sTqbMkX}V&b!2(i26=@XkAHi +zUe0HGibT#&vagx<ATzEN{u5$<zb4Eu_shq{Z>Q-CB3yN)U2SkD`K5bVeuc>wJKvHG +zjVwouA0&QmmI3;K=na$jIr1&bG2@|^_-#rk1IG*gu#BUpN*HhYVS(iT4+<D~x7ZUe +z`F6QX;0uM{Q2chcG{}sr*1``9W}r;Z#{Dv0W{P7zW%b5$vcCviSG*~HYjTo-<~+Vo +z<lH-o?KJhymOPfXjQI;h{&>mHEee^jU-)CCzj|N6cyr&>NXGB+fc^WE63^~i89#|{ +z#tq`1CuKr2^CxY8sDFFN!ns89{7=H4eu4#*h@2ZGp4;wb1I>OpgLXAFt};p<YNHB7 +zjIj;%Xx$zeuwUyV{p;T1lyj%V?d-v<@K@3MrsTbcuIBzS^Io#}p<zHCD-t_bf5q}2 +z4(5Bl_&Mkqrr{QKJtX}8Pc!|s@E0~`|Fl2FhRE<UR){}`_Gi91zGh3l>WG&(=rZlx +zFL`n*4JeKOg!s8s4$MB3_WER8w37+njGuYZu6O@bVvI_@8B@jnN{JtYfw~sSJiFpK +zre&BJ*NQ(sy2@!!Q|PC7h>-o}?;<B$<V>t$hMC{qhF=LE{{$Oup7VSt{z;V$f$5*| +z7)OM!BkM_@$WIqP?3~7Ovc(T{yhHfEB=Bi{K-UiG_gM)HJk4xlEJ(uVA7%b_ky9l7 +zaz(&8{1K5~br%bk;bfeV_*}M~1)FjHy5zlDGGUthdV;@ovlHK0^3`7+HsrY2*;?{I +z`-RLm$KwF;&ow>R9@9U!iJu3pWC5~VGwzUn-|uDqI*~tB@|!DQzc5nx*EVp<e?{c` +zXR|#m`DPRWM*ciMiv`~<@~23<j?HJFnXlH!`f&D73^eonL5b&^E@S)!k+T~l$=`K| +z`CkbCW?83QCkK#b{2vy-9h8YK6#0>^6_Ph%WP&y0El$Q=c`I)3Zwxo~N_!XI%z9rF +z{?o$$dJQv7y;q4nZ91`>zqp#QMC8AEy;FW)!B>g>W}NJmarDYrmR}}%{lb6wd1h>2 +zamLlsu0^uZJSqGZ;^+298863V##UM9{3C+Rxaul?{@@2TT++AEU;43`^t;)Q$zspY +z#Vo%_>^vg*r|Un=FyrkziNh-vF#oXNr^<RDsvR4C2>zvOHa;{jRLVYG*hZqX>*-?( +zrrw*OCu$DGNx$W6|My&M9G3Q;mw@Wd#RhGo2;X)EGfe*vly%65-?0F3pD|CyZ^BmQ +zoA^o@@7HZ|@>h!AYCXmB%{VzH@i4kAx7R0j_7}hP{e>BmAeXMmXgJwfTEw)ecck=t +z+Py5_T$k<;{^P@$Z}#sF8D9~y@PCKJ;YGKYaVcr3F_~F$8CfwgM$Fix)FdNj;IJVv +z35gkr<B~G75;KMk>6e_Anm8<OOmZTZRbLVlKQ)d7#3d(92XN5jnEORSzvQ^g%*0G1 +zadKj6R!nAEc1C<+OxCpYL}P4rYJ65w8tTMkq(M9o$uY1YD@mlpP)*o2HZCdINKPB4 +z7ZRC}I3{}>SIZiok(QN}oTx)GvoaF0(~ZpZjHJ}8u?EQ0__!=FWPDs|LULk;jwg|c +z85wCA<dUpJBP~5K6;JUKV^R{c;u7Mr;sWYsWT(Q342d5<k?mBifag-+3<%+7o7!xC +ze0D~1%(&#VF=%~!a$;O6EFGJXC|<CdV^>ge2@#`28mjRyKLKuKAE-h!H8F!+%BYmY +zl*~lEe0*XYdRMD3HZD6^2c#s%WoBn2rZ~l>q>V{}cgH5DP0{LRB&Mfj=#|l3lau15 +z5z3y-q;V7!snSo(BlpI{!ztq&&}o_I0!@5c)_9nDX*cMdru+z#rzxgklW2BYy4W@) +zBZ(BoB`1$TcN!^pNQ>97>4_O*(=t+w37ILWEJr=1$7N(DYA~~(R3xQOqlijQOy$5z +zN!JXWoD!27m!d}yIN8}r2?j!OT+Ep4v16T~myQlc$Hb&$XC+Q$3rtpgT51Aw^tyyL +zObFLPlO_hRvQr&QC2C4sQkKIE<s7S`!f>ZKP)V6Fi7Dw>(~N{<BnD-W3{z&Lr=`bW +zq-RNadUob`<bw<+Lj#OU#JJYVi4G`EO`K|q3(y{)mTd+-x;ch`9PcriiIcJuQ_ToW +zO`H;gfX~PplgI;~^9%9pL6AlX388{agt1IcHegIvQc7al*o3%g9FLTi0zhg&vLuzy +zpj*O?Y;p=zSWdJUGV$YWEVVf%fXBm%A_apmDQlVvCcDZd#YqWvp&DS-D4&pt=D{;* +z35ky8t27alkd_jcl*&zI4w7aXMvXLI)uw@{Oi74I8#5s>URn#GF%u`7u2U@)R(5i- +zh-3(IlTA-f%*cexZ3bk(ZigJDHa<Bm6CI>!)Z3!0Wg!$oR^rS|PmE`_LTf`#<Ej?b +zBw0(0y24BHqoXh|P3nbuw$%BKr0FPd=1xb^B`MTVs%280&k0p^kqT(;>Li-wFlJ(q +zpH!KOp&H6`ahFu2@us;=J;uZ(B+#%Mn?_HffaV<VFjb9>gJNssa1B}=*t|?wVn?FB +zfKbLx9!oQDR<>GUB*!TG;>Rb(PfSm<;!QERvk_sGniFCujj=U$%w(shXC!83#-vV; +zNsmjCS&}8HAhhc!W=7%^%)cyzntsV7sb>w#7!4JWH}sOY^z{EynvNCE{{n&cY-j2! +z;`O}YC_t)k_JLlS7(XtldV%Az(qsOMRTiX1tHx(RilkL5E_D4!%r)pwO3AFDBsng= +zdXrP)Ybrp>s#ZO8WF}yyFq6G*ni^j*w60Yv+Uh|WHQAC8mym=(0*kT|^(jKvkXcjZ +z%(#^Fn7HI|woX`R&O+74UQMF1vQtxOC9cgXx(Sn$<FH853e{MUsYM4;U(<q-md_bU +z@iIVVZlF|enWYkrRIR?2HoU3_=tGU>ZXT67Hz6&XHZdw`Xu8C>n1t+%7%YC&BHngl +z4M4c)zXRjqvtq_f`&U^6A!}`r)@yb%s<R^Te-KaY;pAv5s74mG=6`@CrDvsO{;Qzm +zxQua$G3gVtVluKYlLrhD>NwNeHj-ApSSwm!%>n<V$5P^^#$?1#jv0fcSqAMWEE(0b +zk-%9QQ~x(`YIaHthG5!%?_)y#Pr*PymD<z}^WWW=6;A^vZXDtf>s))<tfpC$;*)^N +z3`EKx(;X-*JE-hQF>pd8D6jIf5>t4<XrtDapfPn#*h<+eYI}_9Tpg~DQESEMkYRDP +z*sypGq-`4|3~jl?nb|q1Nw!W(Oir+UOl`7kzI0_Ume7~Dgp9#XD=t~-$0lN|dYGJ< +zDrXNW>DUgZ<i}3e7oTLZzDDHdfSFjBW3i#ZE<Gk2OJi$UC1vs1nOSKm7;4r=UO`}1 +zJa(zd6qQcxa!HCdBS5Jx3OR*lMy!(T;igrLAFFmPHI!Zw{8~*YNk#i7VH>FD4hJG7 +zhU8bP7$+U%4Q*c1t%ls}MC`Nz@`NTlK0Vv%O}+Zq%xRhbQd(VS=+$fJ5uS>48?ZZz +zuUSvrIHUwIvj!g|B*n$hnT!%rEoO4+So9xamG+mMj%|mUaY226kuVKM74Z|TG!9Dx +z3S!15jT?_`Wq{WMQM3s7uOKUob<df0ScRsAazqs~IW<Xnj6;|g5}HSy#U>RqCZ4w4 +zG*KmKOSx)_)3UW#w8~Tdy}Dgoef8{ruWlDRs*_u+=Guc^_m*X#!(BABJCECRPQXxi +z6hTZfPH6%Xq&kvNICgqGc4tWxQ08et91d17ZK=auhA>B+`l_IpEiVOy+NR+sH&eFj +z)WH~S)=3~g2U@8B<b+G?6Fk(|$Iau@(A(B%5CnFfNo4aS1=zx9Ykxs2roQSGz8qs* +zA|x}04vcNKO8)U_DJeL2R*NlJiPE8k-i4TZaE2O}Y>dyu!4<Xv8P?GpAM?ReSs7{5 +z3_8ukA?Ema90j6#GmP<4f=A_JK6A#(fOV?9D<2vsQ#l=5W~Ipi4LMzDwoi`r18SP0 +z`5ZJ;tqZU@MbBA=u?eg-om{P)Zxv6#MqID01}Uu9PFCRsIw5cv&OM05VR~9Bj$zSE +z)!_8(tV{#RJ{||K<^d?WHl9u}l2wG!M&Ak_^FUvn>rLiPV>K$!^z&*nD4nYWlUr@9 +zadq1CCS+qN?}!g6%gi1FtyoA^TRJu)37$+2JmNEz#;0XuBq9gWcM@hAw##U;xReby +z;Y$KK=&PxeHagXoX3)yh8MmgkxP%Efsi7%>7A}{nb&TYHDV~s&g#iB-Kn8XRY4Bx2 +zQf4*wTWU;LMk00qmpI`PSf<Jbfi85wXg2sCl&am$e^*Md>XoX6VoXhb;8L@7)!XC5 +zRPO;N=HDzKT{XAemQ!=XotWx%rO+m2QZ<2-j&EcVv#_vm=4f+dsZuJ;jKQ}wh(JA& +z3n&BowD@YrNCq}g3E1}~A*?Zu^jvQ$7>}<vW3W3LqerF64bIb7>x-<wsmO%ENaW-g +zs6whx$B1@V24K_*t(sDN?UsgI{_i3LRFe$kdv%COD`5z#MoVTkW`qp*qWa=$lbO|k +z8q%3nUQ<G|00Aj2IcZFMhs?ANw;M5u>MPcmm@%}spf9Dt!Yngj@W8(PVmf!Yt*iBD +zKXvKQ+2VHY5W!z<*E0BjCWXH##A9vzTSrQ`oH$fc%W$bu{$Bply3FBHLi7KEjQ{_? +z|L=kS#RD9NL5RM2c!vwGW2kH4GmG(tlFKL(-W5qncmt)5@vhJrEt2piNNr=Q(Ah1C +zu4Q}*nlAJAxbT{Yx^j~F9xcDSW%4719~;0QU&0YRK7c<(_~`+Bukfb^@Ye`GCxBlp +z{QLlZneYn(_}>bDNdW(p@RtYh8*FF$O9J?<g<lrHzfJh%0sLOVKM=ro3%??OKTP<M +z!})zy%g;i)1Niw-Y-el$-#1G9AHY8${PY0+Z^EA%!2ezNIRX5$!p{%j|0Vpw0RBbc +zFA3n+rWYY`Ef3(=6@Ezozk%?}0{AV3Umn13EBpfi{7%BJ2;lb+zAu2^OZb%m{NBQ^ +z3gGt<zVV>5ANvVEIDmh*@IwOl1BKr_fPath!vgq2gdZNjzfbs`0{BCP-z|Xufbb&& +z_zwy{Hh>>5aXUVMpDg_J0RCj*PYvKdF8rJT{vzS$2k@5*zc7HmTKG!>_#1@3Jb=GV +z_(cKyUBX`<z~5)$@8kZZ*Foi#P!-SXHNL!ZsrZ{T{yD|re@Zm|c#U7C@#RlhRcX1# +z$E&s0bwJ~vx48IS0gWH7@qHS<qsFh)_%k$qmB#O)@ta4pAL!3&R%-k(jc>kVNX6kA +z-+Tv__?<L9X9nWpx4ks}Ps~#PMrwTXZxpD&t?{EZe6+@|t?@@_{2YxRtMPYf{P7we +zub^62y2i(=tkyME<Ns-K4I@Y6lkdzcU*nr|0F@PL{0$};_az#ClEz=I@ds-BB8@Mv +zgsRf@8XvEwTGu9xk5^x<t3>11;#WgeS((PiQr5c4HNO05i7Gpw@q20b3XR{#l7hdJ +z()g(wzf$Al)mQ7P()d^i+1F4zZlAKbMzF@;t?@%NzWL5C6*t%T-86id#>Xqh))lVt +zvn?*-U*nf*{B9b*iN=rA_}w+WTjQH+LMo2d_~zeg5PyWmzmphp#cKQllZpFyjbEYh +z(=|T+6vMivYW$NH7xAz0@rto^<!gNNoo*^D)cE-p8u733@h4E$wOr#rYjN=#lNuj? +z(qUceHNO1GfGXRh@t0X>{7$6CpR4i9G=2|_U#{`ZzkR3T0~-HR4PT-0@#?pA`80ln +zHeM<<{_7UnFsd~ElN#T+-;V#MHGZ(h$Dck}SBS>HUenuL<Ks`4tSe08e`j%#|26&` +zjo(S*f1vTZX?*$9096{P@o(4gZjC=u<40?Jecl|Q@vqa`6|3>z(BzEQ_$@Vly2dwu +zFO!O=YWy2C`8gUNe;Q?7`5ON-i;MWz_`@{*5{<t~<1g3vi!^?b#=l47uh;l*Yy3?b +zKUU+HX#7NtU#9WpPh3@LxyHwzELhh8jX%cXV%?(g<21fc<ImLil^TDE#;?-&qcpzp +zfF1w!w0;TJ_}1Svpk9c^pRCDguJO&kVWQ$Njo(wlhiiQN$&Ph(()fcdF4jL9|96ca +zsqtm&u1eh+|9cG|t?}hgGF9majo(Vc$7=i^HU4;wKSkrGYy8m~f2zh0)A%_W-~0^^ +zD$dvVn>Bo)#=lSFFVXnnT0bt=_%CbtB8~r##$T`T4`}>N8vlBYU!w6_Yy2{ePk-BJ +zUgaA9kjcdTfX3&D<iZM#-(SP~G`{&;GE`it@!M+nDvjSx;~T^5_+PH^gEhWe<A-Sc +z8#I1%jW0j#qDsRw{wWO~uJLcw_?<L<rpE84@o&=jks3c<<GVF}Yt8@B8vkYuKSJZn +zPjINxSdE{h;m2$IU`>9y#=k|wPu2KSHGYo9FVy(?8vj;}U#RhK)ATOU_&;d)<r=@e +z#xK(N9W?%Wjo(I-ze(e7)bJ%5zg**&Y5d1Ee!0d!s__qK{7xFbLgSl%TS>(}jenbl +zuhjVR6HltNO5?w(;SD*rp}kjUjUTM>yJ-9njelC>H`n-GHGY`JU#s!mxhI3&1+J)H +zTO01Yk}Q|6pbj>zxgQ6A#Gs22V^DOlT>}1X(kc>9M31LJf5k;y?M4z!J>)M}^!-HF +zBDzG;gNUw8^m;}2B^pW$|8hllCz`gX{z64}CYp{g{5gugnP_s0KV8wSiKeZnKUUE# +ziKeZiKU&evh^8&0KT^^4iEco2Cq>sHx*^eFia!4fXxfVTLlk|QXxbwA4MiU(nzlOr +z%74IU_XE+imGM_7`Vi5yh4GgwdLPlW<?xp%`ZJ<0Cwjf2cMwfm1OIYG7ZXiOe}AE( +z-yxco*!~<vuO*t6zW#JYuOyn5w*FW}FD06mkp5^zFCdzhg8oQF&nKFebpB3?o<lS( +zdHi9Do=!AP{r(U|XAn(OxZhCp1fppw_E-K*?H@yQ7||7q9!d1|M3*c2exhj#@|P%j +z5YcUjUa#oBMAMYuU#{rxMAKB@FI04AqA8{Oa}<3u(Uh9~>56VmbU4wmif&0XrDA`y +zqMH#-Db*jT==wxc3iNkUbS<JOmHERIef}h9N=g0@MV}^`Qjy<K^l_p)5?y&g^*_;+ +z8vGTCK14JPeSf*4_YqA)*k7XP&xod>>tC<v9YoX6^e<O*G0_o37b^N4qG=1^&r$SR +zqVFI&UC}Fv?nZR1qL&g)TV;Q=q8AX|o#;qK&nKF;e*R91o<lS(0sUc$o=$WxqC*s& +zLG)cj8;YJlbZ??7|5E)=bR^LgiXKUHAEL_@eLvBCi7rv}Afo#by<X9MiSAGIaz%G1 +zI*RB*MRz9pZlZG(eKXMmh)!2@Yoci>;Ez>wOQHu79j)kQL=Pf5QqlE^rmcm)lcH-8 +zO-ovTn4-_006m205JjIR`d*?9MIR@cmU#Zk^Q!-ejwZT7(T9j0N_4rR_Yr+R(Itxh +zjOYi5Ua#mKL=Pi+xuT1S9!_+jqTeC<L85aMy_V>Qh)!4ZN}@*)9joZ2L_bV)w4xUf +zJ(B21Mb9Uiwi^CUik?ICBSeQOdOFdxMD~X$I)ms(i8d5Hf#?{bE6=I^Cpwns3Pq13 +zI*#aaMc+^K7@|uQJ&5RdqSq_BFVP7^FIRMTq7#WORCH&e#}b{R=$nZiM|8TPTN6za +zkUv(@Es0JdI$F`qh@L=nq@wE+J(1{6impX;GSOj*K7Sl^3eh2oK23Bg(T1Xr6P-qM +zWtHlGqSJ}4Q1l_9ClOt)=zT<I5M83^&xp<>dcC4|5S>Nzazz&tolSJ1qTeB!wsig+ +zMXx1#3eo9`UP&}9-TbkNUP|;dqN5ePfavK&M=E+g(T@?`NzrqNrlpWSOwrSco<Veo +zqBDq|NwlHp2}I8#y7H{*f1-1Uu2A$yqGuCbuIT%To<nqrq6ZP3OZ0k0_a%BR(aROx +zo#;HG3l-g&=y^ovDEelipCCG2(XENjCpuQqEs6FJ9j)kQM9(KWQqlE^E+D#-qH7WT +zB++4tKJN$ZB|1dWr-^=wXhYG*iGG^s%0E^A6J1Djg`y7;{S49Nirz=`0-{S4{Tb2E +z61`s0JBVIL^m0WP6TOJ&LPftr^kSlO6up+{=ZH>M^h%<a5FM-Nr9?kZbhM%u5WSS> +zNJY;l`URppDS8gk%ZLtB^mL+MBsxUV8AQKCw4vw;M88aQ<sYj5iC#{0g`!6iy@Kd+ +z&~C3Q1QV>=+l%Je;qIHN+@53Z+^WV?YK{H~3(fbA@<Q|U=!+G!o&^3N5;E}na5M4S +zt7^MFJKWok_jU)ByZ2UQtIDApRpotIr$@UzJ1_n~^>cbXk9tP-jqcoDt5FOQo?}@J +z-37gV@U=F4?P0NRJpLKI)0GZj(C;6OrK>}eRuqD?)a_MXfofSdz_|OwxR%3VPchh# +zb+LT3{~-uy(kh4W{(JCDI!1r=|JJ_`xM!ctua5?Kwr)Z{cs9I8z2R9@q;B5jxb^qs +zt;cP!$Ge1>1yLbxPhKHEhT$<Ej|uLAI_+q6<@QARZYwFxD+7}n?)Gk={@z5-#gWAD +zoOOHl{_cLAN-$DtC_xUbp#-yQ4JBB2Raa7)M-fH_j4jPOpdQ`1s<lRTE4R0iu|LQt +zrcCPgM%=nDh=S@7+<eUu$GKa{AI8jvv(*EMnMrka{|9v_+oDd@UR9?j)%g+V+!@X5 +zO(xK40#OPE=t~B5CD1m2U;+7!EtpBbsSI4pz>Wl5tfYk-*>yM3%J771lX9^)q8&;- +zrM}xS(?a$&ptcb}wceLb;tTSqJ83j{BkDQJqft<hN9|Ije?y^GyE9eG-Aes$WVMDI +zdSW?8oycGmoVXJ54?FplXOsjA9hN{(EMcn?xf4hw;e99nE%0-<u2%x;VW_`~;uCf8 +zumTS(X_>Re<ET*()m$}bv9l<S%qdV&%2l6smiJLr!&TJ+XVDEPVxN9+nuNHrkF+)l +zhBx<wSOQCZ+o=;!yTH{ErEZjYRlpV3<_;YUnQl)h%c%pfCvP`7#G6-vP##-qbVN20 +ze|HdnH+kQfTap##F7PVvGqm_(5DlL%Ak4S>cX*CGa;iMY&|DSz186D;J%We++|BNS +z4JsJCTWKh|y<Qp*ZqMMh!ER5Two#t#13i@(lc=--l|CdjZ0-BhYADCRGVSDEB|GWK +zwo~;nLv=gbnsyF^WVd$_8?coI{y<L&D~)j~?ITJ7;r?=?Tno@=RJlmXt3aY)F+)r- +zmb1^EV)GS*2EyG=Ndq9MU`9B+Tu2TnSfuhB(h^lbTVO#S4<@2g-{{|{+sc5--Aex& +zS(hVA+z4^(C@&<PNG^y92R07NA15{ps=GK<?}ll1l4K!MA;ej+Wr5P^*$HKxEoEWA +z6>^EYV6-p6-Q^mUdT|Q#btNpH{V^r<Q9RS&peCd=>H<PhO#OkH5_KVW#swp*DdaY@ +z<d(rEUmFx7loP%|C>K!N`X>Eq4uYSlOS}>FolOZswSuS%pQ?!s>cZTf89sMGln+xu +z6=Ldbihpm!_j}Nbl)kvJyU5Z4S3~G2Fuc*V@ND22qbGNU&uB9DJB%I(sVayJ&aJB7 +z<cUJi2pI1bwB&<4S4)U3s8h=wUk;)X=?E&nSV2`dYUVigjZ*rku+-NP4kTbPEeAhT +z^1yvqL(KT);zj=`F@fa`bINO=p_?GcmAo8XUOf%bp5!%f$P07I+oJr=_T4AX#bvs@ +z%^Kp{laRNi7Q2Y;^L^p)??esV8`_n9Q!%ow_9kfvFUgzekoUe*-qjkqqZ%#nAN{DC +zC9j2s=tc6bcF3FSl(!2}#hq2^n`QcMz24qWHN-C`Aa56?KdXQ5cglNALvIsHiVfYq +zX&T~1lJ}THUTdekTQu}G(>{7b$7=6Q8e#~^qwfuD`%ZuE=#RtF2NZwznekVoxA&li +z`1?5I9Y(1wZ@W`ofrj2=_HUIg&!ZvUBzd%%vE|Ko%Il$_V<>OZ_@M2I)!sWb#AwJn +zaTj4QK0TCLN0GRm!1M4vi2%R~=o4^@=_f9M*jq+<px1+7`L<GVfvfQW9{vB|xfY&j +z?hKs`0N|ZSpq(#XKn+eY|4*)<(L~SI$8qo(un=~8D%_rrO7n711m_r~d2{8-U7A;9 +zK5puH@9@Ec?}D2=c@<z{Y3##Ixw5zws#%NXO*up@ap(GifL%`@<_z@g=(7c7hDDe3 +z*{sp-?G<(0-ssw!LcmnjgUUD4b1{M3XHU5&mV~%(`j`yPEvfC^?yH3=wV-4Zl$7S> +z<6njJhOWnQ5*^eBzd@;W(0POey0OQ9?1bJC&z=wt2+F^{_i4y@RJ&=(Ln5==v2!p| +zN$3R(axIKjQQXdPk>8#Kx+TtY3%vA1O9{FaC}C<%#CqO^9*=Tz?pEdMtoF8o0#%^m +zb&FF`Pg2xEDJq2AW>DlV2>tF58sjC#rHTe!qUa7=k(kH&usl&JmpD~^>W51D?{<{t +zErf<!aCTVWr6<t^{X4&c18Kd-ZQGB$=4{)4Q<?2l`5>w6qEs${qSnft^kk~^hCYiL +zn#zR#Yn2n6Dv$c0vIH|<Y2Gp@YJ_esroJxl5_zdxe@BQ^+s3*oKvb_g-P*^gFoP7{ +z2Zh@(CJo=0$jk`2a#p5pc_nJwR}agW;=M|0L=<EoH_gP&cRd7Pa2`Mn6vFQ1cxtL# +zMNjBj5k~Q=x$4fEEa%X!#`2C%%QyWD%NGHSaS%&IcJ_M_MY$@!7&FI|=DiBd^wmXy +zm!8Cl#nfKSo;AqVPEUs00V*Sb7M4w+isP%444@xiHp9VF>dQP9DCNJ!T#&O>Kl}ut +z)E5v+KIPTQP0sdh1qkKJv1+WeqjGyo`y!Ql^Ga0xQr}Y;tt!uXO0js~q<pYQ2`|{7 +zWH3|~@14*roKgUVJvaU}rZ$Eys#Rd*Rt1>}BA6ViV9J8x&m5WPYHCK66LN$gb|+QA +zRkYPo=BTz5EFyh_y{;ihB$y6=LIqj?q{1Ee*0eSE2PsCE?{z9%3uz~=#eCRQ)s65u +zl@-*iERvO#h%)-=?n{)t;Z)YkR91(T?Q|-;j+9Bl&T6Se$0{0K+C*k{VX3dj59AEj +zt>yL%ABJZ&!>3{9K!a19N;dz94p9@O+w)D}#^%CN5;wYvmjK0)?6TXbiQZnnVd>!O +z4uvNFZsy-{5d7BQTU((>wKwr(S9peh<Ms?GAMA-LD~+Nbtu{)dsCRL@KsWfk9$Pu` +z6Gtas4lB{FVSDUp&W&f;x2VKYf!HmcOcC#mIJr|<c=%H!mNIHX?u-gP^C>3O6h`f2 +zR5_tm0+l=C8)I541k54=(W)JyRxoHgfo8C%au$_FDEa|#pdMq?+k|?EQDux8NT}(I +z8qTPf2z47!(s+Lh41QW+FHy?{jDv!x3hb+BoYczdg@2~hrxDZK|2E|0R@KhxpIcR@ +z$=m`^{+C#E3}kA9;waqjr(b7>ZNr>JWmNPEiZ0RUZHWEg@N#I!CQ_Yu)V+*?xJjPN +zg6Eb51sE9}%z~_v?QDKoL1dkqc6iFM>kR-{?Q;iKwMwGvpiUo8nats@ViBvg&V?pm +z?~6@nfMiXzJHAXcB#3xr(w--em=zT>sC*|pR4|;7<#e2(Qc#Rj*^=+6qs~xxo|px9 +z#yX3qp*T0HD(J)mC>u>>cK#fVvJ*W}xgILBsk9!nJ2(VPY2uw!wI^_!NRzKMRShA* +zfb@v^rpc3saU6spFm$&)w4?B>hW1ye4D|~TUz(e~tDx4Nv5p9$F$@p5J=x`+;kz*m +zOE3&Kl}7n^7@j1x)@ZC`O10V^n_gD);dY0bDNqB$Htn*<<{NlcWAgwHf-F=lKFr}5 +z{gE1*y<w~GR;rpiLk85ng!+b2H#4d$p)La|cgAiWn>P{YTL!rp)Q&*kqiZ3mgca5% +z)OU<JvO_5hCDay1ZDQ27r9d5F)MiH2BGe+FN~4rV{PY()1yLvUu~}a2*nAj3du(<A +z<){DL2fF1WXD%B6>He`?w8>d?D;3>?qDwUL*epSyq6gL3q;mrrn{UGYOW;Tzk#%}R +zotas86N>2w`ywt3#S=Xd5p;S(f`ZC%lGyXH>|hM0ps30dEiWmXk$oA;Zi=c@h%+_n +z$zGE?qcW&TUa)11l@4f3E00m4AU|3qG%`_QCyJ^7fK`<eg`=ufLW$y}ohaHk{rSze +zGy<wrqHxsLRCA($Gl;iIoEv}Gtf-h~qSyqg#7Y#mf9x0sX;6mYL?g#f-vFZLcRLY7 +zfKUhT*EsnR;O9o2<Q&q1%IqA{g6bfL_&A4L8i>dtCnbmcf$^Z_kng_X9C8vl<YbSi +z-A$hC^0ykQjmqpC5`<@!L)JqtOuiT6K+7RZAp`S)l|#aiLvWgxjg#x)blg};lT__& +z?7wN!DD^Fc<5YgDEN};_a?AqTJ!N<9$c|KGw8h2Tz=2qaSmj=*;$DEHoo>$_-!BI* +zUc|Pcu1bj#!(xfoRgQIytT4Q;c$<);P*3)ccH(*uqZ(}sb-MjS*owq;ai^WQe#f)E +zsCWSti*Z6gwSVSpa~*{EGEp^m#*fA<S}sf`P;Un9U{DhR-K*roFS#Xd`#cA8mw6CO +zmG7j=QCvBXD<8(q*VL}u+^W0`!Jt>ZfN(D!z?I!x`6a6S)gkJ&A63%AceACwe&3;~ +zs$bySXnc<Xs|q4R@Dia~JH1D8hOiui<%}gcPeKl1OCzzGrKyr0Y2mCM3x@v)Ulq7M +z{KO8YckryjsSiZLX+0oD3#WS^&=E^Mx6C=fws2xwiE?ruwV@-XM6#eDx{kWx2#k05 +zXPqJYGoprZ6ly*M*PT0>%w0i7dn1lJv0DV|E?}qNTuq#YZ?fqi9?1hTsx2-hKd>Vr +zgT2u~N?EX{{Q0xz=+UDh9qNPOcW*?YQ*mEYu{17&#_C|;JWgCo6X%U~D@$@qn!7#! +zA%7g%k9K+^a-0?X2QY<vtu{k+tWB!tIT58mK$I-%t*;KSJh!HQUX0T!R0+s-3Yf<N +zR9urGi!p0)<JG@b_t<Iq5vPDC5n%V^O_b1m1?)Y~@T%MyRmQY>if06IA0W~Af_g+% +z&74V#CTiD>PN~0<KOCJ^$Lvdzj<(cN0we2G*I5!%b(G|j&K1rgNJcVIGbw%Z`U@4? +zYqiOyV(H7*C~$G8<`fcbqtJt;zDm%TRh^^3N?8$mowb|Uwbfu~O#_--W=0tW`NEPW +z@0TDyC@+XHEnp1PsAfIul=<O*oEC(r-0ls15PpUIrA~Aq&=~A{x7*qB6FjSIS;gzA +zUZ`kh%jZ!Wo5XV5d{L?@y3rakcr^2fYnDi)<LFG5=ndVcsz<DH+RzY!EQfVc%h^(% +zagj#Un$=1txie(#xfvpg>5V`%sg9D`s|Rkr^<OIw9zY%p#yGFU;<3`m8U^1~s?>-# +zD)^bR07YbW3vdqDt-vF<;zV;4Xl(+hU^qq}Pj=MXEBA4KS=NWadgS8lifSzPu{#@+ +z<@7EaEFV;&+&LRJ-=ANxEJ;w?ngimCqcLSRLnZY+z!uZ1YpC9UtH)CHja(hA)J(K` +zhS(S?<{U8`6Fq%7SY>22Qf(|yoD+Cwhx|iCbnyR8qaG%!=mjoVm5l=`#K;@C`L4Gb +zrMjbvTU9_|?`TyEs=t8iM{xc5RR8-gl~XFsE`fd0!Vq~3XchWKH4CRwlwi0eCmPu8 +z3Xx{ff=5Bj<%Y$G43-7Rzi{Y9eIA$=)+gIZR;9v=wt8o127xMWzcMb{j}^Ifj1uCR +zaRDbJr93>t(Q0jGJ*5K7)%invc;0|#Pe?)N;*Y>X3gFq2PH46D<!02QLRUIa7=fp@ +z+LQS)Jgdok7^^&i69rA>OjNbHKExV%-q0w9&vU}>V+#vK0g|z6u2Qfq2i@sgPUDg0 +zTQ$<?i+-xlyWv++^~9azo?^mU>!E9uNYudy3)!mz0QF0v5nB(TGO-_Ktu3`?H8z{| +zqDlu5S2*olErO(Jvrl%y7dCFs)&n?{*S}|~x~;_RT~rCKGIFy)TRP8vddJFhKEIYb +zcSjI<>tWV0eXGND{ge*Z+z;&Dnu=!{YD$mfQ%V5xCesQCfKT@0=KG@@P4(tgK(*zH +z?Zm@bFL+2wG*uOZzKCoJ9GR%zGg*(yAJUKgz%lIDdsq@7$XUs1xM8+baySdP_H3cR +zP|h42SRRJgH+)pNKw0BXDv9jdgx(2Ii%nBXq-B`;?~$?UbS10QS4ES9N7EV3<!Zi! +zO$P$Yn-_$BTtX%(@g7<iv7&-#QxPohX6iJ^7bX!|2c2XTxN;!?`%sT-x-Cfs4irv7 +z->?Z=Kc|*0BA=o+)77qIzppNQ#^o<M%44Pc=RH)*Ra9&bq-A(k1L+=>u_9J(aYRFe +zsu5L%cS`tmKD<*h`wPe5GIw3xP&bRX$tmJA;85B{l+xh3k(H|9L_3X+s95|4Il~+A +z0BR$eJh=H*Q&pP$`1=_`y~(KdjC!0<WRJ>EUUxL^l?d&rRLncIE*#JAZMNH7glE;} +z=V&B)Bi_O{C0g?6Q&anj7(UPmZ^rF=Kon5>2CxFFeNUre@h5C~CTgR7YjE?Gs$Q~k +zJOabjP_xr8?d-^kFLNq>9<{Y3XZJ%S!&hu}G;4xV=6ZdTJ+NQKGYxFap~}NIlAYhM +zox4yQb_S81t(<lumR$)VhL%PnSPb&N$^;RQIu)PVU4xwm7=8{1L7Mw_01lzGH9OC4 +zblSNM6^l=^oo(38hjH^wp{iEAJWr_K8TB`GpfwW-HB>23^I5pL%}gOIohc$5_A+)P +zVcY3gjKJ(qRjgrcQR+KL`P+l^Kv_OI95&wvJL%;ma!Nn8*&BKq|LI;x9q4T3H@j+Z +zN^N$^j~g9Mc@uC5{q=pj^M1gy-g(ENr#J*D1<D$86Z+%k8$(qsr+iGPri}7I2b}T} +zp?WF>Xi07fvPr4$1GCG$(dlYX(P-N5Tg7&a6+5V*BiRmb=s<30tkd$}Khqi-W-Tqf +zp(7do*ZYo!ehfH-y0nI#+aL{<#b+OCLI-X_J8r@m+<eniRa*Pe%0>nBl?3g`(DP7) +z)_zOSdj(n$*)Xp}os^tJ#whN@$Z|%0PRO=|w7#R+NvPWxwU$xEg!+fWqJp;6nC~eg +z(9#fFyMoA0;5<cA%pJQo;sw+pC*PsGiS-?=SiKR8g<ZjYQDN@wQ8Y)2KCz3!q*j^~ +zt+k6VK$XCFDcZw&Xt79o9u@Xfy9T0H6%Cf6(Na_(dwaYpDJ5OhY#v3%HJ3_Vr6}B% +zhg7EIwUweFraU+8W-AIpr2Hx=_m)z(L#j7AT8ipOQAU|nlrBZTlk4HXhwP$QDLO7i +zJ-G<`m{MPuQto>DU3+w{!n2wJzEbHU;`R3&QFs?>2c%YSsGp&OoY2daBG)hxPU+vx +z!mYGgj*7*J95q>}jVPSE0Z~)NjYhZNybE?V|3tNv*NLFJag<Uy1`gIEA6w;Wj5fE+ +z!>Rm$T^_6O9F<gG?dvzGa@U%7Y(Kn+XXS^6+_+cXb@<_SSZMhn8iTjYlZ`imhHr9v +z(N`Xvk$Xd%am_ByniqDGt*&08i`;S>>%vhs50iS-d=G6%ha4yv{;|6ty9}LJPL_Az +zw5y(1vR9xg;!1dpiZ8O`NRE0Jl>Xb!j(0&@18BVq8cMbJT~HXVG^kUmBq;IMr*0{5 +z@F$^1{c3h`^2uKRA(|tc{Jn6qf5)Z#he`h0OZlhJ4SuyxbjtDXz*b^LfbjPKJ~2Lk +z`5P?3w|dU%-C>4$1y8w`PN9CGF0l`TlE{(XMwCj5u~kJFM*M`YZ4r$X0Q$O{eujg8 +zWd|$&{~*r@BD^&~%e6?7fUj;z!mBJ{IZ5F7bPZf@$5$^rtN1#pvSma+z_q#lKOC|6 +zO31lW$Ap?)sm}2+e{#()*E?!1<5>Q79qXd_+KXrCvWDG3R4lGwGyg_yH1u{db0}4{ +zCd79M^*y8ZGwK#X-NGoDbG(H5fl+TW>N-NXxB;-W)c2`M^0FS_1PAWBI#->#(D)9a +z3PtvKSL1t$O?RU5d_}v?y=D9J7d$I}enUa+jre_?!z=SX(#9)v;C#RvdWxY7oX}B# +z!fDGyI61J8g<B3hfQsssSt$Adwc)@&(0{%VRh1S{)<pXzL4#<U>5X`Xp)KD5^cZ3q +zLyl5VusJEuCTuOnCNlO)!fv*(YLM42(W=55=eG$h-fL-lOL?!pO)Kx6=Lp&IrtQ6T +zcvjx~PG#YU4R1NT=Y|1Rwqx&67<xm0V|cU^-a^^y8Yv3MgZHum%Y*+x#p3I@snby# +z9vp}k`@Yz2w$1V&%|ONUAJ>Kl?_+3Zg1#b9d#N&;kYS8$$H>-%oJL41u168-dPZHu +zH?dIN4T0->faO(co!5z=tr_|iLq`)d+=AMjSBJ1|7+b{HhY5SZ>@9CZDvb|x*u&hP +z&_sg)kr<IIB^Rv{84!4xg&KlNKbl2eb<Rh%dP}V&R)G$Q4ikYLr08C|sFM`6lA<oA +zVGw>5$9&Q2c1SG4vkHj@7|u|(@(o8wM4+}65(q0k7{$v%o*_75<u`;7Agwq@HGvE* +zyH%-(b=@iIC_vh?I{K3awLtxY#)5oJ_B{pxdg&_4D{oR&YuUMnP;TCxY++PGLOlT# +zUJa_P{<v%{fd(>YF@x$7Xp90KsG~r61RBJkNerq*pk4rND+Ay6E_Hx)*oE&DdKm!l +zslrB}{C`qyI`1O5b;xroij?O)H1iyWXw4D7eP|Yz`fAHFj)D+HN>Tyb8Lj%QG$#i< +zq*=u;&6%rF1;Y<`3iDNw>z_5~K^0Y=Li!V2(p;Le98YwCQtQ5Mlo4PL1)ry|kV`5k +z%C2*iEa8$Wx2uSrP~O-K8W%O3IJ;H*Tq&ejc6f1kR-tn}#snID-Z{6O-^z`?G<-0z +z>A@4k)%PJ_HJ@!!)m;~gSRn;ZC7z+s3LYOirZ|rb#5_#l?(LOB`8l06`_%HNmYTA+ +z5|sWJ8qjGBoj}kif?9F*9HE|I)B}vlB2+6z$=4Q>2&Fp08_}LoV+eKb18OjuM(cR< +zm8H=r(OPv3m~A-bGko`ui>)}LWkm~;t9sKL@ios2caYo_N-hG9>RAD|g}JIb@1t>T +zb~J^>0qU|lb*>~Dd&YVlA*%kK0UjC0+I(n?uZw8YXRKL-r9aIEwg+RsA#7d7Voz15 +z;zR|S+9$VHsnd1WYCBvy<5`7EQ#I})c0rKlnO$47OruXetr`9<5~K!S1~@|E+t=*y +z*o$Ws9&(yfkF1tcwLG3D;-J$vR8^I~q~h@S4t_R|)<!b)9)jLLP-{xrM5wpe4P6=a +z2cZlR==SET0mNr;v^0@3xOE)Moy1r=HE7GmdP8YN2)Ax^Hg9Wj4c-{W@Ku<4G;cfw +zIE3z5WqaczJnP=*LB@Z|#!umi>jCKW^;1<H-UuP+XAB+8&|U;>E>Hw{rF_%<$tI=v +zK~YRC8^nsep=;FGh&bvr_2_1;Ws$U{!dkZkb4djh8n_=&cW>xguD-=NA-#&~P;%^5 +zyQK&5tXe8>m_37v#XpiTZ-f`Mkrt+r`46kAQ6*Yh7)#J&3?0MJc!G8?p*b|pF_wB! +z(>+M5c+03DhXyH_?)Me5l9|hynaN13_=cCD0IgG-tqYv?%V5)O(4fXAyAvogH&baV +zDLt%8)tfxTzDn31Gn;f0yRop}v}H*)r&2>opXN%iNmV*WeG2=hN~MB)nrBoi3Um00 +zY9AKZDQc!_Nh#+`ma<2R7i_qAac)VIxh_mwJEQh1Ic{s-_>pvAlk1lRf$T_|ePl>0 +z>wXU_i|g^;;@h>Vzj~uDd}}r;y%oHE!rmAay%8fs?O|AzTN#AE3La`2H<b;wD&WvY +zz)x|1qD19EYF#HO%H$&SQ>pJPp3wyQwohfyt7zQP4xPTTZj#sQqV0$`P}Jo8sQqjL +zednqqY+w^gkP#&nkgm@tv><=A=E(x3*LBTGJ41%xS!Kv|WSci)4V<A3@-?V!O{QUL +zEoQI4KHw_eHI6Eil|t9X74~R(9nWgC$O`OPR4ne!-j6|TjFx*|hxcz`TlGnFJVARf +zv@1g+2x<t_?)6l}1RPg&A{mZB*x9p>IWO);MXhb0Qw0T8j%xg_NzzxYrM`dO5gN~@ +z`PpY{GejG@38~);IT)uoYP|#e4hye(1e^*EECQ*)0@jNr2+u<~r_EVz_snEGtDYII +zl0-xkr<<F=0IO#r%~i5m=Eyts{XIiI*4E1%_>g-!q-jnldyiV_swawR$@BNi&fW^8 +zbNa_=jCvy`DO-BIiJNZ*RkcRcZ*=TSKScx7J&byTP!BOm)-j(FY9^!FG3qTs-Nq<+ +z_4gG*&0^F=bQ<ELh)@j}RmSW18HCDV)ImnkPQrH#9hp1hV}2WN1c7EV=sgC#MxYYv +z?c5n5EUGi1<}m6hM!ig^rAkzD7S)JAxeQ8T(5nQ>251|7mFYV{L20e8XdO>dC<__B +z-+=PJ0ThLt^N)5D$QHGZp>_OpRM9%<Myn8i&mkd+b$lJN19kpo_3oo6E}|jtG1ucX +zvnWmKtqyYvP<dyT11Jf-oJ1r#N|v(-m3i)Qlt}Wa!nvZSaJ_=f2=U$Mz(__0rn#rE +zghgQwP)1KsRi8STJmESZoGP>VE}w9IvN%=3`O4zZH{B#>hs9|wob?tbTsSXToNmH- +z(&D&<Gu`5h5YBjuGhR3kTAZoE>2GoJh11#MED=ta#VHbwm495DgmXc<8~zc_af@?6 +zI0r0_PdGa*PL*&La;}6|4T?YbXQhP+5l*4SQKuZh%v2oLZ!g#>=_sC6O8NmNB2@j( +zl=S#|?ma6lVbYb?gK?h2Rjx;KwdfwGs<`Hh5=uWaS&4m~gNnubsH?pZr&p_F@EG*^ +z{#nP`)Y7Vs+Ht*3&@UNU%FuLzeko9G5t;KA)pj-2TIVubM_=JVSp#S5UV@NnTQ;2G +z1E5fAS(?)6TEEnu24BUqng(UF(38ylh0Sfw=B|Kyd~GjnSyO`k%Fth4Q%+b+&~wxb +zYqM~I4vBx0_A}}YLVc+kOUFU^YNYXIVHJvGvoPmv<&D~6EG?<eJ}-SenZ6V9M*Qt; +zULizQ>y0NEekasx-iTv&uY^$ZmnIgo0;`{&BI6rS$l}*6*!X9m(|4s9uk|y1$5z~s +zp+{CJZ{!p7#GAS|dJ(D-qc$_@B|?2dC`vNke3fO`8$~D*Z)9;${;|Z4d_SI5<QMU& +z({Ik^&4I{jy>X7=w?Mt-jR%wku7#q2qCTG$Sl%$m_?y`H3$Lms=0T?~Sd7=a@im>3 +z-^|dx44qEUZ{N_pv5ru;FzR(i?IF}gLa{eghGlQ;LXmi5EC=$>&)MEMjA!MImfXDW +zoz2UF$ZEYYis9Enz2=Q5Wr1s+C?Ic4X9bow`jYW?v+=*aqP#H$I(_F~XX7<*Tt(0U +z4E>0q$pqa)P-~>n`FydPQ7<y;4??XGfrt$?yRbKYL6LZ41PAiL#kMy-$FuUr;}DAA +z{nFXIu@G6UH@pmQ0`;0V?obxEriudcMlvg~ypcu5C$RAqE0s5rpwoA9?IqqANYF%v +zZeZx61l>+h%NuP7HI`9NGb)QvFNi>RBbZ9r8%I$j-WbGzylau|jcs^V-gt|T*gkPK +zZv;eE>y2#;4}yBl8#gHnToXhAdE-%5V0q&;R4ks&#_wC9yfF$oec!FQ#2b$hbPhvT +zGc=l@?-JDV#&AOAGHN!X4DyCo1i~B5ZEu`|0P#jo4&<#1ZEw7dXXOq0x(~6j(b>E~ +z5LvA^<b3k?<qmILtt@aoA_~YG(X7DoMlc!wG8_LfYGVyL1Uh}?MVENvTRQs#gzS2r +zp?wLuilCM^HWCV6AXFx!Mi6S22!uDnZEsYfNW9U319{!Ewl`kEv+_o3_Qo2>)jGQ; +zL{{sKOoksryEJ$sWr6EnQ9$14%L*)SOef>9eIeuDM{RhcH+1@TtiHq>_YoBDViB}} +zp<N0396>E_+(f8tj7nsbhftG5AiUAd_Qn|$i8sPHkXJ0Qy|D<-${P#$wDARaS8HAe +zh^*Ed#~8l<B?tWCYt$rHq$nV7bY%sWH%`*w<RLb`2({sj+o03;o~kOxalDe+PSC>) +zox#u>2<joI<&75z^$nvQV$_x7jd&3VZ>Sv0d84WAjb<Fk&pu;&;|V+~Z(PRB^TNBD +zH^LyYT5k+s_@^&A;HOq8Z*&#~<c%9xf#r=3Wc*n+ekp3h8*QM|_nNBe@J4NdRxvb< +zq0I^U7(p#>d`m}|=NL7RQ8$y%hKoRWV+575H`<^`VxtZRa$ceBjcIsR-Wbnkud|$; +z-3%hD^~N-YZ&~K>#?e=mH`<B<@<wx3V0j~!jK6|51Kx-yQ5)U}g-+iRRn_5*2!e(( +zG>)P537SGs%NtDybtR*EFe-w4Hb4Zz8{=(nbU=}K<4+Ylt|?F3-k6AI<&C9$K0C?T +z*>xbYT5r70@Hby@c;o9=lsB#v1>}wTtibZd0y?9;jg6m)+VDnQ==9B3RUO_KN6^j; +zeSo1C&|F^(K`n3eAygMewP#c$`Rq;+2yaZaz0nOt;tih)9#_&+wl_xOS$ShOo%VYp +z;-O9(DSxi4!5iN){N<$%cq!oUK(HtvZ(Q&y1(r8HM#bWL+4ywShBwZk4Zg=!Rfjj8 +zC+K|)jbiAp1RY9H%Nv=5ie^+RM$v%r-68_vjeOf1eP}H4i^Ydj@VG|7K=T{H``B1- +z=s$Gu?2Q->b(%MPD{AmY6ZXb4&pY6o0fz_9KgkNn8^7Wi?zX(~CmkKDpK0?(j6rR9 +z;{@8^OI1}J-q=OZWNzmj46Pt&KZ07`SVgE5Mm1&B{S-mhia>Z{iS3O+G?v&KyE%}D +zh_SS5>%+!+Lp!lI20)$WjYG?8@J1ho=R%PNe;sfLJy~FTqXN&mH^RyId^Ua<YQr1f +zq7A-SRn_5*zv(E~!_b=;x{sg{1hu@epHTA|Rhv<xD1w@ZKzO6b_Qr!K5^sFSf!te+ +zC2w?LW4)ncAQZ82C)8=p+x>D4-pFNm_Hz#Si-1Guck^v;?8CF}jrnB!Yi#`8s10xI +zK^uJctEvuf#1M2fL$7A&#{|8Rpq4l8BvcWj{#dL8PM`=15`pl>CfghFC=ze1=Rm$q +zj3sZhV`IIcbZQB2+yZr)H$Hr+25%f=_&BK7;7<b%q2(Ui8z19Y_r`8iEdGd%@5aV& +zM@xPERaJ*KRuJ@KhBjj8`vh%4P|F*S5$Y30{k%wdV;)7&?=O-qe7<3OV<w8k8!I`G +z+laB`jjPyLZ|G&*ylbIOYu<W@taeVhk>L+Ry#}AHEO70}x4rQ`o^@|@AmhJh<8Nl; +z-$hG(w~O)G9=0|?e_-gvg{qxJ1Z_Z2%NyU~47&IzqYg6aX^Nm@%Pemku)RS!M7*(( +z136TTC2!PYWAXPS>R>yf3DjxLTM3cXdc(u;d!Sx}XDSO^?>%9AqX^HsH`2-Yf7tkI +z*!Wd&iZ5J@*Srx$(2EQ`^{n#7QiA^dg6@r0gu;J}oFaP{qu!(l+D|As->|*03Ps|L +zc^t@f#aQyjU-Oi)_&!*DH5d`(?CgaQ>GXyt`wZSl`hd}QLA&ORvC06~YREK?zFuJY +z)|B!JDi*h7+nccMOW+gV)ndEmjHv{@nxQ`~P|olYv~nqZ>2ZdC73Bc}UBjSl4BABT +zvkM^cMHPHOzwhA<eG?@-pA2SC{GG>^k|$2#8Qta$t-xU@JbTvJw)qg~^n`ke6z@MW +zybF|Tt{A2CyOxOpnq3Q7f#r$=s91aln_frS2c5nUF<o=Tn*{B~(1Xt?SIi;kvFG); +zc!E%OGU{DMeL>N)jZhpH>QtOp<vUR%agoYF{M%gH8%Oc1ywQxC=XW;mafqze8*Lcg +z4(c^;3{e)io)QJ*jXA8q@<x3!ei$47XQ681Ea>#r65};*9KozuJe;As7@9@U{Y!Lj +zY$nu$j9SI0{S-cL6N<eNLL-g6@ih%hj*VE3;_q{9Z+wks<&FLjir6^pY+fovR_l%7 +z48IEMHE;A*7PxXm0eK^f6<FTrNyblN<9$ynZ%l$t-<jvwc+DG437WystqdJY&`$|! +zWzZ8i^DWL~)N_nFNfGpl2*m8Fz71h-_)sL?xSs?0%Q?0;O7X0`F_{jMy%C=~n->d_ +z)q3LzhS!67%^SBV3tSnZfV?r56<EfnlJWD|_(M-AZ`@19|Fl?n13#mJ7xj5J-;baL +z3|+_2ZUo(;pm?!{dY<1IDU<w*7TlxSTk3OhYyc&%0@6eqL0OKzN?L7~s&Bt-QKNat +zQoSYgorDUnh%2OCnq6<XUFwq3p>}DJU3!WV0(5qf(gOLKQ5keX3NPdNl+<prs~(Zk +zD(>3K0{h!XZ^R)f+{KN@+pdN3JqfjRpOlVX#EwO&d~ZOdA4_R(yHw86sq}p*z1}XB +zb7d-hT}o@)rNKN$QRy>MdTgPkx4B(9M@mcW(r~*pNlMq)rQPh(QBqo9m%8mzx0I&X +zr6cUp2r0eKE*)=|UL&Qq*`-tM(%Mpbxm}uXm-;b4sdxW))@tt(yL69~?zc;e?9vTV +zy4fz>WS71qr7zf}Wp?R8DV<@L9<WQNOKFT<>a$BTq_mG+T4k4xkka2J=ny$F*HHfs +zmQt5pS8^|vc9zng7g*kqTtubUO6jLuiqTu@ds9V`>#mu0QtFInm6WchQ)+KSw<jH0 +zW*2G)BqeX??F^kd-vM2&6uG{i!NMsaeT`=bx6<>qs95|BXPJShjm^(iBpcswu~AD% +zr*TYN{4GPTW9Vvv-fT9fK)nP<t(x+*YCm4+vEHuviruNRhT15VYf$kno23#AShv_L +zl~urMZnIRj0Lx{vtk)9SaJ*`-B{a1-YOtf$Meapl)Bp$P7mE{2Apy=|i_=^<pIV%7 +z;cT=x-GsBs;<$zLti>52oY@v<yl~Pi&Q#%ywmA91xyRxx5zd_!r${(ATAWS73AH$7 +z!l`X>4hZLz*^w@vaE@3UH3Z;|&n=D$dvLZ`92M%|tT8!wZm+bs9(~M?@B8tr;(Ioo +zrs73Ck0WSLpeL>Pjy&C@X_OED45{$U_{Nicz%%?SyeZY+6SW&}N|kAEO3h_qlb>)1 +zdr5_b>&SF_1bm5SPsr&eAyK}uO&<DmY?BV#GwH4BTnH$R$16H8sW+rxBxHIK-uFNR +zp(`Bd;e<|LbW=u;A@sFCTR%eDi9m@AIyp~?j3H3fQv^D|>;47=8q1(k2Hj7fFBRx3 +z2K|Ji*5YvtTFIb+1bRz>%K2TV?F6F#(kEIlgF$@=<WV5`@x^5XN@CCm2Hj4e1O+N% +zNmB?kfk9mu)R92F6)1#lx}QK38Pu3THxj5NKu9oQ{Fc_Ogi2<VFHia4dP1G?k`KaJ +zR9yn4Fz6!&T|=Nf3e<@~Kj471IF&&!G3Y7+tyQ3I4BASdGzLv$P!j^>DNrPXmJleN +zLBkmI50b1eR)O3M$|TSv26bf6DFXFSplAl&OP~w})o0Mp1iDgzMlk3m0%bDj*j(j; +z!vs3@B)K4#L3Id}#h?-f?IqA|1sczwBREwp&SuaH4El^fs}(4nLB#}`%%I5(+Crc? +z3N)2LiwHD@K|>kz9)U&^XloAEV2n#4+*HQh#JIJDi%__H3l~MWX^acfaE%m>7MU#X +zTEb0d+`(Ms3nlMZ0qLb_fN_7|#I*P^#=XtBH%RYRg<EdnJ}2DcjPo#V5#bgo98DN3 +zZx!KYFfNX9a|oBBaP;CE<7N<UCgbj8+)TnnDICo<j2lk4S&VDSxQT?j7PxH&evj4n +zEDZz4dxZnw7bU^>98mu5G?ij~T}*K6&ovsNh?n;CUg7PKsqHZK%%?*9=9Buv9n9zI +zvBK@?8%%Z7-v@>8(*aNP75wy-NBsdhO3OXb*D!ClhyOGTKb-4{Zp*w7_1g?smg7A? +z{7yqBaKmT<Z21f|WCwx3?#AG75B*XLsqEy5?$1x%)DO83FVYh|n0crX%}>#u=wbXc +z!V^7$pJF}HkMPrYPjoClrF)_i_-U#qdc1mClmoYWqSZUX_+@ZKq;m;HmM1!k2?`%i +z^i(F6E8=k`C=fj6JL^>ii>Sjrg>&&Qms7X!A5EFR6C6$lElbp2pn9*MpCnO8`dOUZ +zl7{4#-zgX37oTR&I72^oKXZ>+^JcE;3ZY4~`nnsXE)IW!XO;(6Y*}qZ{OB;=@3Sk0 +z%q%C{-L6OQv!YZsh5}A;5`+_NangnJs0tvel_Q)FJZ7yz;dHk!%Y_qean=jxN{dq> +zoF9?#SbLdp7UY?n1Hvh>Fcrdi%i_?Fqf#rDS)5AY%(pmI!kMZ#u6mjFqT=riSyViZ +zRS^bG?b(ijv-k<N#adXXw;cHd@H4K_bC#n<f~w(K1-a%4;Pb4*T08GW#p0hh2Q)%$ +ztQa=rBL}oVRqI&q4FdhlAm2;{T1}uc^Ta#eeCj|x)_WNxd~}no9PGM5)YGwEOS6eB +z*x;}nhr#bcV0F!#$mr3~t!0utrQWr3lHI&wJnLJ746?koi-I_!16%$dtaN<cQPpbR +z5CYX<P(22f5h&Dd9z`QJ&xaCj-eMJXt^uN+n%9HXdqa!qm>2(*6lZ^Yg=lg%Pfjfx +zaQkM=aI|lg3O?6Q>2~`L;aP8AGcrAlO}`hl(S3hn8RHvCRjm`7ldz`vdPapasxLLL +zs~O$id^NcExTzP4<hbc52T+1oKusLM7I;G+;wC=o?2}V-YiME-!<RnpXyOjQA+)yE +z#ItG6Caxpn?_%R8qBfd%IW=(#Ri!4XpLFpMsyCye7&V7bLzMy~3va&47Tm-vTIz8x +zrq59p%!XF;o84@-z#Do7C)DW0$DG~LxTYpXaT7N_=4j%PT%{mP6wn6tihw2#CgUGr +z<MUA)P3(k)m~SCfwR-UeLXBqB7)E_Ss8ppuHBqHMZsKNI$#D~}<#F;-s@=o|cvkzD +zXSj(=oZWH@L{=N9KQR2O>5e8|U?27p1=PgbSb>#i{HRzwosD0G+GyesEG2wzQ&p>p +z9}(&?M$KZBK}{@B3RDwSKIbO>MQb!}Vs{=YTT<*MuEVoxVh6T)gR@)Q5Ls;#XEFTL +zG)EI#a1%$00&3#DtiWpGJTiU>8@~g!(ZmT@Rr$V{tv4~2P|q`J8KbTxM-&l?W<GDe +znxMFe9qcAP#6#skvfaepcvel^Mc*Faz|h$(i4f^*A|?wDPF=mBExC~mosI0OY;a|Z +z3Tk8$tFRh*J(>SDoB!=p)yTX#FyEh}CDaQrr}!NPZDP<A^2EmgnM)1Yu6{+hcNtg6 +zxRHcgri4}UDs>%!-eb^22K6D(6eX-uty@Ug6NKBqxPFXl`+rFL_5hozHtrd0w=l$L +zq(lg%qB^3C6r)jYsgW+~l_HgHMno<(Moy<wx+oP=qI8vzPGJZ`NuvuYF-f(jQB5f0 +z65sFlJZrDL_YA%7_kI2_>+JP=uIqW$ZLhsIalL^<*B#|lv@tFO29T~=b@VAxJhO(j +zK{ALm%3je_&br-ig6=3w6RhPe3%t!C?9m<LkJ1G6Ka>Uf(UBp276J{Q|8<-4r~ivk +z27llGwDJqJasa3iWDceY?og200qqcUNqniG_6q9FM(Qg3CB``A(E+U!YSg^d8sqmF +z@$BtyQ}OZCp=#dUaBRSV6@%tA=0g|U>tKL=p!hfL3*o;UCkECF7+AH8fqB&Zch&s? +zP{Y7xm?XH9LCP(RlF$~$lSKca=w6DB(H+-{AX+*_rgGAfkq1$gi3eL{<AiTGyHfR; +zIMi>@Q7B7;@{S{#Xk567>VTqLPQl*pYVU_5LiYYRR_twN__IONl)r7zKD3}ZK5)Wt +z05$AA53>e$8c1z}o<Y!Y3L2uI^>oT`;V%u!`KdPON2t*T-HZ5!$T_$A<~@h9m^V$$ +zdokQV=YZkS%==Z*TeCyvRZ{aZ41b!}LHS$rc;7s6nri+Qs9|0fW(@8J4+P9xPf!a5 +zO;*rv^uf~rnLd$|Z8dK<YSg?`HE+!j-@F9MVqOPTI4|5DSAyZu%!?`dpWz|%nu~a6 +zu;EYhu2uflyeFx77u9?NsA1lHm@T;9jtQ7IjG(Rxnx~*HG;a|=#yqYZ)Vy=7dF`|} +z_+_wf-ghXAd2-_jpH&UFM>ZH9&Air70O8dLvIEK6O~gA78~!wJjPkeUolDLCqniJ5 +zubB5NW(w}X(E;;n5j0RipD5^NHt{BajCouJsd;yyMqBS{&AqAt^A6o&%p1e|HStJ= +zuz6F#@Mz|Jrs#_xJ7C@r5%0VPp5EeTy7IT?eFehA1FCs#P^0yhV3y#X6g2N0g2pPS +z_#Oe}vWfTIZ_VSHPR)B0HEP}{&5c$@JUi2qJ@e#dRXox(+#ZX;u$*~1T;C2I;Ew?i +zAFwc2G;r43>|2;X83AG~yqC&9ugagL%5TCX!My;a=v}JHdt!PLG+jZ}6m)>CoGKtQ +z47Vg`hJtq9EpABAS0$tT;dMuN7WtD_Wgc}G!49tp5UI;DG~fOn<Olq(C`-T(eL_4? +z681n2BpkzKOO)Vrs2XrtUl5=ro-!gB^AD>C>$2q_Onj(@9=uBoosB`=tpZZGthTu9 +zd4iTIXp@4D&>K5O5@cL9f}mvzdRIXY)A>sQLb%9`<k#@5bb(f7Iwu}w|0JG?ugq|8 +zT>&C>+3}jgAK&D=?0uBQWs7kT070`f?14UzU|rV6KE54Kt)dRwe`m;HO#p|JZZZPs +zuzo7QzL};L&D^SHegbM_QA_$_(|sVdk7>KmCh@(ZUQtvJOeWm<MCtn@D}##LCpD#! +z@YV#pz$J#4Lg1wY9I>~+n7`mZ4%`=52%ecQgZaT=>KlytrUt0DOHICey$+j&G1*>p +zQNyI5=u2!(no(+_scC6zxcx|)&rD4%ThrLo<eQqkI(|V8w<k%n%G7*oYg(F`JX4cr +zYBJ-pdr6{Yri%FpH2fkvn5<f2s-Bl-%7CQKhTl9>bGMbm9Zu4`YHIq~noLtO+thTl +zHQWIu%`>LvR9nLxQP#vwO;uaN9a7dX*6GvVb(n*0+%aX1EbUP9m960pDr-g=nuM+S +zkEzKvHM49DcUVa?)YMF}HQaG!&CRCf4qL<RSJqr>YWmt5?!~g^22<1C)^KB%HG@q} +zBU{5=TGk9RHI-})w`_yle$}zCFy`&wva+Wk`^;9F&0JPqZYt;7O70mOwjE97Q>a{% +zvETb{VR2*B7sj&iNxCoartsRat_8L68pq0jBp27r!KXtW9D7I>Oq(Z+-Jg{0>HiPc +zp=^&4@_`X<6c=B5R90t}x!R+k2F0ndtCfx39%zre4oaLaAPBh;Q7qC28?xt&^nL;9 +zkuq}BkcPgjJA<;;gEA;<r6+3-x_~tq2dsaZ2G~BhvNrly-$e(Ki>s4K&e%g$$H6}b +zlCsAb4J#WB7iRnZ>3J+xZSWZbtSG%r^SJXi`pe8%J#?KC605m3^<I2`ywO~Qz9k5_ +zs3X*-0x1)DYrxPwsdVny0VQramJ%7|E7(+JG^-cZ?Bbwiqaen*W16Sg%jjp;WE?z( +zLr+wPR@In0=sUDF9eU7r=ngJQVd$XY$8u<ZRXK+)9T;+GwldSOTLF$n?b_q4LyHlN +zR3PNgJB<?C?)8-jJ2ap~*r8I<qX5HkxT%|lH7ntY)NAS%LCvf~uh8MI5DQhg2cj`j +zq=fFdXau$-YUO^2*8XH_Q~g@AeanvHdsExuE=y~6K3V&@slDbNTWdBAS-Z;A7T;-W +z&3+qemzdhm{93bB#oD(`?K^%gHyI>y;*nXVb|Ac9EHVpo(mr8o>)v5&<$jCWJK5AW +z_i4EtG@NCV0I^iXua)~SN_&r?EkYw3xm=7G+QFvwQ@>X3&nWG6ruHqZmDifAxSM>O +zzSsB@u5KvHgljc7&T+hINN5JNeOO?^r7xzy{ts@F0Q%@HA?QLt!ThiO${an0Q-m^@ +z+u3Oo5GH=90t>Jl05v9C4yKmwP$9)mK&*3nX4VI{iM_Z<CZT~Vn>8MAMH(DeR@*Dm +z$hh*Jy&?^ZD=*0v=O&{PmofcRrFd$V+I#)rkP&~N4ebQev-ew^kAcQ7fFdv(UnR}$ +zI01Y2Umdo01qc)8vlqlLEArA`!5{a2jg(TH?Lu$U9PJ6yrB7Kt)L3r6B~)rYj|APH +z2YYXu|1lL6Pfb_lZVD^c;%IjCRp^(ve-N<a(CyN0>4rJmt!)`QI?xXD`KLL&`w&mx +zia+kVLJH-NrtPkNzP5!ZOO$=Cp|dco!u{Z5z24Zq{v?X&b3ApclAIhS>84sgY=ltj +zF)GAH+sBNyA?p1<ctatcej2qt$mp`W_A`jORZ;5{)tIQS6=mMNHIk^Iikhvc6r$cS +zk*Y0uzP4l=yeHhn#J+@y+CBPb_bA@`V?K=gH;4mox*iYuVsy`nwWvB_W3N#uCCrVQ +z?E9iCMG{<!&@rE?fd}r-@?Aa*WpVj*3B1U~6x<RP=ulG`EUn8m(De<%Zz=q3?A-_8 +zn<XxtG$VlSuAu^~yPpPOLZ*56o*sAp<LU47-oT?Kq}4^-?7of2s5-NsBHKbc_a-m+ +zkqhPp-aH4EctoLRD6}b|=POh^a*$bm437-C%J;~1D2qovfp?LSXM<nB#J#tc^GG~( +zyFzD$x8BzQ3J+8_%;}B8SB6u64G0r6Rq=a44R6fDA9tLPqR~(#Jvo{W_oi8N65!$G +z_uI-Zo;pA^cqpvFrR9{>Tj_Txx&+(e0n-|&zSkQ5)VEg|efv@0h14S+SqW<ByPv!6 +z8-~zS9x2)DMO!6Il&J1;0d<e`HNO2FtpgTch836wE;iaE!Ktq1_aUW74^s>lxz4NL +z>urF&pfYU0{RqOudQ~|^RqjTW8<Ny6@Rt(xnWBogg^oR3qW&6e4C`D8v38!=D2WS8 +z@x#4X^43e+	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∋FKVLDQ#J_g=>+NK@;7 +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 +z(MVIzT9%6zv(9dau4#2Z$_CbZK+m)uN1hF>48%0DW@G*7EbDrtIoo;#mN&L;L>Ze{ +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 +z%0D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 +U-CuI!6~$h`9=0Zt-ST?>5B{UL7XSbN + +literal 0 +HcmV?d00001 + +diff --git a/src/plugins/ves/libs/libevel.so b/src/plugins/ves/libs/libevel.so +new file mode 100644 +index 0000000000000000000000000000000000000000..de2b5ed1162ce632aa8b00c7bf15fe57134a9b9a +GIT binary patch +literal 416440 +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�u;mwmOC9r&d*t^D +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 + +literal 0 +HcmV?d00001 + +diff --git a/src/plugins/ves/ves.api b/src/plugins/ves/ves.api +new file mode 100644 +index 00000000..a7106f8d +--- /dev/null ++++ b/src/plugins/ves/ves.api +@@ -0,0 +1,72 @@ ++/* ++ * Copyright (c) 2017 Intel and/or its affiliates. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++/** \brief VES Agent config add / del request ++ @param client_index - opaque cookie to identify the sender ++ @param context - sender context, to match reply w/ request ++ @param server_port - VES Server port ++ @param read_interval - Time period for each loop ++ @param is_add - add the config if non-zero, else delete ++ @param server_addr[] - server address ++*/ ++define ves_agent_config ++{ ++ u32 client_index; ++ u32 context; ++ u32 server_port; ++ u32 read_interval; ++ u32 is_add; ++ u8 server_addr[16]; ++}; ++ ++/** \brief VES Agent config response ++ @param context - sender context, to match reply w/ request ++ @param retval - return code for the request ++*/ ++define ves_agent_config_reply ++{ ++ u32 context; ++ i32 retval; ++}; ++ ++/** \brief VES Agent mode set request ++ @param client_index - opaque cookie to identify the sender ++ @param context - sender context, to match reply w/ request ++ @param pkt_loss_rate - Base packet loss rate if Demo Mode ++ @param work_mode[] - Agent's work mode, real or demo ++*/ ++define ves_agent_mode ++{ ++ u32 client_index; ++ u32 context; ++ u32 pkt_loss_rate; ++ u8 work_mode[8]; ++}; ++ ++/** \brief VES Agent Mode response ++ @param context - sender context, to match reply w/ request ++ @param retval - return code for the request ++*/ ++define ves_agent_mode_reply ++{ ++ u32 context; ++ i32 retval; ++}; ++ ++/* ++ * Local Variables: ++ * eval: (c-set-style "gnu") ++ * End: ++ */ +diff --git a/src/plugins/ves/ves_all_api_h.h b/src/plugins/ves/ves_all_api_h.h +new file mode 100644 +index 00000000..72b15697 +--- /dev/null ++++ b/src/plugins/ves/ves_all_api_h.h +@@ -0,0 +1,18 @@ ++/* ++ * ves_all_api_h.h - skeleton vpp engine plug-in api #include file ++ * ++ * Copyright (c) 2017 Intel and/or its affiliates. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#include <ves/ves.api.h> +diff --git a/src/plugins/ves/ves_api.c b/src/plugins/ves/ves_api.c +new file mode 100644 +index 00000000..7a9b8004 +--- /dev/null ++++ b/src/plugins/ves/ves_api.c +@@ -0,0 +1,139 @@ ++/* ++ *------------------------------------------------------------------ ++ * ves_api.c - ves api ++ * ++ * Copyright (c) 2017 Intel and/or its affiliates. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ *------------------------------------------------------------------ ++ */ ++ ++#include <vnet/vnet.h> ++#include <vlibmemory/api.h> ++ ++#include <vnet/interface.h> ++#include <vnet/api_errno.h> ++#include <vnet/ip/ip.h> ++#include <vnet/ip/ip4.h> ++ ++#include <ves/ves_node.h> ++ ++#include <ves/ves_msg_enum.h> /* define message IDs */ ++ ++#define vl_typedefs /* define message structures */ ++#include <ves/ves_all_api_h.h> ++#undef vl_typedefs ++ ++#define vl_endianfun /* define message structures */ ++#include <ves/ves_all_api_h.h> ++#undef vl_endianfun ++ ++/* instantiate all the print functions we know about */ ++#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) ++ ++#define vl_printfun ++#include <ves/ves_all_api_h.h> ++#undef vl_printfun ++ ++ ++#include <vlibapi/api_helper_macros.h> ++ ++#define foreach_vpe_api_msg \ ++_(VES_AGENT_CONFIG,ves_agent_config) \ ++_(VES_AGENT_MODE,ves_agent_mode) ++ ++static void vl_api_ves_agent_config_t_handler ++ (vl_api_ves_agent_config_t *mp) ++{ ++ vl_api_ves_agent_config_reply_t *rmp; ++ ip46_address_t server; ++ int rv = -1; ++ ++ ip46_address_reset (&server); ++ clib_memcpy (&server.ip4, mp->server_addr, sizeof (server.ip4)); ++ ++ rv = ves_set_server(&server, ++ (u32) ntohl (mp->server_port), ++ (u32) ntohl (mp->read_interval), ++ (int) (mp->is_add == 0)); ++ ++ REPLY_MACRO (VL_API_VES_AGENT_CONFIG_REPLY); ++} ++ ++static void vl_api_ves_agent_mode_t_handler ++ (vl_api_ves_agent_mode_t *mp) ++{ ++ vl_api_ves_agent_mode_reply_t *rmp; ++ ves_agent_mode_t mode = VES_AGENT_MODE_REAL; ++ int rv = -1; ++ ++ if (!strcmp((char *)mp->work_mode, "demo") ++ || !strcmp((char *)mp->work_mode, "Demo") ++ || !strcmp((char *)mp->work_mode, "DEMO")) ++ mode = VES_AGENT_MODE_DEMO; ++ ++ rv = ves_agent_set_mode(mode, (u32) ntohl(mp->pkt_loss_rate)); ++ ++ REPLY_MACRO (VL_API_VES_AGENT_MODE_REPLY); ++} ++ ++/* ++ * ves_api_hookup ++ * Add vpe's API message handlers to the table. ++ * vlib has alread mapped shared memory and ++ * added the client registration handlers. ++ * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process() ++ */ ++#define vl_msg_name_crc_list ++#include <ves/ves_all_api_h.h> ++#undef vl_msg_name_crc_list ++ ++static void ++setup_message_id_table (api_main_t * am) ++{ ++#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); ++ foreach_vl_msg_name_crc_ves; ++#undef _ ++} ++ ++static clib_error_t * ++ves_api_hookup (vlib_main_t * vm) ++{ ++ api_main_t *am = &api_main; ++ ++#define _(N,n) \ ++ vl_msg_api_set_handlers(VL_API_##N, #n, \ ++ vl_api_##n##_t_handler, \ ++ vl_noop_handler, \ ++ vl_api_##n##_t_endian, \ ++ vl_api_##n##_t_print, \ ++ sizeof(vl_api_##n##_t), 1); ++ foreach_vpe_api_msg; ++#undef _ ++ ++ /* ++ * Set up the (msg_name, crc, message-id) table ++ */ ++ setup_message_id_table (am); ++ ++ return 0; ++} ++ ++VLIB_API_INIT_FUNCTION (ves_api_hookup); ++ ++/* ++ * fd.io coding-style-patch-verification: ON ++ * ++ * Local Variables: ++ * eval: (c-set-style "gnu") ++ * End: ++ */ +diff --git a/src/plugins/ves/ves_msg_enum.h b/src/plugins/ves/ves_msg_enum.h +new file mode 100644 +index 00000000..6e8a5dfa +--- /dev/null ++++ b/src/plugins/ves/ves_msg_enum.h +@@ -0,0 +1,31 @@ ++/* ++ * ves_msg_enum.h - vpp engine plug-in message enumeration ++ * ++ * Copyright (c) 2017 Intel and/or its affiliates. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#ifndef _VES_MSG_ENUM_H_ ++#define _VES_MSG_ENUM_H_ ++ ++#include <vppinfra/byte_order.h> ++ ++#define vl_msg_id(n,h) n, ++typedef enum ++{ ++#include <ves/ves_all_api_h.h> ++ /* We'll want to know how many messages IDs we need... */ ++ VL_MSG_FIRST_AVAILABLE, ++} vl_msg_id_t; ++#undef vl_msg_id ++ ++#endif /* _VES_MSG_ENUM_H_ */ +diff --git a/src/plugins/ves/ves_node.c b/src/plugins/ves/ves_node.c +new file mode 100644 +index 00000000..be9a886c +--- /dev/null ++++ b/src/plugins/ves/ves_node.c +@@ -0,0 +1,582 @@ ++/* ++ * Copyright (c) 2017 Intel and/or its affiliates and others. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#include <stdio.h> ++#include <stdlib.h> ++#include <unistd.h> ++#include <string.h> ++#include <sys/time.h> ++ ++#include <vnet/plugin/plugin.h> ++#include <vpp/app/version.h> ++ ++#include "ves_node.h" ++ ++#define BUFSIZE 128 ++ ++typedef struct dummy_vpp_metrics_struct { ++ int bytes_in; ++ int bytes_out; ++ int packets_in; ++ int packets_out; ++} vpp_metrics_struct; ++ ++static vlib_node_registration_t ves_agent_process_node; ++vpp_metrics_struct *last_vpp_metrics; ++vpp_metrics_struct *curr_vpp_metrics; ++time_t start_epoch; ++time_t last_epoch; ++char hostname[BUFSIZE]; ++ ++static u8 *format_ves_agent_config(u8 *s, va_list *args); ++ ++void read_vpp_metrics(vpp_metrics_struct *vpp_metrics, char *vnic) { ++ // Define an array of char that contains the parameters of the unix 'cut' command ++ char* params[] = {"-f3", "-f11", "-f4", "-f12"}; ++ // Define the unix command to execute in order to read metrics from the vNIC ++ char* cmd_prefix = "sudo cat /proc/net/dev | grep \""; ++ char* cmd_mid = "\" | tr -s \' \' | cut -d\' \' "; ++ char cmd[BUFSIZE]; ++ // Define other variables ++ char buf[BUFSIZE]; /* buffer used to store VPP metrics */ ++ int temp[] = {0, 0, 0, 0}; /* temp array that contains VPP values */ ++ FILE *fp; /* file descriptor to pipe cmd to shell */ ++ int i; ++ ++ for(i = 0; i < 4; i++) { ++ // Clear buffers ++ memset(buf, 0, BUFSIZE); ++ memset(cmd, 0, BUFSIZE); ++ // Build shell command to read metrics from the vNIC ++ strcat(cmd, cmd_prefix); ++ strcat(cmd, vnic); ++ strcat(cmd, cmd_mid); ++ strcat(cmd, params[i]); ++ ++ // Open a pipe and read VPP values ++ if ((fp = popen(cmd, "r")) == NULL) { ++ printf("Error opening pipe!\n"); ++ return; ++ } ++ ++ while (fgets(buf, BUFSIZE, fp) != NULL); ++ temp[i] = atoi(buf); ++ ++ if(pclose(fp)) { ++ printf("Command not found or exited with error status\n"); ++ return; ++ } ++ } ++ ++ // Store metrics read from the vNIC in the struct passed from the main function ++ vpp_metrics->bytes_in = temp[0]; ++ vpp_metrics->bytes_out = temp[1]; ++ vpp_metrics->packets_in = temp[2]; ++ vpp_metrics->packets_out = temp[3]; ++} ++ ++int ++ves_agent_report_vnic_stats(ves_agent_main_t *vam) ++{ ++ EVEL_ERR_CODES evel_rc = EVEL_SUCCESS; ++ EVENT_MEASUREMENT* vpp_m = NULL; ++ EVENT_HEADER* vpp_m_header = NULL; ++ int bytes_in_this_round; ++ int bytes_out_this_round; ++ int packets_in_this_round; ++ int packets_out_this_round; ++ struct timeval time_val; ++ ++ /* Is not enabled, do nothing */ ++ if (vam->config.is_enabled == VES_AGENT_DISABLED) { ++ return 0; ++ } ++ ++ memset(curr_vpp_metrics, 0, sizeof(vpp_metrics_struct)); ++ read_vpp_metrics(curr_vpp_metrics, DEFAULT_MEASURE_ETH); ++ ++ if(curr_vpp_metrics->bytes_in - last_vpp_metrics->bytes_in > 0) { ++ bytes_in_this_round = curr_vpp_metrics->bytes_in - last_vpp_metrics->bytes_in; ++ } else { ++ bytes_in_this_round = 0; ++ } ++ ++ if(curr_vpp_metrics->bytes_out - last_vpp_metrics->bytes_out > 0) { ++ bytes_out_this_round = curr_vpp_metrics->bytes_out - last_vpp_metrics->bytes_out; ++ } else { ++ bytes_out_this_round = 0; ++ } ++ ++ if(curr_vpp_metrics->packets_in - last_vpp_metrics->packets_in > 0) { ++ packets_in_this_round = curr_vpp_metrics->packets_in - last_vpp_metrics->packets_in; ++ } else { ++ packets_in_this_round = 0; ++ } ++ ++ if(curr_vpp_metrics->packets_out - last_vpp_metrics->packets_out > 0) { ++ packets_out_this_round = curr_vpp_metrics->packets_out - last_vpp_metrics->packets_out; ++ } else { ++ packets_out_this_round = 0; ++ } ++ ++ vpp_m = evel_new_measurement(vam->config.read_interval); ++ if(vpp_m != NULL) { ++ char str_pkt_loss[12]; ++ printf("New measurement report created...\n"); ++ evel_measurement_vnic_use_add(vpp_m, /* Pointer to the measurement */ ++ DEFAULT_MEASURE_ETH, /* ASCII string with the vNIC's ID */ ++ packets_in_this_round, /* Packets received */ ++ packets_out_this_round, /* Packets transmitted */ ++ 0, /* Broadcast packets received */ ++ 0, /* Broadcast packets transmitted */ ++ bytes_in_this_round, /* Total bytes received */ ++ bytes_out_this_round, /* Total bytes transmitted */ ++ 0, /* Multicast packets received */ ++ 0, /* Multicast packets transmitted */ ++ 0, /* Unicast packets received */ ++ 0); /* Unicast packets transmitted */ ++ ++ if ( vam->config.mode == VES_AGENT_MODE_DEMO) { ++ sprintf(str_pkt_loss, "%d", vam->config.base_pkt_loss); ++ } else { ++ sprintf(str_pkt_loss, "%s", "0.0"); ++ } ++ evel_measurement_custom_measurement_add(vpp_m, /* Pointer to the measurement */ ++ "ONAP-DCAE", /* measurement group's name */ ++ "Packet-Loss-Rate", /* the measurement's name */ ++ str_pkt_loss); /* The measurement's value */ ++ ++ last_epoch = start_epoch + vam->config.read_interval * 1000000; ++ vpp_m_header = (EVENT_HEADER *)vpp_m; ++ vpp_m_header->start_epoch_microsec = start_epoch; ++ vpp_m_header->last_epoch_microsec = last_epoch; ++ strcpy(vpp_m_header->reporting_entity_id.value, "No UUID available"); ++ strcpy(vpp_m_header->reporting_entity_name, hostname); ++ ++ evel_rc = evel_post_event(vpp_m_header); ++ if(evel_rc == EVEL_SUCCESS) { ++ printf("Measurement report correctly sent to the collector!\n"); ++ } ++ else { ++ printf("Post failed %d (%s)\n", evel_rc, evel_error_string()); ++ } ++ } ++ else { ++ printf("New measurement report failed (%s)\n", evel_error_string()); ++ } ++ ++ last_vpp_metrics->bytes_in = curr_vpp_metrics->bytes_in; ++ last_vpp_metrics->bytes_out = curr_vpp_metrics->bytes_out; ++ last_vpp_metrics->packets_in = curr_vpp_metrics->packets_in; ++ last_vpp_metrics->packets_out = curr_vpp_metrics->packets_out; ++ gettimeofday(&time_val, NULL); ++ start_epoch = time_val.tv_sec * 1000000 + time_val.tv_usec; ++ ++ return 0; ++} ++ ++always_inline int ++ves_agent_start(ves_agent_main_t *vam) ++{ ++ vlib_main_t *vm = vam->vlib_main; ++ struct timeval time_val; ++ char fqdn[16]; /* "xxx.xxx.xxx.xxx" */ ++ //char *fqdn = "127.0.0.1"; /* "xxx.xxx.xxx.xxx" */ ++ ++ sprintf(fqdn, "%d.%d.%d.%d", vam->config.server_addr.data[0], ++ vam->config.server_addr.data[1], ++ vam->config.server_addr.data[2], ++ vam->config.server_addr.data[3]); ++ /* Always success. TODO: Error check in next version */ ++ last_vpp_metrics = malloc(sizeof(vpp_metrics_struct)); ++ curr_vpp_metrics = malloc(sizeof(vpp_metrics_struct)); ++ ++ if(evel_initialize(fqdn, /* FQDN */ ++ vam->config.server_port, /* Port */ ++ NULL, /* optional path */ ++ NULL, /* optional topic */ ++ 0, /* HTTPS? */ ++ "", /* Username */ ++ "", /* Password */ ++ EVEL_SOURCE_VIRTUAL_MACHINE, /* Source type */ ++ "vFirewall", /* Role */ ++ 1)) /* Verbosity */ ++ { ++ fprintf(stderr, "\nFailed to initialize the EVEL library!!!\n"); ++ return -1; ++ } ++ ++ gethostname(hostname, BUFSIZE); ++ memset(last_vpp_metrics, 0, sizeof(vpp_metrics_struct)); ++ read_vpp_metrics(last_vpp_metrics, DEFAULT_MEASURE_ETH); ++ gettimeofday(&time_val, NULL); ++ start_epoch = time_val.tv_sec * 1000000 + time_val.tv_usec; ++ ++ vlib_process_wait_for_event_or_clock(vm, (f64)(vam->config.read_interval)); ++ ++ return 0; ++} ++ ++always_inline int ++ves_agent_stop(void) ++{ ++ sleep(1); ++ free(last_vpp_metrics); ++ free(curr_vpp_metrics); ++ evel_terminate(); ++ ++ return 0; ++} ++ ++/* *INDENT-OFF* */ ++VLIB_PLUGIN_REGISTER () = { ++ .version = VPP_BUILD_VER, ++ .description = "VNF Event Stream Agent", ++}; ++/* *INDENT-ON* */ ++ ++static uword ++ves_agent_process (vlib_main_t * vm, ++ vlib_node_runtime_t * rt, ++ vlib_frame_t * f) ++{ ++ ves_agent_main_t *vam = &ves_agent_main; ++ uword event_type; ++ uword * event_data = 0; ++ ++ if (vam->config.read_interval == 0) { ++ vam->config.read_interval = DEFAULT_READ_INTERVAL; ++ } ++ ++ while (1) ++ { ++ vlib_process_wait_for_event_or_clock(vm, (f64)(vam->config.read_interval)); ++ ++ event_type = vlib_process_get_events (vm, &event_data); ++ ++ switch (event_type) ++ { ++ case EVENT_VES_AGENT_START: ++ ves_agent_start(vam); ++ break; ++ case EVENT_VES_AGENT_STOP: ++ ves_agent_stop(); ++ break; ++ default: ++ ves_agent_report_vnic_stats(vam); ++ break; ++ } ++ ++ vec_reset_length (event_data); ++ } ++ ++ /* NOTREACHED */ ++ return 0; ++} ++ ++VLIB_REGISTER_NODE (ves_agent_process_node, static) = { ++ .function = ves_agent_process, ++ .type = VLIB_NODE_TYPE_PROCESS, ++ .name = "ves-agent-process", ++ .process_log2_n_stack_bytes = 16, ++}; ++ ++int ++ves_set_server (ip46_address_t *addr, ++ u32 server_port, ++ u32 read_interval, ++ int is_del) ++{ ++ ves_agent_main_t *vam = &ves_agent_main; ++ vlib_main_t *vm = vam->vlib_main; ++ int rc = 0; ++ ++ if (ip46_address_is_zero(addr)) ++ return VNET_API_ERROR_INVALID_DST_ADDRESS; ++ ++ if (is_del) ++ { ++ if (vam->config.is_enabled == VES_AGENT_DISABLED) { ++ return rc; ++ } ++ ++ if ((vam->config.server_addr.as_u32 != addr->ip4.as_u32) ++ || (vam->config.server_port != server_port)) ++ return VNET_API_ERROR_NO_SUCH_ENTRY; ++ ++ memset(&(vam->config.server_addr), 0, sizeof(ip4_address_t)); ++ vam->config.server_port = DEFAULT_SERVER_PORT; ++ vam->config.read_interval = DEFAULT_READ_INTERVAL; ++ vam->config.is_enabled = VES_AGENT_DISABLED; ++ vlib_process_signal_event (vm, ves_agent_process_node.index, ++ EVENT_VES_AGENT_STOP, 0); ++ } else { ++ // Already enabled the same config. ++ if ((vam->config.server_addr.as_u32 == addr->ip4.as_u32) ++ && (vam->config.server_port != server_port) ++ && vam->config.read_interval == read_interval ++ && vam->config.is_enabled == VES_AGENT_ENABLED) { ++ return rc; ++ } ++ ++ // Already enabled, but not exact match. ++ if (vam->config.is_enabled == VES_AGENT_ENABLED) { ++ return VNET_API_ERROR_VALUE_EXIST; ++ } ++ ++ vam->config.server_addr.as_u32 = addr->ip4.as_u32; ++ vam->config.server_port = server_port; ++ if (read_interval) { ++ vam->config.read_interval = read_interval; ++ } else { ++ vam->config.read_interval = DEFAULT_READ_INTERVAL; ++ } ++ vam->config.is_enabled = VES_AGENT_ENABLED; ++ vlib_process_signal_event (vm, ves_agent_process_node.index, ++ EVENT_VES_AGENT_START, 0); ++ } ++ ++ return (rc); ++} ++ ++static u8 * ++format_ves_agent_set_error(u8 *s, va_list *args) ++{ ++ s = format(s, "%s\n\n", "Caution, set fails due to enabled config:"); ++ s = format(s, "%U", format_ves_agent_config, NULL); ++ return s; ++} ++ ++static clib_error_t * ++ves_server_set_command_fn(vlib_main_t * vm, ++ unformat_input_t * input, ++ vlib_cli_command_t * cmd) ++{ ++ ip46_address_t server_addr; ++ u32 server_port = DEFAULT_SERVER_PORT, inter_val = DEFAULT_READ_INTERVAL; ++ int is_del = 0, set_server = 0; ++ ++ memset(&server_addr, 0, sizeof(server_addr)); ++ ++ while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) ++ { ++ if (unformat (input, "server %U", ++ unformat_ip4_address, &server_addr.ip4)) ++ set_server = 1; ++ else if (unformat (input, "port %u", &server_port)) ++ ; ++ else if (unformat (input, "intval %u", &inter_val)) ++ ; ++ else if (unformat (input, "delete") || ++ unformat (input, "del")) ++ is_del = 1; ++ else ++ break; ++ } ++ ++ if (is_del || set_server) ++ { ++ int rv; ++ ++ rv = ves_set_server (&server_addr, server_port, inter_val, is_del); ++ switch (rv) ++ { ++ case 0: ++ return 0; ++ ++ case VNET_API_ERROR_INVALID_DST_ADDRESS: ++ return clib_error_return (0, "Invalid address"); ++ ++ case VNET_API_ERROR_NO_SUCH_ENTRY: ++ return clib_error_return(0, "No such Entry found"); ++ ++ case VNET_API_ERROR_VALUE_EXIST: ++ vlib_cli_output (vm, "%U\n", format_ves_agent_set_error, NULL); ++ return clib_error_return (0, "BUG found!"); ++ ++ default: ++ return clib_error_return (0, "BUG: rv %d", rv); ++ } ++ } else { ++ return clib_error_return (0, "parse error`%U'", ++ format_unformat_error, input); ++ } ++} ++ ++VLIB_CLI_COMMAND (ves_server_set_command, static) = { ++ .path = "set ves agent", ++ .short_help = "set ves agent [del] server <ipaddr> port <port> [intval <inter-value>]", ++ .function = ves_server_set_command_fn, ++}; ++ ++static u8 * ++format_ves_agent_config(u8 *s, va_list *args) ++{ ++ ves_agent_main_t *vam = &ves_agent_main; ++ char fqdn[16]; /* "xxx.xxx.xxx.xxx" */ ++ ++ s = format(s, "%=16s %=12s %=8s %s\n", "Server Addr", ++ "Server Port", "Interval", "Enabled"); ++ if (vam->config.is_enabled == VES_AGENT_DISABLED) { ++ return s; ++ } ++ ++ sprintf(fqdn, "%d.%d.%d.%d", vam->config.server_addr.data[0], ++ vam->config.server_addr.data[1], ++ vam->config.server_addr.data[2], ++ vam->config.server_addr.data[3]); ++ ++ s = format(s, "%=16s %=12d %=8d %s\n", fqdn, ++ vam->config.server_port, ++ vam->config.read_interval, ++ vam->config.is_enabled ? "True" : "False"); ++ ++ return s; ++} ++ ++static clib_error_t * ++ves_server_show_command_fn(vlib_main_t * vm, ++ unformat_input_t * input, ++ vlib_cli_command_t * cmd) ++{ ++ vlib_cli_output (vm, "%U", format_ves_agent_config, NULL); ++ ++ return (NULL); ++} ++ ++VLIB_CLI_COMMAND (ves_server_show_command, static) = { ++ .path = "show ves agent", ++ .short_help = "Display VES Agent Configuration", ++ .function = ves_server_show_command_fn, ++}; ++ ++int ++ves_agent_set_mode(ves_agent_mode_t mode, ++ u32 pkt_loss_rate) ++{ ++ ves_agent_main_t *vam = &ves_agent_main; ++ int retval = 0; ++ ++ if (VES_AGENT_MODE_DEMO == mode) { ++ if (pkt_loss_rate > 100) { ++ vam->config.mode = VES_AGENT_MODE_REAL; ++ vam->config.base_pkt_loss = 0; ++ return 1; ++ } ++ vam->config.mode = VES_AGENT_MODE_DEMO; ++ vam->config.base_pkt_loss = pkt_loss_rate; ++ } else { /* Only demo or real for current stage */ ++ vam->config.mode = VES_AGENT_MODE_REAL; ++ vam->config.base_pkt_loss = 0; ++ } ++ ++ return retval; ++} ++ ++static clib_error_t * ++ves_mode_set_command_fn(vlib_main_t * vm, ++ unformat_input_t * input, ++ vlib_cli_command_t * cmd) ++{ ++ u32 pkt_loss_rate = 0; ++ ves_agent_mode_t mode = VES_AGENT_MODE_REAL; ++ int set_mode = 0; ++ ++ while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) ++ { ++ if (unformat (input, "demo") || unformat (input, "Demo") ++ || unformat (input, "DEMO")) ++ { ++ mode = VES_AGENT_MODE_DEMO; ++ set_mode = 1; ++ } ++ else if (unformat (input, "real") || unformat (input, "Real") ++ || unformat (input, "REAL")) ++ set_mode = 1; ++ else if (unformat (input, "base %u", &pkt_loss_rate)) ++ ; ++ else ++ break; ++ } ++ ++ if (set_mode) ++ { ++ int retval = ves_agent_set_mode(mode, pkt_loss_rate); ++ if (retval == 0) ++ return 0; ++ else ++ return clib_error_return (0, "BUG found!"); ++ } else { ++ return clib_error_return (0, "parse error`%U'", ++ format_unformat_error, input); ++ } ++} ++ ++VLIB_CLI_COMMAND (ves_mode_set_command, static) = { ++ .path = "set ves mode", ++ .short_help = "set ves mode <demo|real> [base <pkt-loss-rate>]", ++ .function = ves_mode_set_command_fn, ++}; ++ ++static inline u8 * ++format_ves_agent_mode(u8 *s, va_list *args) ++{ ++ ves_agent_main_t *vam = &ves_agent_main; ++ ++ s = format(s, "%=8s %s\n", "Mode", "Base Packet Loss Rate"); ++ ++ s = format(s, "%=8s %d%%\n", ++ vam->config.mode == VES_AGENT_MODE_DEMO ? "Demo" : "Real", ++ vam->config.base_pkt_loss); ++ ++ return s; ++} ++ ++static clib_error_t * ++ves_agent_mode_show_command_fn(vlib_main_t * vm, ++ unformat_input_t * input, ++ vlib_cli_command_t * cmd) ++{ ++ vlib_cli_output (vm, "%U", format_ves_agent_mode, NULL); ++ ++ return (NULL); ++} ++ ++VLIB_CLI_COMMAND (ves_agent_mode_show_command, static) = { ++ .path = "show ves mode", ++ .short_help = "Display VES Agent Mode Information", ++ .function = ves_agent_mode_show_command_fn, ++}; ++ ++static clib_error_t * ++ves_agent_init(vlib_main_t * vm) ++{ ++ ves_agent_main_t *vam = &ves_agent_main; ++ ++ vam->vlib_main = vm; ++ vam->vnet_main = vnet_get_main(); ++ ++ return 0; ++} ++ ++VLIB_INIT_FUNCTION (ves_agent_init); ++ ++/* ++ * fd.io coding-style-patch-verification: ON ++ * ++ * Local Variables: ++ * eval: (c-set-style "gnu") ++ * End: ++ */ +diff --git a/src/plugins/ves/ves_node.h b/src/plugins/ves/ves_node.h +new file mode 100644 +index 00000000..7b773843 +--- /dev/null ++++ b/src/plugins/ves/ves_node.h +@@ -0,0 +1,66 @@ ++/* ++ * Copyright (c) 2017 Intel and/or its affiliates. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef _VES_NODE_H_ ++#define _VES_NODE_H_ ++ ++#include <vnet/ip/ip.h> ++ ++#include "include/evel.h" ++ ++#define DEFAULT_SERVER_IP "127.0.0.1" ++#define DEFAULT_MEASURE_ETH "eth0" ++#define DEFAULT_SERVER_PORT 8080 ++#define DEFAULT_READ_INTERVAL 100 ++ ++typedef enum { ++ VES_AGENT_MODE_REAL = 0, ++ VES_AGENT_MODE_DEMO, ++ _NUM_VES_AGENT_MODES ++} ves_agent_mode_t; ++ ++/* VES Agent Server configuration */ ++typedef struct { ++ ip4_address_t server_addr; ++ u32 server_port; ++ u32 read_interval; ++ int is_enabled; ++ u32 base_pkt_loss; /* For demo only */ ++ ves_agent_mode_t mode; /* Demo or Real */ ++} ves_agent_config_t; ++ ++typedef struct { ++ ves_agent_config_t config; ++ ++ /* convenience */ ++ vlib_main_t * vlib_main; ++ vnet_main_t * vnet_main; ++} ves_agent_main_t; ++ ++ves_agent_main_t ves_agent_main; ++ ++#define EVENT_VES_AGENT_START 1 ++#define EVENT_VES_AGENT_STOP 0 ++ ++#define VES_AGENT_DISABLED 0 ++#define VES_AGENT_ENABLED 1 ++ ++int ves_set_server(ip46_address_t *addr, u32 server_port, ++ u32 read_interval, int is_del); ++ ++int ves_agent_set_mode(ves_agent_mode_t mode, ++ u32 pkt_loss_rate); ++ ++#endif /* _VES_NODE_H_ */ +diff --git a/src/vpp-api/java/Makefile.am b/src/vpp-api/java/Makefile.am +index f18e0c24..7f4738d8 100644 +--- a/src/vpp-api/java/Makefile.am ++++ b/src/vpp-api/java/Makefile.am +@@ -149,6 +149,26 @@ jvpp-snat/io_fd_vpp_jvpp_snat_JVppSnatImpl.h: $(jvpp_registry_ok) $(jvpp_snat_js + endif + + # ++# VES Plugin ++# ++if ENABLE_VES_PLUGIN ++noinst_LTLIBRARIES += libjvpp_ves.la ++libjvpp_ves_la_SOURCES = jvpp-ves/jvpp_ves.c ++libjvpp_ves_la_CPPFLAGS = -Ijvpp-ves ++libjvpp_ves_la_LIBADD = $(JVPP_LIBS) ++libjvpp_ves_la_DEPENDENCIES = libjvpp_common.la ++ ++BUILT_SOURCES += jvpp-ves/io_fd_vpp_jvpp_ves_JVppVesImpl.h ++JAR_FILES += jvpp-ves-$(PACKAGE_VERSION).jar ++CLEANDIRS += jvpp-ves/target ++ ++jvpp_ves_json_files = @top_builddir@/plugins/ves/ves.api.json ++ ++jvpp-ves/io_fd_vpp_jvpp_ves_JVppVesImpl.h: $(jvpp_registry_ok) $(jvpp_ves_json_files) ++ $(call japigen,ves,JVppVesImpl) ++endif ++ ++# + # iOAM Trace Plugin + # + if ENABLE_IOAM_PLUGIN +diff --git a/src/vpp-api/java/jvpp-ves/jvpp_ves.c b/src/vpp-api/java/jvpp-ves/jvpp_ves.c +new file mode 100644 +index 00000000..60e325b5 +--- /dev/null ++++ b/src/vpp-api/java/jvpp-ves/jvpp_ves.c +@@ -0,0 +1,108 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#include <vnet/vnet.h> ++ ++#include <ves/ves_msg_enum.h> ++#define vl_typedefs /* define message structures */ ++#include <ves/ves_all_api_h.h> ++#undef vl_typedefs ++ ++#include <vnet/api_errno.h> ++#include <vlibapi/api.h> ++#include <vlibmemory/api.h> ++ ++#if VPPJNI_DEBUG == 1 ++ #define DEBUG_LOG(...) clib_warning(__VA_ARGS__) ++#else ++ #define DEBUG_LOG(...) ++#endif ++ ++#include <jvpp-common/jvpp_common.h> ++ ++#include "jvpp-ves/io_fd_vpp_jvpp_ves_JVppVesImpl.h" ++#include "jvpp_ves.h" ++#include "jvpp-ves/jvpp_ves_gen.h" ++ ++/* ++ * Class: io_fd_vpp_jvpp_ves_JVppVesImpl ++ * Method: init0 ++ * Signature: (JI)V ++ */ ++JNIEXPORT void JNICALL Java_io_fd_vpp_jvpp_ves_JVppVesImpl_init0 ++ (JNIEnv *env, jclass clazz, jobject callback, jlong queue_address, jint my_client_index) { ++ ves_main_t * plugin_main = &ves_main; ++ clib_warning ("Java_io_fd_vpp_jvpp_ves_JVppVesImpl_init0"); ++ ++ plugin_main->my_client_index = my_client_index; ++ plugin_main->vl_input_queue = (unix_shared_memory_queue_t *)queue_address; ++ ++ plugin_main->callbackObject = (*env)->NewGlobalRef(env, callback); ++ plugin_main->callbackClass = (jclass)(*env)->NewGlobalRef(env, (*env)->GetObjectClass(env, callback)); ++ ++ // verify API has not changed since jar generation ++ #define _(N) \ ++ get_message_id(env, #N); ++ foreach_supported_api_message; ++ #undef _ ++ ++ #define _(N,n) \ ++ vl_msg_api_set_handlers(get_message_id(env, #N), #n, \ ++ vl_api_##n##_t_handler, \ ++ vl_noop_handler, \ ++ vl_noop_handler, \ ++ vl_noop_handler, \ ++ sizeof(vl_api_##n##_t), 1); ++ foreach_api_reply_handler; ++ #undef _ ++} ++ ++JNIEXPORT void JNICALL Java_io_fd_vpp_jvpp_ves_JVppVesImpl_close0 ++(JNIEnv *env, jclass clazz) { ++ ves_main_t * plugin_main = &ves_main; ++ ++ // cleanup: ++ (*env)->DeleteGlobalRef(env, plugin_main->callbackClass); ++ (*env)->DeleteGlobalRef(env, plugin_main->callbackObject); ++ ++ plugin_main->callbackClass = NULL; ++ plugin_main->callbackObject = NULL; ++} ++ ++/* Attach thread to JVM and cache class references when initiating JVPP VES */ ++jint JNI_OnLoad(JavaVM *vm, void *reserved) { ++ JNIEnv* env; ++ ++ if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_8) != JNI_OK) { ++ return JNI_EVERSION; ++ } ++ ++ if (cache_class_references(env) != 0) { ++ clib_warning ("Failed to cache class references\n"); ++ return JNI_ERR; ++ } ++ ++ return JNI_VERSION_1_8; ++} ++ ++/* Clean up cached references when disposing JVPP VES */ ++void JNI_OnUnload(JavaVM *vm, void *reserved) { ++ JNIEnv* env; ++ if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_8) != JNI_OK) { ++ return; ++ } ++ delete_class_references(env); ++} +diff --git a/src/vpp-api/java/jvpp-ves/jvpp_ves.h b/src/vpp-api/java/jvpp-ves/jvpp_ves.h +new file mode 100644 +index 00000000..642101ca +--- /dev/null ++++ b/src/vpp-api/java/jvpp-ves/jvpp_ves.h +@@ -0,0 +1,43 @@ ++/* ++ * Copyright (c) 2017 Intel Corp and/or its affiliates. ++ * ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at: ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#ifndef __included_jvpp_ves_h__ ++#define __included_jvpp_ves_h__ ++ ++#include <vnet/vnet.h> ++#include <vnet/ip/ip.h> ++#include <vnet/api_errno.h> ++#include <vlibapi/api.h> ++#include <vlibmemory/api.h> ++#include <jni.h> ++ ++/* Global state for JVPP-VES */ ++typedef struct { ++ /* Pointer to shared memory queue */ ++ unix_shared_memory_queue_t * vl_input_queue; ++ ++ /* VPP api client index */ ++ u32 my_client_index; ++ ++ /* Callback object and class references enabling asynchronous Java calls */ ++ jobject callbackObject; ++ jclass callbackClass; ++ ++} ves_main_t; ++ ++ves_main_t ves_main __attribute__((aligned (64))); ++ ++ ++#endif /* __included_jvpp_ves_h__ */ +-- +2.12.2.windows.2 + |