package daemon
 

 import (

 	"strings"

 	"time"

 	"github.com/docker/docker/container"

 	daemonevents "github.com/docker/docker/daemon/events"

 	"github.com/docker/engine-api/types/events"

 	"github.com/docker/engine-api/types/filters"

 	"github.com/docker/libnetwork"

 )
 

 // LogContainerEvent generates an event related to a container with only the default attributes.

 func (daemon *Daemon) LogContainerEvent(container *container.Container, action string) {

 	daemon.LogContainerEventWithAttributes(container, action, map[string]string{})
 }
 
 // LogContainerEventWithAttributes generates an event related to a container with specific given attributes.
 func (daemon *Daemon) LogContainerEventWithAttributes(container *container.Container, action string, attributes map[string]string) {
 	copyAttributes(attributes, container.Config.Labels)

 	if container.Config.Image != "" {
 		attributes["image"] = container.Config.Image
 	}
 	attributes["name"] = strings.TrimLeft(container.Name, "/")
 
 	actor := events.Actor{
 		ID:         container.ID,
 		Attributes: attributes,
 	}
 	daemon.EventsService.Log(action, events.ContainerEventType, actor)
 }
 

 // LogImageEvent generates an event related to an image with only the default attributes.

 func (daemon *Daemon) LogImageEvent(imageID, refName, action string) {

 	daemon.LogImageEventWithAttributes(imageID, refName, action, map[string]string{})
 }
 

 // LogImageEventWithAttributes generates an event related to an image with specific given attributes.

 func (daemon *Daemon) LogImageEventWithAttributes(imageID, refName, action string, attributes map[string]string) {

 	img, err := daemon.GetImage(imageID)
 	if err == nil && img.Config != nil {
 		// image has not been removed yet.
 		// it could be missing if the event is `delete`.

 		copyAttributes(attributes, img.Config.Labels)

 	}
 	if refName != "" {
 		attributes["name"] = refName
 	}
 	actor := events.Actor{
 		ID:         imageID,
 		Attributes: attributes,
 	}
 
 	daemon.EventsService.Log(action, events.ImageEventType, actor)
 }
 

 // LogPluginEvent generates an event related to a plugin with only the default attributes.
 func (daemon *Daemon) LogPluginEvent(pluginID, refName, action string) {
 	daemon.LogPluginEventWithAttributes(pluginID, refName, action, map[string]string{})
 }
 
 // LogPluginEventWithAttributes generates an event related to a plugin with specific given attributes.
 func (daemon *Daemon) LogPluginEventWithAttributes(pluginID, refName, action string, attributes map[string]string) {
 	attributes["name"] = refName
 	actor := events.Actor{
 		ID:         pluginID,
 		Attributes: attributes,
 	}
 	daemon.EventsService.Log(action, events.PluginEventType, actor)
 }
 

 // LogVolumeEvent generates an event related to a volume.
 func (daemon *Daemon) LogVolumeEvent(volumeID, action string, attributes map[string]string) {
 	actor := events.Actor{
 		ID:         volumeID,
 		Attributes: attributes,
 	}
 	daemon.EventsService.Log(action, events.VolumeEventType, actor)
 }
 
 // LogNetworkEvent generates an event related to a network with only the default attributes.
 func (daemon *Daemon) LogNetworkEvent(nw libnetwork.Network, action string) {
 	daemon.LogNetworkEventWithAttributes(nw, action, map[string]string{})
 }
 
 // LogNetworkEventWithAttributes generates an event related to a network with specific given attributes.
 func (daemon *Daemon) LogNetworkEventWithAttributes(nw libnetwork.Network, action string, attributes map[string]string) {
 	attributes["name"] = nw.Name()
 	attributes["type"] = nw.Type()
 	actor := events.Actor{

 		ID:         nw.ID(),

 		Attributes: attributes,
 	}
 	daemon.EventsService.Log(action, events.NetworkEventType, actor)
 }
 

 // LogDaemonEventWithAttributes generates an event related to the daemon itself with specific given attributes.
 func (daemon *Daemon) LogDaemonEventWithAttributes(action string, attributes map[string]string) {
 	if daemon.EventsService != nil {

 		if info, err := daemon.SystemInfo(); err == nil && info.Name != "" {
 			attributes["name"] = info.Name
 		}

 		actor := events.Actor{
 			ID:         daemon.ID,
 			Attributes: attributes,
 		}
 		daemon.EventsService.Log(action, events.DaemonEventType, actor)
 	}
 }
 

 // SubscribeToEvents returns the currently record of events, a channel to stream new events from, and a function to cancel the stream of events.
 func (daemon *Daemon) SubscribeToEvents(since, until time.Time, filter filters.Args) ([]events.Message, chan interface{}) {
 	ef := daemonevents.NewFilter(filter)
 	return daemon.EventsService.SubscribeTopic(since, until, ef)
 }
 
 // UnsubscribeFromEvents stops the event subscription for a client by closing the
 // channel where the daemon sends events to.
 func (daemon *Daemon) UnsubscribeFromEvents(listener chan interface{}) {
 	daemon.EventsService.Evict(listener)
 }
 

 // copyAttributes guarantees that labels are not mutated by event triggers.

 func copyAttributes(attributes, labels map[string]string) {

 	if labels == nil {

 		return

 	}
 	for k, v := range labels {
 		attributes[k] = v
 	}

 }