NamespaceFormat = "namespace"

	// AccessFormat - access log format used in some event targets.
	AccessFormat = "access"

	// AMZTimeFormat - event time format.
	AMZTimeFormat = "2006-01-02T15:04:05.000Z"

	// StoreExtension - file extension of an event file in store
	StoreExtension = ".event"
)

// Identity represents access key who caused the event.
type Identity struct {

	if escape {
		keyName = url.QueryEscape(args.Object.Name)
	}

	newEvent := event.Event{
		EventVersion:      "2.0",
		EventSource:       "minio:s3",
		AwsRegion:         args.ReqParams["region"],
		EventTime:         eventTime.Format(event.AMZTimeFormat),
		EventName:         args.EventName,
		UserIdentity:      event.Identity{PrincipalID: args.ReqParams["principalId"]},
		RequestParameters: args.ReqParams,

}

// send - sends an event to the NSQ.
func (target *NSQTarget) send(eventData event.Event) error {
	objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
	if err != nil {
		return err
	}
	key := eventData.S3.Bucket.Name + "/" + objectName

	data, err := json.Marshal(event.Log{EventName: eventData.EventName, Key: key, Records: []event.Event{eventData}})
	if err != nil {
		return err
	}

	}
	return true, nil
}

// send - sends an event to the mqtt.
func (target *MQTTTarget) send(eventData event.Event) error {
	objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
	if err != nil {
		return err
	}
	key := eventData.S3.Bucket.Name + "/" + objectName

	data, err := json.Marshal(event.Log{EventName: eventData.EventName, Key: key, Records: []event.Event{eventData}})
	if err != nil {
		return err
	}

		ntargets[k] = v
	}
	return ntargets
}

// Send - sends events to targets identified by target IDs.
func (list *TargetList) Send(event Event, targetIDset TargetIDSet, sync bool) {
	if sync {
		list.sendSync(event, targetIDset)
	} else {
		list.sendAsync(event, targetIDset)
	}
}

func (list *TargetList) sendSync(event Event, targetIDset TargetIDSet) {
	var wg sync.WaitGroup
	for id := range targetIDset {

		tags[ilmSrc] = src.String()
	}
	tags[ilmAction] = event.Action.String()
	tags[ilmRuleID] = event.RuleID

	if !event.Due.IsZero() {
		tags[ilmDue] = event.Due
	}

	// rule with Transition/NoncurrentVersionTransition in effect
	if event.StorageClass != "" {
		tags[ilmTier] = event.StorageClass
	}

	// rule with NewernoncurrentVersions in effect
	if event.NewerNoncurrentVersions > 0 {

	}
	return err
}

// send - sends an event to the webhook.
func (target *WebhookTarget) send(eventData event.Event) error {
	objectName, err := url.QueryUnescape(eventData.S3.Object.Key)
	if err != nil {
		return err
	}
	key := eventData.S3.Bucket.Name + "/" + objectName

	data, err := json.Marshal(event.Log{EventName: eventData.EventName, Key: key, Records: []event.Event{eventData}})
	if err != nil {
		return err
	}

			},
		},
		Timeout: 1000 * time.Millisecond,
	}
	eventC := CNIEventClient{
		client: c,
		url:    "http://unix" + path,
	}
	return eventC
}

func PushCNIEvent(cniClient CNIEventClient, event *skel.CmdArgs, prevResIps []*cniv1.IPConfig, podName, podNamespace string) error {
	if event == nil {
		return fmt.Errorf("unable to push CNI event, CmdArgs event was nil")
	}

	var ncconfigs []nodeagent.IPConfig

	return msg, nil
}

func (s *CniPluginServer) ReconcileCNIAddEvent(ctx context.Context, addCmd CNIPluginAddEvent) error {
	log := log.WithLabels("cni-event", addCmd)

	log.Debugf("netns: %s", addCmd.Netns)

	// The CNI node plugin should have already checked the pod against the k8s API before forwarding us the event,

		buf := bytes.NewBuffer(grid.GetByteBuffer()[:0])
		enc := json.NewEncoder(buf)
		tmpEvt := struct{ Records []event.Event }{[]event.Event{{}}}
		for {
			select {
			case ev := <-localCh:
				buf.Reset()
				tmpEvt.Records[0] = ev
				if err := enc.Encode(tmpEvt); err != nil {
					bugLogIf(ctx, err, "event: Encode failed")
					continue
				}
				mergeCh <- append(grid.GetByteBuffer()[:0], buf.Bytes()...)