mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 14:20:23 -04:00
309 lines
11 KiB
Go
309 lines
11 KiB
Go
package daemon // import "github.com/docker/docker/daemon"
|
|
|
|
import (
|
|
"context"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/docker/docker/api/types/events"
|
|
"github.com/docker/docker/api/types/filters"
|
|
"github.com/docker/docker/container"
|
|
daemonevents "github.com/docker/docker/daemon/events"
|
|
"github.com/docker/libnetwork"
|
|
swarmapi "github.com/docker/swarmkit/api"
|
|
gogotypes "github.com/gogo/protobuf/types"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
var (
|
|
clusterEventAction = map[swarmapi.WatchActionKind]string{
|
|
swarmapi.WatchActionKindCreate: "create",
|
|
swarmapi.WatchActionKindUpdate: "update",
|
|
swarmapi.WatchActionKindRemove: "remove",
|
|
}
|
|
)
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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
|
|
}
|
|
}
|
|
|
|
// ProcessClusterNotifications gets changes from store and add them to event list
|
|
func (daemon *Daemon) ProcessClusterNotifications(ctx context.Context, watchStream chan *swarmapi.WatchMessage) {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case message, ok := <-watchStream:
|
|
if !ok {
|
|
logrus.Debug("cluster event channel has stopped")
|
|
return
|
|
}
|
|
daemon.generateClusterEvent(message)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (daemon *Daemon) generateClusterEvent(msg *swarmapi.WatchMessage) {
|
|
for _, event := range msg.Events {
|
|
if event.Object == nil {
|
|
logrus.Errorf("event without object: %v", event)
|
|
continue
|
|
}
|
|
switch v := event.Object.GetObject().(type) {
|
|
case *swarmapi.Object_Node:
|
|
daemon.logNodeEvent(event.Action, v.Node, event.OldObject.GetNode())
|
|
case *swarmapi.Object_Service:
|
|
daemon.logServiceEvent(event.Action, v.Service, event.OldObject.GetService())
|
|
case *swarmapi.Object_Network:
|
|
daemon.logNetworkEvent(event.Action, v.Network, event.OldObject.GetNetwork())
|
|
case *swarmapi.Object_Secret:
|
|
daemon.logSecretEvent(event.Action, v.Secret, event.OldObject.GetSecret())
|
|
case *swarmapi.Object_Config:
|
|
daemon.logConfigEvent(event.Action, v.Config, event.OldObject.GetConfig())
|
|
default:
|
|
logrus.Warnf("unrecognized event: %v", event)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (daemon *Daemon) logNetworkEvent(action swarmapi.WatchActionKind, net *swarmapi.Network, oldNet *swarmapi.Network) {
|
|
attributes := map[string]string{
|
|
"name": net.Spec.Annotations.Name,
|
|
}
|
|
eventTime := eventTimestamp(net.Meta, action)
|
|
daemon.logClusterEvent(action, net.ID, "network", attributes, eventTime)
|
|
}
|
|
|
|
func (daemon *Daemon) logSecretEvent(action swarmapi.WatchActionKind, secret *swarmapi.Secret, oldSecret *swarmapi.Secret) {
|
|
attributes := map[string]string{
|
|
"name": secret.Spec.Annotations.Name,
|
|
}
|
|
eventTime := eventTimestamp(secret.Meta, action)
|
|
daemon.logClusterEvent(action, secret.ID, "secret", attributes, eventTime)
|
|
}
|
|
|
|
func (daemon *Daemon) logConfigEvent(action swarmapi.WatchActionKind, config *swarmapi.Config, oldConfig *swarmapi.Config) {
|
|
attributes := map[string]string{
|
|
"name": config.Spec.Annotations.Name,
|
|
}
|
|
eventTime := eventTimestamp(config.Meta, action)
|
|
daemon.logClusterEvent(action, config.ID, "config", attributes, eventTime)
|
|
}
|
|
|
|
func (daemon *Daemon) logNodeEvent(action swarmapi.WatchActionKind, node *swarmapi.Node, oldNode *swarmapi.Node) {
|
|
name := node.Spec.Annotations.Name
|
|
if name == "" && node.Description != nil {
|
|
name = node.Description.Hostname
|
|
}
|
|
attributes := map[string]string{
|
|
"name": name,
|
|
}
|
|
eventTime := eventTimestamp(node.Meta, action)
|
|
// In an update event, display the changes in attributes
|
|
if action == swarmapi.WatchActionKindUpdate && oldNode != nil {
|
|
if node.Spec.Availability != oldNode.Spec.Availability {
|
|
attributes["availability.old"] = strings.ToLower(oldNode.Spec.Availability.String())
|
|
attributes["availability.new"] = strings.ToLower(node.Spec.Availability.String())
|
|
}
|
|
if node.Role != oldNode.Role {
|
|
attributes["role.old"] = strings.ToLower(oldNode.Role.String())
|
|
attributes["role.new"] = strings.ToLower(node.Role.String())
|
|
}
|
|
if node.Status.State != oldNode.Status.State {
|
|
attributes["state.old"] = strings.ToLower(oldNode.Status.State.String())
|
|
attributes["state.new"] = strings.ToLower(node.Status.State.String())
|
|
}
|
|
// This handles change within manager role
|
|
if node.ManagerStatus != nil && oldNode.ManagerStatus != nil {
|
|
// leader change
|
|
if node.ManagerStatus.Leader != oldNode.ManagerStatus.Leader {
|
|
if node.ManagerStatus.Leader {
|
|
attributes["leader.old"] = "false"
|
|
attributes["leader.new"] = "true"
|
|
} else {
|
|
attributes["leader.old"] = "true"
|
|
attributes["leader.new"] = "false"
|
|
}
|
|
}
|
|
if node.ManagerStatus.Reachability != oldNode.ManagerStatus.Reachability {
|
|
attributes["reachability.old"] = strings.ToLower(oldNode.ManagerStatus.Reachability.String())
|
|
attributes["reachability.new"] = strings.ToLower(node.ManagerStatus.Reachability.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
daemon.logClusterEvent(action, node.ID, "node", attributes, eventTime)
|
|
}
|
|
|
|
func (daemon *Daemon) logServiceEvent(action swarmapi.WatchActionKind, service *swarmapi.Service, oldService *swarmapi.Service) {
|
|
attributes := map[string]string{
|
|
"name": service.Spec.Annotations.Name,
|
|
}
|
|
eventTime := eventTimestamp(service.Meta, action)
|
|
|
|
if action == swarmapi.WatchActionKindUpdate && oldService != nil {
|
|
// check image
|
|
if x, ok := service.Spec.Task.GetRuntime().(*swarmapi.TaskSpec_Container); ok {
|
|
containerSpec := x.Container
|
|
if y, ok := oldService.Spec.Task.GetRuntime().(*swarmapi.TaskSpec_Container); ok {
|
|
oldContainerSpec := y.Container
|
|
if containerSpec.Image != oldContainerSpec.Image {
|
|
attributes["image.old"] = oldContainerSpec.Image
|
|
attributes["image.new"] = containerSpec.Image
|
|
}
|
|
} else {
|
|
// This should not happen.
|
|
logrus.Errorf("service %s runtime changed from %T to %T", service.Spec.Annotations.Name, oldService.Spec.Task.GetRuntime(), service.Spec.Task.GetRuntime())
|
|
}
|
|
}
|
|
// check replicated count change
|
|
if x, ok := service.Spec.GetMode().(*swarmapi.ServiceSpec_Replicated); ok {
|
|
replicas := x.Replicated.Replicas
|
|
if y, ok := oldService.Spec.GetMode().(*swarmapi.ServiceSpec_Replicated); ok {
|
|
oldReplicas := y.Replicated.Replicas
|
|
if replicas != oldReplicas {
|
|
attributes["replicas.old"] = strconv.FormatUint(oldReplicas, 10)
|
|
attributes["replicas.new"] = strconv.FormatUint(replicas, 10)
|
|
}
|
|
} else {
|
|
// This should not happen.
|
|
logrus.Errorf("service %s mode changed from %T to %T", service.Spec.Annotations.Name, oldService.Spec.GetMode(), service.Spec.GetMode())
|
|
}
|
|
}
|
|
if service.UpdateStatus != nil {
|
|
if oldService.UpdateStatus == nil {
|
|
attributes["updatestate.new"] = strings.ToLower(service.UpdateStatus.State.String())
|
|
} else if service.UpdateStatus.State != oldService.UpdateStatus.State {
|
|
attributes["updatestate.old"] = strings.ToLower(oldService.UpdateStatus.State.String())
|
|
attributes["updatestate.new"] = strings.ToLower(service.UpdateStatus.State.String())
|
|
}
|
|
}
|
|
}
|
|
daemon.logClusterEvent(action, service.ID, "service", attributes, eventTime)
|
|
}
|
|
|
|
func (daemon *Daemon) logClusterEvent(action swarmapi.WatchActionKind, id, eventType string, attributes map[string]string, eventTime time.Time) {
|
|
actor := events.Actor{
|
|
ID: id,
|
|
Attributes: attributes,
|
|
}
|
|
|
|
jm := events.Message{
|
|
Action: clusterEventAction[action],
|
|
Type: eventType,
|
|
Actor: actor,
|
|
Scope: "swarm",
|
|
Time: eventTime.UTC().Unix(),
|
|
TimeNano: eventTime.UTC().UnixNano(),
|
|
}
|
|
daemon.EventsService.PublishMessage(jm)
|
|
}
|
|
|
|
func eventTimestamp(meta swarmapi.Meta, action swarmapi.WatchActionKind) time.Time {
|
|
var eventTime time.Time
|
|
switch action {
|
|
case swarmapi.WatchActionKindCreate:
|
|
eventTime, _ = gogotypes.TimestampFromProto(meta.CreatedAt)
|
|
case swarmapi.WatchActionKindUpdate:
|
|
eventTime, _ = gogotypes.TimestampFromProto(meta.UpdatedAt)
|
|
case swarmapi.WatchActionKindRemove:
|
|
// There is no timestamp from store message for remove operations.
|
|
// Use current time.
|
|
eventTime = time.Now()
|
|
}
|
|
return eventTime
|
|
}
|