Ceilometer项目源码分析----ceilometer-agent-notification服务的初始化和启动

感谢朋友支持本博客，欢迎共同探讨交流，由于能力和时间有限，错误之处在所难免，欢迎指正！

如果转载，请保留作者信息。
博客地址：http://blog.csdn.net/gaoxingnengjisuan
邮箱地址：dong.liu@siat.ac.cn

PS：最近没有登录博客，很多朋友的留言没有看见，这里道歉！还有就是本人较少上QQ，可以邮件交流。

ceilometer-agent-notification服务的初始化和启动

    本篇博客将解析服务组件ceilometer-agent-compute的初始化和启动操作。ceilometer-agent-notification服务组件实现访问oslo-messaging，openstack中各个模块都会推送通知（notification）信息到oslo-messaging消息框架，ceilometer-agent-notification通过访问这个消息队列服务框架，获取相关通知信息，并进一步转化为采样数据的格式。从消息队列服务框架获取通知信息，并进一步获取采样数据信息，可以理解为被动获取监控数据操作，需要一直监听oslo-messaging消息队列。

    来看方法/ceilometer/cli.py----def agent_notification,这个方法即实现了ceilometer-agent-notification服务的初始化和启动操作。

def agent_notification():
    service.prepare_service()
    launcher = os_service.ProcessLauncher()
    launcher.launch_service(
        notification.NotificationService(cfg.CONF.host,'ceilometer.agent.notification'),
        # workers默认值为1；
        workers=service.get_workers('notification'))
    launcher.wait()

1 服务ceilometer-agent-notification的初始化操作

服务ceilometer-agent-notification的初始化操作主要实现了以下内容的操作：

（1）若干参数的初始化，定义了所要监听序列的host和topic；

（2）建立线程池，用于后续服务中若干操作的运行；

class Service(service.Service)----def __init__

class Service(service.Service):
    def __init__(self, host, topic, manager=None, serializer=None):
        """
        NotificationService(cfg.CONF.host,'ceilometer.agent.notification')
        host:cfg.CONF.host
        topic:'ceilometer.agent.notification'
        """
        super(Service, self).__init__()
        self.host = host
        self.topic = topic
        self.serializer = serializer
        if manager is None:
            self.manager = self
        else:
            self.manager = manager

class Service(object)----def __init__

class Service(object):
    def __init__(self, threads=1000):
        self.tg = threadgroup.ThreadGroup(threads)
        self._done = event.Event()

2 服务ceilometer-agent-notification的启动操作

服务ceilometer-agent-notification的启动操作实现了以下任务：

（1）加载命名空间'ceilometer.dispatcher'中的插件；

（2）为RPC通信建立到信息总线的连接，建立指定类型的消息消费者；

（3）启动协程实现启动启动消费者线程，等待并消费处理队列'ceilometer.agent.notification'中的消息；

（4）连接到消息总线来获取通知信息；实际上就是实现监听oslo-messaging消息框架中compute/image/network/heat/cinder等服务的队列；

（5）从队列中获取通知信息，将通知转换程采样数据的格式，然后进行采样数据的发布操作；从通知获取采样数据信息，可以理解为被动获取数据操作；

class NotificationService----def start

class NotificationService(service.DispatchedService, rpc_service.Service):
    NOTIFICATION_NAMESPACE = 'ceilometer.notification'
    def start(self):
        super(NotificationService, self).start()
        # Add a dummy thread to have wait() working
        self.tg.add_timer(604800, lambda: None)

class DispatchedService----def start

加载命名空间'ceilometer.dispatcher'中的插件：
ceilometer.dispatcher =
    database = ceilometer.dispatcher.database:DatabaseDispatcher
    file = ceilometer.dispatcher.file:FileDispatcher

class DispatchedService(object):
    DISPATCHER_NAMESPACE = 'ceilometer.dispatcher'
    def start(self):
        """
        加载命名空间'ceilometer.dispatcher'中的插件：
        ceilometer.dispatcher =
        database = ceilometer.dispatcher.database:DatabaseDispatcher
        file = ceilometer.dispatcher.file:FileDispatcher
        """
        super(DispatchedService, self).start()
        LOG.debug(_('loading dispatchers from %s'),
                  self.DISPATCHER_NAMESPACE)
        
        self.dispatcher_manager = named.NamedExtensionManager(
            # self.DISPATCHER_NAMESPACE = ceilometer.dispatcher
            namespace=self.DISPATCHER_NAMESPACE,
            # cfg.CONF.dispatcher = ['database']
            names=cfg.CONF.dispatcher,
            invoke_on_load=True,
            invoke_args=[cfg.CONF])
        if not list(self.dispatcher_manager):
            LOG.warning(_('Failed to load any dispatchers for %s'),
                        self.DISPATCHER_NAMESPACE)

class Service(service.Service)----def start

这个方法主要完成了以下步骤的内容操作：

（1）为RPC通信建立到信息总线的连接，建立指定类型的消息消费者；

（2）启动协程实现启动启动消费者线程，等待并消费处理队列'ceilometer.agent.notification'中的消息；

（3）连接到消息总线来获取通知信息；实际上就是实现监听oslo-messaging消息框架中compute/image/network/heat/cinder等服务的队列；

（4）从队列中获取通知信息，将通知转换程采样数据的格式，然后进行采样数据的发布操作；从通知获取采样数据信息，可以理解为被动获取数据操作；

注：第（3）（4）步骤是通过执行方法initialize_service_hook实现的；

class Service(service.Service):
    def start(self):
        """
        为RPC通信建立到信息总线的连接；
        1.建立指定类型的消息消费者；       
        2.执行方法initialize_service_hook；
        3.启动协程实现等待并消费处理队列中的消息；
        """
        super(Service, self).start()

        """
        为RPC通信建立到信息总线的连接；
        建立一个新的连接，或者从连接池中获取一个；
        """
        self.conn = rpc.create_connection(new=True)
        LOG.debug(_("Creating Consumer connection for Service %s") %
                  self.topic)

        """
        RpcDispatcher：RPC消息调度类；
        """
        dispatcher = rpc_dispatcher.RpcDispatcher([self.manager],
                                                  self.serializer)

        # Share this same connection for these Consumers
        """
        create_consumer：建立指定类型的消息消费者（fanout or topic）；
        1.创建以服务的topic为路由键的消费者；
        2.创建以服务的topic和本机名为路由键的消费者
          （基于topic&host，可用来接收定向消息）;
        3.fanout直接投递消息，不进行匹配，速度最快
          （fanout类型，可用于接收广播消息）；
        """
        self.conn.create_consumer(self.topic, dispatcher, fanout=False)
        node_topic = '%s.%s' % (self.topic, self.host)
        self.conn.create_consumer(node_topic, dispatcher, fanout=False)
        self.conn.create_consumer(self.topic, dispatcher, fanout=True)

        # Hook to allow the manager to do other initializations after
        # the rpc connection is created.
        """
        在消息消费进程启动前，必须先声明消费者；
        建立一个'topic'类型的消息消费者；
        根据消费者类（TopicConsumer）和消息队列名称
        （pool_name：  ceilometer.collector.metering）
        以及指定主题topic（metering）建立消息消费者，并加入消费者列表；
        """
        if callable(getattr(self.manager, 'initialize_service_hook', None)):
            self.manager.initialize_service_hook(self)

        """
        启动消费者线程；
        consume_in_thread用evelent.spawn创建一个协程一直运行；
        等待消息，在有消费到来时会创建新的协程运行远程调用的函数；
        启动协程实现等待并消费处理队列中的消息；
        """
        self.conn.consume_in_thread()

下面来重点分析方法class NotificationService----def initialize_service_hook，这个方法主要实现以下步骤的内容操作：

1.获取与命名空间ceilometer.event.trait_plugin相匹配的所有插件，并加载；
  ceilometer.event.trait_plugin =
      split = ceilometer.event.trait_plugins:SplitterTraitPlugin
      bitfield = ceilometer.event.trait_plugins:BitfieldTraitPlugin
2.获取与命名空间ceilometer.notification相匹配的所有插件，并加载；
  ceilometer.notification =
      instance = ceilometer.compute.notifications.instance:Instance
      ......
      stack_crud = ceilometer.orchestration.notifications:StackCRUD
  这些插件描述了针对各个监控项，如何从对应的通知中获取相关监控信息并形成采样格式；
3.连接到消息总线来获取通知信息；
  实际上就是实现监听oslo-messaging消息框架中compute/image/network/heat/cinder等服务的队列；
  从队列中获取通知信息，将通知转换程采样数据的格式，然后进行采样数据的发布操作；

class NotificationService----def initialize_service_hook

class NotificationService(service.DispatchedService, rpc_service.Service):
    NOTIFICATION_NAMESPACE = 'ceilometer.notification'
    def initialize_service_hook(self, service):
        '''
        主要实现的功能：
        1.加载命名空间'ceilometer.notification'的所有插件：
        2.遍历上述加载的所有插件，均执行方法：_setup_subscription
        注：_setup_subscription：连接到消息总线来获取通知信息；
        实际上就是实现监听oslo-messaging消息框架中compute/image/network/heat/cinder等服务的队列；
        从队列中获取通知信息，将通知转换程采样数据的格式，然后进行采样数据的发布操作；
        从通知获取采样数据信息，可以理解为被动获取数据操作；
        '''
        self.pipeline_manager = pipeline.setup_pipeline()

        LOG.debug(_('Loading event definitions'))
        
        """
        extension.ExtensionManager：
        获取与namespace(ceilometer.event.trait_plugin)相匹配的所有插件，并加载；
        ceilometer.event.trait_plugin =
        split = ceilometer.event.trait_plugins:SplitterTraitPlugin
        bitfield = ceilometer.event.trait_plugins:BitfieldTraitPlugin
        """
        self.event_converter = event_converter.setup_events(
            extension.ExtensionManager(
                namespace='ceilometer.event.trait_plugin'))

        """
        NOTIFICATION_NAMESPACE = 'ceilometer.notification'
        加载命名空间'ceilometer.notification'的插件：
        """
        self.notification_manager = \
            extension.ExtensionManager(
                namespace=self.NOTIFICATION_NAMESPACE,
                invoke_on_load=True,
            )

        if not list(self.notification_manager):
            LOG.warning(_('Failed to load any notification handlers for %s'),
                        self.NOTIFICATION_NAMESPACE)
        
        """
        连接到消息总线来获取通知信息；
        实际上就是实现监听oslo-messaging消息框架中compute/image/network/heat/cinder等服务的队列；
        从队列中获取通知信息，将通知转换程采样数据的格式，然后进行采样数据的发布操作；
        从通知获取采样数据信息，可以理解为被动获取数据操作；
        
        遍历上述加载的所有插件，均执行方法：
        def _setup_subscription(ext, *args, **kwds)
        其中ext即为遍历的上述加载的插件；
        """
        self.notification_manager.map(self._setup_subscription)

上述代码主要实现了三部分的内容，下面来进行细致的分析；

步骤1：

self.event_converter = event_converter.setup_events(
    extension.ExtensionManager(
        namespace='ceilometer.event.trait_plugin'))

这里主要实现获取与命名空间ceilometer.event.trait_plugin相匹配的所有插件，并加载；

ceilometer.event.trait_plugin =
        split = ceilometer.event.trait_plugins:SplitterTraitPlugin
        bitfield = ceilometer.event.trait_plugins:BitfieldTraitPlugin

步骤2：

self.notification_manager = \
    extension.ExtensionManager(
        namespace=self.NOTIFICATION_NAMESPACE,
        invoke_on_load=True,
    )

这里主要实现获取与命名空间ceilometer.notification相匹配的所有插件，并加载；

ceilometer.notification =
        instance = ceilometer.compute.notifications.instance:Instance
        instance_flavor = ceilometer.compute.notifications.instance:InstanceFlavor
        instance_delete = ceilometer.compute.notifications.instance:InstanceDelete
        instance_scheduled = ceilometer.compute.notifications.instance:InstanceScheduled
        memory = ceilometer.compute.notifications.instance:Memory
        vcpus = ceilometer.compute.notifications.instance:VCpus
        disk_root_size = ceilometer.compute.notifications.instance:RootDiskSize
        disk_ephemeral_size = ceilometer.compute.notifications.instance:EphemeralDiskSize
        cpu_frequency = ceilometer.compute.notifications.cpu:CpuFrequency
        cpu_user_time = ceilometer.compute.notifications.cpu:CpuUserTime
        cpu_kernel_time = ceilometer.compute.notifications.cpu:CpuKernelTime
        cpu_idle_time = ceilometer.compute.notifications.cpu:CpuIdleTime
        cpu_iowait_time = ceilometer.compute.notifications.cpu:CpuIowaitTime
        cpu_kernel_percent = ceilometer.compute.notifications.cpu:CpuKernelPercent
        cpu_idle_percent = ceilometer.compute.notifications.cpu:CpuIdlePercent
        cpu_user_percent = ceilometer.compute.notifications.cpu:CpuUserPercent
        cpu_iowait_percent = ceilometer.compute.notifications.cpu:CpuIowaitPercent
        cpu_percent = ceilometer.compute.notifications.cpu:CpuPercent
        volume = ceilometer.volume.notifications:Volume
        volume_size = ceilometer.volume.notifications:VolumeSize
        image_crud = ceilometer.image.notifications:ImageCRUD
        image = ceilometer.image.notifications:Image
        image_size = ceilometer.image.notifications:ImageSize
        image_download = ceilometer.image.notifications:ImageDownload
        image_serve = ceilometer.image.notifications:ImageServe
        network = ceilometer.network.notifications:Network
        subnet = ceilometer.network.notifications:Subnet
        port = ceilometer.network.notifications:Port
        router = ceilometer.network.notifications:Router
        floatingip = ceilometer.network.notifications:FloatingIP
        bandwidth = ceilometer.network.notifications:Bandwidth
        http.request = ceilometer.middleware:HTTPRequest
        http.response = ceilometer.middleware:HTTPResponse
        stack_crud = ceilometer.orchestration.notifications:StackCRUD

这些插件描述了针对各个监控项，如何从对应的通知中获取相关监控信息并形成采样格式；

步骤3：

self.notification_manager.map(self._setup_subscription)

这里所实现的功能是：

连接到消息总线来获取通知信息；实际上就是实现监听oslo-messaging消息框架中compute/image/network/heat/cinder等服务的队列；从队列中获取通知信息，将通知转换程采样数据的格式，然后进行采样数据的发布操作；

这条语句的执行操作是遍历命名空间ceilometer.notification的所有插件，均执行方法：
def _setup_subscription(ext, *args, **kwds)

方法_setup_subscription解析：

方法_setup_subscription所实现的功能：

针对上述加载的命名空间ceilometer.notification中的一个插件，执行以下操作：
1.调用方法get_exchange_topics获取插件的ExchangeTopics序列；
class ComputeNotificationBase----def get_exchange_topics；
class ImageBase----def get_exchange_topics；
class NetworkNotificationBase----def get_exchange_topics；
class StackCRUD----def get_exchange_topics；
class _Base（卷）----def get_exchange_topics；
ExchangeTopics序列描述了用于连接到所监听队列的交换器exchange和topics；
经过分析所获取的exchange和topics的值为：
topics = 'notifications.info'指定所要监听的消息队列；
exchange = nova/glance/neutron/heat/cinder来区分获取不同服务的通知信息；
2.遍历所监听的消息队列（暂时只有一个队列notifications.info），实现：
2.1.建立一个'topic'类型的消息消费者；
2.2.监听topic指定的消息队列（notifications.info），当进行消息消费操作的时候，将层层调用，最终实现调用方法self.process_notification，实现将接收到的通知转换成采样数据的格式，并进行发布；
（1）根据不同监控项调用不同插件中的process_notification方法，实现从通知中获取监控项的采样数据信息；
（2）实现发布监控项采样数据样本（File/RPC/UDP）；

来看方法_setup_subscription的源码：

    def _setup_subscription(self, ext, *args, **kwds):
        """       
        针对上述加载的命名空间ceilometer.notification中的一个插件，执行以下操作：
        1.调用方法get_exchange_topics获取插件的ExchangeTopics序列；
        class ComputeNotificationBase(plugin.NotificationBase)----def get_exchange_topics；
        class ImageBase(plugin.NotificationBase)----def get_exchange_topics；
        class NetworkNotificationBase(plugin.NotificationBase)----def get_exchange_topics；
        class StackCRUD(plugin.NotificationBase)----def get_exchange_topics；
        class _Base(plugin.NotificationBase)（卷）----def get_exchange_topics；
        ExchangeTopics序列描述了用于连接到所监听队列的交换器exchange和topics；
        经过分析所获取的exchange和topics的值为：
        topics = 'notifications.info'指定所要监听的消息队列；
        exchange = nova/glance/neutron/heat/cinder来区分获取不同服务的通知信息；
        2.遍历所监听的消息队列（暂时只有一个队列notifications.info），实现：
        2.1.建立一个'topic'类型的消息消费者；
        2.2.监听topic指定的消息队列（notifications.info），当进行消息消费操作的时候，将层层调用，
        最终实现调用方法self.process_notification，实现将接收到的通知转换成采样数据的格式，并进行发布；
        (1).根据不同监控项和具体插件调用不同的process_notification方法，实现从通知中获取监控项的采样数据信息；
        (2).实现发布监控项采样数据样本（File/RPC/UDP）；
        """
        handler = ext.obj
        
        """
        default = True
        """
        ack_on_error = cfg.CONF.notification.ack_on_event_error
        LOG.debug(_('Event types from %(name)s: %(type)s'
                    ' (ack_on_error=%(error)s)') %
                  {'name': ext.name,
                   'type': ', '.join(handler.event_types),
                   'error': ack_on_error})

        """
        调用方法get_exchange_topics获取插件的ExchangeTopics序列；
        class ComputeNotificationBase(plugin.NotificationBase)----def get_exchange_topics；
        class ImageBase(plugin.NotificationBase)----def get_exchange_topics；
        class NetworkNotificationBase(plugin.NotificationBase)----def get_exchange_topics；
        class StackCRUD(plugin.NotificationBase)----def get_exchange_topics；
        class _Base(plugin.NotificationBase)（卷）----def get_exchange_topics；
        ExchangeTopics序列描述了用于连接到所监听队列的交换器exchange和topics；
        经过分析所获取的exchange和topics的值为：
        topics = 'notifications.info'指定所要监听的消息队列；
        exchange = nova/glance/neutron/heat/cinder来区分获取不同服务的通知信息；
        """
        for exchange_topic in handler.get_exchange_topics(cfg.CONF):
            """
            遍历所监听的消息队列（暂时只有一个队列notifications.info）；
            """
            for topic in exchange_topic.topics:
                try:         
                    """
                    实现封装方法callback，即self.process_notification；
                    1.建立一个'topic'类型的消息消费者；
                    2.监听topic指定的消息队列（notifications.info），当进行消息消费操作的时候，将层层调用，
                      最终实现调用方法callback_wrapper，即self.process_notification；
                    
                    callback=self.process_notification
                    将接收到的通知转换成采样数据的格式，并进行发布；
                    1.根据不同监控项和具体插件调用不同的process_notification方法，
                      实现从通知中获取监控项的采样数据信息；
                    2.实现发布监控项采样数据样本（File/RPC/UDP）；
                    """
                    self.conn.join_consumer_pool(
                        # process_notification：将接收到的通知转换成采样数据的格式，并进行发布；
                        callback=self.process_notification,
                        pool_name=topic,
                        topic=topic,
                        exchange_name=exchange_topic.exchange,
                        ack_on_error=ack_on_error)
                except Exception:
                    LOG.exception(_('Could not join consumer pool'
                                    ' %(topic)s/%(exchange)s') %
                                  {'topic': topic,
                                   'exchange': exchange_topic.exchange})

接着来看这里所调用的方法process_notification：

    def process_notification(self, notification):
        """
        RPC endpoint for notification messages
        将接收到的通知转换成采样数据的格式，并进行发布；
        1.根据不同监控项和具体插件调用不同的process_notification方法，
          实现从通知中获取监控项的采样数据信息；
        2.实现发布监控项采样数据样本（File/RPC/UDP）；

        When another service sends a notification over the message
        bus, this method receives it. See _setup_subscription().
        """
        LOG.debug(_('notification %r'), notification.get('event_type'))
        
        """
        _process_notification_for_ext：
        将接收到的通知转换成采样数据的格式，并进行发布；
        1.根据不同监控项和具体插件调用不同的process_notification方法，
          实现从通知中获取监控项的采样数据信息；
        2.实现发布监控项采样数据样本（File/RPC/UDP）；
        """
        self.notification_manager.map(self._process_notification_for_ext,
                                      notification=notification)

        # cfg.CONF.notification.store_events：默认值为False；
        if cfg.CONF.notification.store_events:
            # 转换通知消息到Ceilometer Event；
            self._message_to_event(notification)

再来看方法_process_notification_for_ext：

    def _process_notification_for_ext(self, ext, notification):
        """
        将接收到的通知转换成采样数据的格式，并进行发布；
        1.根据不同监控项和具体插件调用不同的process_notification方法，
          实现从通知中获取监控项的采样数据信息；
        2.实现发布监控项采样数据样本（File/RPC/UDP）；
        
        to_samples：
        根据不同监控项和具体插件调用以下process_notification方法，实现从通知中获取监控项的采样数据信息；
        class ComputeMetricsNotificationBase----def process_notification(self, message)
        class UserMetadataAwareInstanceNotificationBase----def process_notification(self, message)
        class ImageCRUD(ImageCRUDBase)----def process_notification(self, message)
        class Image(ImageCRUDBase)----def process_notification(self, message)
        class ImageSize(ImageCRUDBase)----def process_notification(self, message)
        class ImageDownload(ImageBase)----def process_notification(self, message)
        class ImageServe(ImageBase)----def process_notification(self, message)
        class NetworkNotificationBase(plugin.NotificationBase)----def process_notification(self, message)
        class Bandwidth(NetworkNotificationBase)----def process_notification(self, message)
        class StackCRUD(plugin.NotificationBase)----def process_notification(self, message)
        class Volume(_Base)----def process_notification(self, message)
        class VolumeSize(_Base)----def process_notification(self, message)
        class HTTPRequest(plugin.NotificationBase)----def process_notification(self, message)
        class NotificationService(service.DispatchedService, rpc_service.Service)----def process_notification(self, notification)
        
        publisher：
        实现发布监控项采样数据样本；
        1.class FilePublisher(publisher.PublisherBase)----def publish_samples(self, context, samples)；
        实现发布采样数据到一个日志文件；
        2.class RPCPublisher(publisher.PublisherBase)----def publish_samples(self, context, samples)；
        通过RPC发布采样数据；
        * 从若干采样数据信息samples中获取提取数据形成信息格式meters，为信息的发布或存储做准备；
        * 将之前从采样数据中提取的信息meters包装成msg；
        * 将匹配的topic，msg添加到本地队列local_queue中，topic默认为metering；
        * 实现发布本地队列local_queue中的所有数据信息到队列metering中；
        * 其中，消息msg中封装的'method'方法为'record_metering_data'，即当消息被消费时，将会
          执行方法record_metering_data，实现存储到数据存储系统中（数据库）；
        3.class UDPPublisher(publisher.PublisherBase)----def publish_samples(self, context, samples)
        通过UDP发布采样数据；
        
        to_samples:
        根据不同监控项和具体插件调用以下process_notification方法，
        实现从通知中获取监控项的采样数据信息；
        """
        with self.pipeline_manager.publisher(context.get_admin_context()) as p:
            # FIXME(dhellmann): Spawn green thread?
            p(list(ext.obj.to_samples(notification)))

再来看方法to_samples：

def to_samples(self, notification):
        """
        根据不同监控项和具体插件调用以下process_notification方法，
        实现从通知中获取监控项的采样数据信息；
        class ComputeMetricsNotificationBase----def process_notification(self, message)
        class UserMetadataAwareInstanceNotificationBase----def process_notification(self, message)
        class ImageCRUD(ImageCRUDBase)----def process_notification(self, message)
        class Image(ImageCRUDBase)----def process_notification(self, message)
        class ImageSize(ImageCRUDBase)----def process_notification(self, message)
        class ImageDownload(ImageBase)----def process_notification(self, message)
        class ImageServe(ImageBase)----def process_notification(self, message)
        class NetworkNotificationBase(plugin.NotificationBase)----def process_notification(self, message)
        class Bandwidth(NetworkNotificationBase)----def process_notification(self, message)
        class StackCRUD(plugin.NotificationBase)----def process_notification(self, message)
        class Volume(_Base)----def process_notification(self, message)
        class VolumeSize(_Base)----def process_notification(self, message)
        class HTTPRequest(plugin.NotificationBase)----def process_notification(self, message)
        class NotificationService(service.DispatchedService, rpc_service.Service)----def process_notification(self, notification)
        """
        if self._handle_event_type(notification['event_type'],
                                   self.event_types):
            return self.process_notification(notification)
        return []

同样，这里实现监控信息发布操作可选取三种模式RPC/UDP/FILE：

模式1：实现发布采样数据到一个日志文件

class FilePublisher(publisher.PublisherBase):  
    def publish_samples(self, context, samples):  
        if self.publisher_logger:  
            for sample in samples:  
                self.publisher_logger.info(sample.as_dict())  

模式2：通过RPC发布采样数据（具体见代码注释）

class RPCPublisher(publisher.PublisherBase):  
    def publish_samples(self, context, samples):  
        """ 
        通过RPC发布信息； 
        1.从若干采样数据信息samples中获取提取数据形成信息格式meters，为信息的发布或存储做准备； 
        2.将之前从采样数据中提取的信息meters包装成msg； 
        3.将匹配的topic，msg添加到本地队列local_queue中，topic默认为metering； 
        4.实现发布本地队列local_queue中的所有数据信息到队列metering中； 
        5.其中，消息msg中封装的'method'方法为'record_metering_data'，即当消息被消费时，将会 
          执行方法record_metering_data，实现存储到数据存储系统中（数据库）； 
        """  
      
        # 从若干采样数据信息中获取提取数据形成信息格式，为信息的发布或存储做准备；  
        meters = [  
            # meter_message_from_counter：  
            # 为一个监控采样数据做好准备被发布或存储；  
            # 从一个采样数据信息中获取提取信息形成msg；  
            utils.meter_message_from_counter(  
                sample,  
                cfg.CONF.publisher.metering_secret)  
            for sample in samples  
        ]  
      
        # cfg.CONF.publisher_rpc.metering_topic：metering messages所使用的主题，默认为metering；  
        topic = cfg.CONF.publisher_rpc.metering_topic  
              
        # 将之前从采样数据中提取的信息meters包装成msg；  
        msg = {  
            'method': self.target,  
            'version': '1.0',  
            'args': {'data': meters},  
        }  
              
        # 将匹配的topic，msg添加到本地队列local_queue中，topic默认为metering；  
        self.local_queue.append((context, topic, msg))  
      
        if self.per_meter_topic:  
            for meter_name, meter_list in itertools.groupby(  
                    sorted(meters, key=operator.itemgetter('counter_name')),  
                    operator.itemgetter('counter_name')):  
                msg = {  
                    'method': self.target,  
                    'version': '1.0',  
                    'args': {'data': list(meter_list)},  
                }  
                topic_name = topic + '.' + meter_name  
                LOG.audit(_('Publishing %(m)d samples on %(n)s') % (  
                          {'m': len(msg['args']['data']), 'n': topic_name}))  
                self.local_queue.append((context, topic_name, msg))  
      
        # 实现发布本地队列local_queue中的所有数据信息；  
        self.flush()

def flush(self):  
    """ 
    实现发布本地队列中的所有数据信息； 
    """          
    # 获取本地队列的数据信息；  
    queue = self.local_queue  
    self.local_queue = []  
              
    # 实现循环发布队列queue中的信息数据；  
    self.local_queue = self._process_queue(queue, self.policy) + \self.local_queue  
              
    if self.policy == 'queue':  
        self._check_queue_length()

@staticmethod  
def _process_queue(queue, policy):  
    """ 
    实现循环发布队列queue中的信息数据； 
    """  
    while queue:  
        # 取出第一位的topic、msg等数据；  
        context, topic, msg = queue[0]  
        try:  
            # 实现远程发布信息，不返回任何值；  
            rpc.cast(context, topic, msg)  
        except (SystemExit, rpc.common.RPCException):  
            samples = sum([len(m['args']['data']) for n, n, m in queue])  
            if policy == 'queue':  
                LOG.warn(_("Failed to publish %d samples, queue them"),samples)  
                return queue  
            elif policy == 'drop':  
                LOG.warn(_("Failed to publish %d samples, dropping them"),samples)  
                return []  
            # default, occur only if rabbit_max_retries > 0  
            raise  
        else:  
            # 从队列中删除发布后的信息；  
            queue.pop(0)  
    return []

模式3：通过UDP发布采样数据（具体见代码注释）

class UDPPublisher(publisher.PublisherBase):  
    def publish_samples(self, context, samples):  
        """ 
        通过UDP协议发送meter信息到服务器端，实现监控信息的发布； 
        """  
        for sample in samples:  
            """ 
            为一个监控采样数据做好准备被发布或存储； 
            从一个采样数据信息中获取提取信息形成msg； 
            """  
            msg = utils.meter_message_from_counter(  
                sample,  
                cfg.CONF.publisher.metering_secret)  
            host = self.host  
            port = self.port  
            LOG.debug(_("Publishing sample %(msg)s over UDP to "  
                        "%(host)s:%(port)d") % {'msg': msg, 'host': host,'port': port})  
            """ 
            通过UDP协议发送meter信息到服务器端，实现监控信息的发布； 
            """  
            try:  
                self.socket.sendto(msgpack.dumps(msg),(self.host, self.port))  
            except Exception as e:  
                LOG.warn(_("Unable to send sample over UDP"))  
                LOG.exception(e)