Tag Archives: neutron

How to create an Open Virtual Network distributed gateway router

Note: This article is originally published here

In this article, I discuss external connectivity in Open Virtual Network (OVN), a subproject of Open vSwitch (OVS), using a distributed gateway router.

OVN provides external connectivity in two ways:

  • A logical router with a distributed gateway port, which is referred to as a distributed gateway router in this article
  • A logical gateway router

In this article, you will see how to create a distributed gateway router and an example of how it works.

Creating a distributed gateway router has some advantages over using a logical gateway router for the CMS (cloud management system):

  • It is easier to create a distributed gateway router because the CMS doesn’t need to create a transit logical switch, which is needed for a logical gateway router.
  • A distributed gateway router supports distributed north/south traffic, whereas the logical gateway router is centralized on a single gateway chassis.
  • A distributed gateway router supports high availability.

Note: The CMS can be OpenStack, Red Hat OpenShift, Red Hat Virtualization, or any other system that manages a cloud.

Continue reading

Logging configuration in OpenContrail

We know that all software components and services generate log files. These log files are vital in troubleshooting and debugging problems. If the log files are not managed properly then it can  be extremely  difficult to get a good look into them.

Although system administrators cannot control the generation of logs, they can achieve  some level of log management by

  • having log rotators to get rid of the old log files.
  • using syslog to catch alerts.
  • archiving logs etc.

OpenContrail has several components, many of which can generate logs as well as store them in the log files. OpenContrail also provides the mechanism to configure the logging, so that the system administrators / DevOps can define the logging parameters to suite their own requirements.

In this blog post we will see logging support in OpenContrail components and what are the logging configuration mechanisms supported by it.

OpenContrail uses Sandesh protocol which provides the mechanism to exchange messages between various OpenContrail components. It also provides the functionality of logging those messages and the logs into the log files. You can read more about Sandesh in this great article

Logging can be configured by :

  • choosing the log file
  • selecting the log file size
  • defining custom formatters/loggers
  • using syslog etc.

OpenContrail has mainly Python components and C++ components.

Python components of OpenContrail are :

  • contrail API server
  • schema transformer
  • SVC monitor
  • discovery server
  • analytics Op server

C++ components of OpenContrail are :

  •  contrail vrouter
  •  contrail controller
  •  Query engine
  •  contrail analytics server
  •  contrail DNS

C++ components of OpenContrail use log4cplus for logging and python components use python logging.

OpenContrail versions

The configuration mechanisms defined in this post are supported by the master version of OpenContrail.

You need to cherry pick the below patches if you are using R2.2 or R2.1 version as these patches are still not merged yet.

OpenContrail R2.2

https://review.opencontrail.org/#/c/11106/

OpenContrail R2.1

https://review.opencontrail.org/#/c/11116/

https://review.opencontrail.org/#/c/11105/

Logging in OpenContrail python modules

First we will talk about logging in python components of OpenContrail. OpenContrail supports logging configuration for python components in three ways:

  1. Use the default logging provided by OpenContrail.
  2. Define your own log configuration file based on the python logging
  3. Define new logging mechanism by implementing a new logger or using other logging libraries like oslo.log

The configuration files of python components support the below logging parameters:

  • log_file
  • log_level
  • log_local
  • logging_conf
  • logger_class

In order to define custom logging configuration, we need to use the ‘logging_conf’ and ‘logger_class’ parameters. When these two parameters are defined, the other ones are ignored.

1. Use the default logging provided by OpenContrail.

You don’t have to do anything here. If you are not particular about logging configuration, then this is good enough.

2. Define your own log configuration file based on the python logging

You can define your own log configuration file. Please refer to the logging file format for more information on how to define the log config file for pythin logging.

Define the ‘logger_class’ and ‘logging_conf’ configuration parameters in the OpenContrail python component configuration files.

logger_class = pysandesh.sandesh_logger.SandeshConfigLogger
logging_conf = PATH TO THE LOG CONFIG FILE

Eg.

contrail-api.conf

[DEFAULT]
...
logger_class = pysandesh.sandesh_logger.SandeshConfigLogger
logging_conf = /etc/contrail/contrail-api-logger.conf

Format of the log configuration file

As mentioned above this has all the details about defining the log configuration file.

Log configuration file should have three main sections defined – [loggers],[handlers] and [formatters].

Below is a sample log configuration file format. This sample file can be used for all the OpenContrail python components. You can define one configuration file per module as well.

[loggers]
keys=root,contrail_api,contrail_svc_monitor,contrail_schema,contrail_discovery_handler,contrail_analytics_api

[handlers]
keys=root_handler,contrail_api_handler,contrail_syslog_handler,contrail_svc_handler,contrail_schema_handler,contrail_analytics_handler

[formatters]
keys=contrail_formatter,contrail_syslog_formatter,svc_formatter

[logger_root]
level=NOTSET
handlers=root_handler

[logger_contrail_api]
level=NOTSET
handlers=contrail_api_handler,contrail_syslog_handler
qualname=contrail-api
propagate=0

[logger_contrail_svc_monitor]
level=NOTSET
handlers=contrail_svc_handler,contrail_syslog_handler
qualname=contrail-svc-monitor
propagate=0

[logger_contrail_schema]
level=NOTSET
handlers=contrail_schema_handler,contrail_syslog_handler
qualname=contrail-schema
propagate=0

[logger_contrail_discovery]
level=NOTSET
handlers=contrail_discovery_handler,contrail_syslog_handler
qualname=contrail-discovery
propagate=1

[handler_root_handler]
class=StreamHandler
level=NOTSET
formatter=contrail_formatter
args=()

[handler_contrail_api_handler]
class=handlers.RotatingFileHandler
args=('/var/log/contrail/contrail-api.log', 'a', 3000000, 10)
formatter=contrail_formatter

[handler_contrail_svc_handler]
class=handlers.RotatingFileHandler
args=('/var/log/contrail/svc-monitor.log', 'a', 3000000, 8)
formatter=svc_formatter

[handler_contrail_schema_handler]
class=handlers.RotatingFileHandler
args=('/var/log/contrail/contrail-schema.log', 'a', 2000000, 7)
formatter=contrail_formatter

[handler_contrail_discovery_handler]
class=handlers.RotatingFileHandler
args=('/var/log/contrail/contrail-discovery-conf.log', 'a', 3000000, 0)
formatter=contrail_formatter

[handler_contrail_analytics_handler]
class=handlers.RotatingFileHandler
args=('/var/log/contrail/contrail-analytics.log', 'a', 3000000, 0)
formatter=contrail_formatter


[handler_contrail_syslog_handler]
class=handlers.SysLogHandler
level=ERROR
formatter=contrail_syslog_formatter
args=('/dev/log', handlers.SysLogHandler.LOG_USER)

[formatter_contrail_formatter]
format= %(asctime)s [%(name)s]: %(message)s
datefmt=%m/%d/%Y %I:%M:%S %p
class=logging.Formatter

[formatter_contrail_syslog_formatter]
format=contrail : %(asctime)s [%(name)s]: %(message)s
datefmt=%m/%d/%Y %I:%M:%S %p
class=logging.Formatter

[formatter_svc_formatter]
format=SVC MON %(asctime)s [%(name)s]: %(message)s
datefmt=%m/%d/%Y %I:%M:%S %p
class=logging.Formatter


As you can see above, a logger is defined for each of the OpenContrail components.

[logger_contrail_api]
level=NOTSET
handlers=contrail_api_handler,contrail_syslog_handler
qualname=contrail-api
propagate=0

‘qualname’ should match the OpenContrail component name, otherwise the logger defined for the OpenContrail component would not get reflected.

Below are the ‘qualname’ for each of the OpenContrail components.

Component name qualname
Contrail Api server contrail-api
SVC Monitor contrail-svc-monitor
Schema Transformer contrail-schema
Contrail Discovery contrail-discovery
Contrail Analytics API contrail-analytics-api

Defining your own logging configuration file gives you the flexibility to choose the logging parameters as per your requirements.

You can choose the logging handlers supported by the python logging like RotatingFileHandler, TimedRotatingFileHandler, WatchedFileHandler, MemoryHandler etc.

You can also choose a simple handler like FileHander and use logrotate or other external log rotaters to rotate the log files.

3. Define your own custom logging mechanism or use existing logging libraries.

If you’r someone who likes to define your new logging mechanism, this can also be done.

In order to do this you need to first:

  • write your custom logging class
  • define the custom logging class in the ‘logger_class’ configuration parameter.

Make sure that your custom python class is loadable. Your custom python class should be derived from ‘sandesh_base_logger.SandeshBaseLogger’.

Contrail Oslo Logger

You can find one custom logger – Contrail Oslo Logger here. Contrail Oslo logger uses the oslo.log and oslo.config modules of OpenStack.

You can define the log configuration options supported by oslo.log in a configuration file and provide the name of the file in the ‘logging_conf’ configuration parameter.

You can find the logging options supported by oslo.log here and here.

If you would like to have your own logging mechanism please see the code of contrail oslo logger as reference.

Logging in OpenContrail C++ components

OpenContrail C++ components use log4cplus  for logging.

OpenContrail supports the below logging parameters in the component configuration files :

  • log_disable : Disable logging
  • log_file    : Name of the log file
  • log_property_file : Path of the log property file.
  • log_files_count : Maximum log file roll over index
  • log_file_size  : Maximum size of the log file
  • log_level  : Severity level for local logging of sandesh messages

Similar to the python logging configuration file, you can define a log configuration file for the C++ components and give the path of the configuration file in the ‘log_property_file’ configuration parameter. When ‘log_property_file’ is defined, other logging parameters are ignored by the OpenContrail C++ components. log4cplus uses the term property file for the log configuration file.

The log property file should be defined in the format described here.

You can refer to this link to understand the format of the log4cplus log property file.

Define ‘log_property_file’ in the DEFAULT section of the C++ component configuration files to use the log property file defined by you.

Eg. contrail-control.conf

[DEFAULT]
log_property_file=/etc/contrail/control-log.properties

Sample lop property file

log4cplus.rootLogger = DEBUG, logfile, syslog

log4cplus.appender.logfile = log4cplus::FileAppender
log4cplus.appender.logfile.File = /var/log/contrail/contrail-collector.log
log4cplus.appender.logfile.Append = true
log4cplus.appender.logfile.ImmediateFlush = true

log4cplus.appender.logfile.layout = log4cplus::PatternLayout

log4cplus.appender.logfile.layout.ConversionPattern = %D{%Y-%m-%d %a %H:%M:%S:%Q %Z} %h [Thread %t, Pid %i]: %m%n

log4cplus.appender.syslog = log4cplus::SysLogAppender
log4cplus.appender.syslog.Threshold=ERROR
log4cplus.appender.syslog.FACILITY=USER
log4cplus.appender.syslog.layout = log4cplus::PatternLayout
log4cplus.appender.syslog.layout.ConversionPattern = %D{%Y-%m-%d %a %H:%M:%S:%Q %Z} %h [Thread %t, Pid %i]: %m%n

You can refer to the Appenders supported by log4cplus here.

Conclusion

You’ve now hopefully seen how logging is supported in OpenContrail and how you can define your own custom logging configuration files. With this knowledge, it should be possible for system admins/DevOps to manage the log files properly and help them quickly and efficiently troubleshoot problems.