feat: add lambda transformation functions target (#16507)

internal/config/lambda/event/arn.go

@@ -0,0 +1,62 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"strings"
+)
+
+// ARN - SQS resource name representation.
+type ARN struct {
+	TargetID
+	region string
+}
+
+// String - returns string representation.
+func (arn ARN) String() string {
+	if arn.TargetID.ID == "" && arn.TargetID.Name == "" && arn.region == "" {
+		return ""
+	}
+
+	return "arn:minio:s3-object-lambda:" + arn.region + ":" + arn.TargetID.String()
+}
+
+// ParseARN - parses string to ARN.
+func ParseARN(s string) (*ARN, error) {
+	// ARN must be in the format of arn:minio:s3-object-lambda:<REGION>:<ID>:<TYPE>
+	if !strings.HasPrefix(s, "arn:minio:s3-object-lambda:") {
+		return nil, &ErrInvalidARN{s}
+	}
+
+	tokens := strings.Split(s, ":")
+	if len(tokens) != 6 {
+		return nil, &ErrInvalidARN{s}
+	}
+
+	if tokens[4] == "" || tokens[5] == "" {
+		return nil, &ErrInvalidARN{s}
+	}
+
+	return &ARN{
+		region: tokens[3],
+		TargetID: TargetID{
+			ID:   tokens[4],
+			Name: tokens[5],
+		},
+	}, nil
+}

internal/config/lambda/event/arn_test.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"testing"
+)
+
+func TestARNString(t *testing.T) {
+	testCases := []struct {
+		arn            ARN
+		expectedResult string
+	}{
+		{ARN{}, ""},
+		{ARN{TargetID{"1", "webhook"}, ""}, "arn:minio:s3-object-lambda::1:webhook"},
+		{ARN{TargetID{"1", "webhook"}, "us-east-1"}, "arn:minio:s3-object-lambda:us-east-1:1:webhook"},
+	}
+
+	for i, testCase := range testCases {
+		result := testCase.arn.String()
+
+		if result != testCase.expectedResult {
+			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
+		}
+	}
+}
+
+func TestParseARN(t *testing.T) {
+	testCases := []struct {
+		s           string
+		expectedARN *ARN
+		expectErr   bool
+	}{
+		{"", nil, true},
+		{"arn:minio:s3-object-lambda:::", nil, true},
+		{"arn:minio:s3-object-lambda::1:webhook:remote", nil, true},
+		{"arn:aws:s3-object-lambda::1:webhook", nil, true},
+		{"arn:minio:sns::1:webhook", nil, true},
+		{"arn:minio:s3-object-lambda::1:webhook", &ARN{TargetID{"1", "webhook"}, ""}, false},
+		{"arn:minio:s3-object-lambda:us-east-1:1:webhook", &ARN{TargetID{"1", "webhook"}, "us-east-1"}, false},
+	}
+
+	for i, testCase := range testCases {
+		arn, err := ParseARN(testCase.s)
+		expectErr := (err != nil)
+
+		if expectErr != testCase.expectErr {
+			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
+		}
+
+		if !testCase.expectErr {
+			if *arn != *testCase.expectedARN {
+				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, testCase.expectedARN, arn)
+			}
+		}
+	}
+}

internal/config/lambda/event/errors.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"fmt"
+)
+
+// ErrUnknownRegion - unknown region error.
+type ErrUnknownRegion struct {
+	Region string
+}
+
+func (err ErrUnknownRegion) Error() string {
+	return fmt.Sprintf("unknown region '%v'", err.Region)
+}
+
+// ErrARNNotFound - ARN not found error.
+type ErrARNNotFound struct {
+	ARN ARN
+}
+
+func (err ErrARNNotFound) Error() string {
+	return fmt.Sprintf("ARN '%v' not found", err.ARN)
+}
+
+// ErrInvalidARN - invalid ARN error.
+type ErrInvalidARN struct {
+	ARN string
+}
+
+func (err ErrInvalidARN) Error() string {
+	return fmt.Sprintf("invalid ARN '%v'", err.ARN)
+}

internal/config/lambda/event/event.go

@@ -0,0 +1,80 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import "net/http"
+
+// Identity represents access key who caused the event.
+type Identity struct {
+	Type        string `json:"type"`
+	PrincipalID string `json:"principalId"`
+	AccessKeyID string `json:"accessKeyId"`
+}
+
+// UserRequest user request headers
+type UserRequest struct {
+	URL     string      `json:"url"`
+	Headers http.Header `json:"headers"`
+}
+
+// GetObjectContext provides the necessary details to perform
+// download of the object, and return back the processed response
+// to the server.
+type GetObjectContext struct {
+	OutputRoute string `json:"outputRoute"`
+	OutputToken string `json:"outputToken"`
+	InputS3URL  string `json:"inputS3Url"`
+}
+
+// Event represents lambda function event, this is undocumented in AWS S3. This
+// structure bases itself on this structure but there is no binding.
+//
+//	{
+//	  "xAmzRequestId": "a2871150-1df5-4dc9-ad9f-3da283ca1bf3",
+//	  "getObjectContext": {
+//	    "outputRoute": "...",
+//	    "outputToken": "...",
+//	    "inputS3Url": "<presignedURL>"
+//	  },
+//	  "configuration": { // not useful in MinIO
+//	    "accessPointArn": "...",
+//	    "supportingAccessPointArn": "...",
+//	    "payload": ""
+//	  },
+//	  "userRequest": {
+//	    "url": "...",
+//	    "headers": {
+//	      "Host": "...",
+//	      "X-Amz-Content-SHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+//	    }
+//	  },
+//	  "userIdentity": {
+//	    "type": "IAMUser",
+//	    "principalId": "AIDAJF5MO57RFXQCE5ZNC",
+//	    "arn": "...",
+//	    "accountId": "...",
+//	    "accessKeyId": "AKIA3WNQJCXE2DYPAU7R"
+//	  },
+//	  "protocolVersion": "1.00"
+//	}
+type Event struct {
+	ProtocolVersion  string            `json:"protocolVersion"`
+	GetObjectContext *GetObjectContext `json:"getObjectContext"`
+	UserIdentity     Identity          `json:"userIdentity"`
+	UserRequest      UserRequest       `json:"userRequest"`
+}

internal/config/lambda/event/targetid.go

@@ -0,0 +1,74 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// TargetID - holds identification and name strings of notification target.
+type TargetID struct {
+	ID   string
+	Name string
+}
+
+// String - returns string representation.
+func (tid TargetID) String() string {
+	return tid.ID + ":" + tid.Name
+}
+
+// ToARN - converts to ARN.
+func (tid TargetID) ToARN(region string) ARN {
+	return ARN{TargetID: tid, region: region}
+}
+
+// MarshalJSON - encodes to JSON data.
+func (tid TargetID) MarshalJSON() ([]byte, error) {
+	return json.Marshal(tid.String())
+}
+
+// UnmarshalJSON - decodes JSON data.
+func (tid *TargetID) UnmarshalJSON(data []byte) error {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+
+	targetID, err := parseTargetID(s)
+	if err != nil {
+		return err
+	}
+
+	*tid = *targetID
+	return nil
+}
+
+// parseTargetID - parses string to TargetID.
+func parseTargetID(s string) (*TargetID, error) {
+	tokens := strings.Split(s, ":")
+	if len(tokens) != 2 {
+		return nil, fmt.Errorf("invalid TargetID format '%v'", s)
+	}
+
+	return &TargetID{
+		ID:   tokens[0],
+		Name: tokens[1],
+	}, nil
+}

internal/config/lambda/event/targetid_test.go

@@ -0,0 +1,118 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestTargetDString(t *testing.T) {
+	testCases := []struct {
+		tid            TargetID
+		expectedResult string
+	}{
+		{TargetID{}, ":"},
+		{TargetID{"1", "webhook"}, "1:webhook"},
+		{TargetID{"httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531", "localhost:55638"}, "httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531:localhost:55638"},
+	}
+
+	for i, testCase := range testCases {
+		result := testCase.tid.String()
+
+		if result != testCase.expectedResult {
+			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
+		}
+	}
+}
+
+func TestTargetDToARN(t *testing.T) {
+	tid := TargetID{"1", "webhook"}
+	testCases := []struct {
+		tid         TargetID
+		region      string
+		expectedARN ARN
+	}{
+		{tid, "", ARN{TargetID: tid, region: ""}},
+		{tid, "us-east-1", ARN{TargetID: tid, region: "us-east-1"}},
+	}
+
+	for i, testCase := range testCases {
+		arn := testCase.tid.ToARN(testCase.region)
+
+		if arn != testCase.expectedARN {
+			t.Fatalf("test %v: ARN: expected: %v, got: %v", i+1, testCase.expectedARN, arn)
+		}
+	}
+}
+
+func TestTargetDMarshalJSON(t *testing.T) {
+	testCases := []struct {
+		tid          TargetID
+		expectedData []byte
+		expectErr    bool
+	}{
+		{TargetID{}, []byte(`":"`), false},
+		{TargetID{"1", "webhook"}, []byte(`"1:webhook"`), false},
+		{TargetID{"httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531", "localhost:55638"}, []byte(`"httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531:localhost:55638"`), false},
+	}
+
+	for i, testCase := range testCases {
+		data, err := testCase.tid.MarshalJSON()
+		expectErr := (err != nil)
+
+		if expectErr != testCase.expectErr {
+			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
+		}
+
+		if !testCase.expectErr {
+			if !reflect.DeepEqual(data, testCase.expectedData) {
+				t.Fatalf("test %v: data: expected: %v, got: %v", i+1, string(testCase.expectedData), string(data))
+			}
+		}
+	}
+}
+
+func TestTargetDUnmarshalJSON(t *testing.T) {
+	testCases := []struct {
+		data             []byte
+		expectedTargetID *TargetID
+		expectErr        bool
+	}{
+		{[]byte(`""`), nil, true},
+		{[]byte(`"httpclient+2e33cdee-fbec-4bdd-917e-7d8e3c5a2531:localhost:55638"`), nil, true},
+		{[]byte(`":"`), &TargetID{}, false},
+		{[]byte(`"1:webhook"`), &TargetID{"1", "webhook"}, false},
+	}
+
+	for i, testCase := range testCases {
+		targetID := &TargetID{}
+		err := targetID.UnmarshalJSON(testCase.data)
+		expectErr := (err != nil)
+
+		if expectErr != testCase.expectErr {
+			t.Fatalf("test %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
+		}
+
+		if !testCase.expectErr {
+			if *targetID != *testCase.expectedTargetID {
+				t.Fatalf("test %v: TargetID: expected: %v, got: %v", i+1, testCase.expectedTargetID, targetID)
+			}
+		}
+	}
+}

internal/config/lambda/event/targetidset.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+// TargetIDSet - Set representation of TargetIDs.
+type TargetIDSet map[TargetID]struct{}
+
+// IsEmpty returns true if the set is empty.
+func (set TargetIDSet) IsEmpty() bool {
+	return len(set) != 0
+}
+
+// Clone - returns copy of this set.
+func (set TargetIDSet) Clone() TargetIDSet {
+	setCopy := NewTargetIDSet()
+	for k, v := range set {
+		setCopy[k] = v
+	}
+	return setCopy
+}
+
+// add - adds TargetID to the set.
+func (set TargetIDSet) add(targetID TargetID) {
+	set[targetID] = struct{}{}
+}
+
+// Union - returns union with given set as new set.
+func (set TargetIDSet) Union(sset TargetIDSet) TargetIDSet {
+	nset := set.Clone()
+
+	for k := range sset {
+		nset.add(k)
+	}
+
+	return nset
+}
+
+// Difference - returns diffrence with given set as new set.
+func (set TargetIDSet) Difference(sset TargetIDSet) TargetIDSet {
+	nset := NewTargetIDSet()
+	for k := range set {
+		if _, ok := sset[k]; !ok {
+			nset.add(k)
+		}
+	}
+
+	return nset
+}
+
+// NewTargetIDSet - creates new TargetID set with given TargetIDs.
+func NewTargetIDSet(targetIDs ...TargetID) TargetIDSet {
+	set := make(TargetIDSet)
+	for _, targetID := range targetIDs {
+		set.add(targetID)
+	}
+	return set
+}

internal/config/lambda/event/targetidset_test.go

@@ -0,0 +1,110 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestTargetIDSetClone(t *testing.T) {
+	testCases := []struct {
+		set           TargetIDSet
+		targetIDToAdd TargetID
+	}{
+		{NewTargetIDSet(), TargetID{"1", "webhook"}},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), TargetID{"2", "webhook"}},
+		{NewTargetIDSet(TargetID{"1", "webhook"}, TargetID{"2", "amqp"}), TargetID{"2", "webhook"}},
+	}
+
+	for i, testCase := range testCases {
+		result := testCase.set.Clone()
+
+		if !reflect.DeepEqual(result, testCase.set) {
+			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.set, result)
+		}
+
+		result.add(testCase.targetIDToAdd)
+		if reflect.DeepEqual(result, testCase.set) {
+			t.Fatalf("test %v: result: expected: not equal, got: equal", i+1)
+		}
+	}
+}
+
+func TestTargetIDSetUnion(t *testing.T) {
+	testCases := []struct {
+		set            TargetIDSet
+		setToAdd       TargetIDSet
+		expectedResult TargetIDSet
+	}{
+		{NewTargetIDSet(), NewTargetIDSet(), NewTargetIDSet()},
+		{NewTargetIDSet(), NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(TargetID{"1", "webhook"})},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(), NewTargetIDSet(TargetID{"1", "webhook"})},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(TargetID{"2", "amqp"}), NewTargetIDSet(TargetID{"1", "webhook"}, TargetID{"2", "amqp"})},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(TargetID{"1", "webhook"})},
+	}
+
+	for i, testCase := range testCases {
+		result := testCase.set.Union(testCase.setToAdd)
+
+		if !reflect.DeepEqual(testCase.expectedResult, result) {
+			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
+		}
+	}
+}
+
+func TestTargetIDSetDifference(t *testing.T) {
+	testCases := []struct {
+		set            TargetIDSet
+		setToRemove    TargetIDSet
+		expectedResult TargetIDSet
+	}{
+		{NewTargetIDSet(), NewTargetIDSet(), NewTargetIDSet()},
+		{NewTargetIDSet(), NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet()},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(), NewTargetIDSet(TargetID{"1", "webhook"})},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(TargetID{"2", "amqp"}), NewTargetIDSet(TargetID{"1", "webhook"})},
+		{NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet(TargetID{"1", "webhook"}), NewTargetIDSet()},
+	}
+
+	for i, testCase := range testCases {
+		result := testCase.set.Difference(testCase.setToRemove)
+
+		if !reflect.DeepEqual(testCase.expectedResult, result) {
+			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
+		}
+	}
+}
+
+func TestNewTargetIDSet(t *testing.T) {
+	testCases := []struct {
+		targetIDs      []TargetID
+		expectedResult TargetIDSet
+	}{
+		{[]TargetID{}, NewTargetIDSet()},
+		{[]TargetID{{"1", "webhook"}}, NewTargetIDSet(TargetID{"1", "webhook"})},
+		{[]TargetID{{"1", "webhook"}, {"2", "amqp"}}, NewTargetIDSet(TargetID{"1", "webhook"}, TargetID{"2", "amqp"})},
+	}
+
+	for i, testCase := range testCases {
+		result := NewTargetIDSet(testCase.targetIDs...)
+
+		if !reflect.DeepEqual(testCase.expectedResult, result) {
+			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
+		}
+	}
+}

internal/config/lambda/event/targetlist.go

@@ -0,0 +1,189 @@
+// Copyright (c) 2015-2023 MinIO, Inc.
+//
+// This file is part of MinIO Object Storage stack
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package event
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+)
+
+// Target - lambda target interface
+type Target interface {
+	ID() TargetID
+	IsActive() (bool, error)
+	Send(Event) (*http.Response, error)
+	Stat() TargetStat
+	Close() error
+}
+
+// TargetStats is a collection of stats for multiple targets.
+type TargetStats struct {
+	TargetStats map[string]TargetStat
+}
+
+// TargetStat is the stats of a single target.
+type TargetStat struct {
+	ID             TargetID
+	ActiveRequests int64
+	TotalRequests  int64
+	FailedRequests int64
+}
+
+// TargetList - holds list of targets indexed by target ID.
+type TargetList struct {
+	sync.RWMutex
+	targets map[TargetID]Target
+}
+
+// Add - adds unique target to target list.
+func (list *TargetList) Add(targets ...Target) error {
+	list.Lock()
+	defer list.Unlock()
+
+	for _, target := range targets {
+		if _, ok := list.targets[target.ID()]; ok {
+			return fmt.Errorf("target %v already exists", target.ID())
+		}
+		list.targets[target.ID()] = target
+	}
+
+	return nil
+}
+
+// Lookup - checks whether target by target ID exists is valid or not.
+func (list *TargetList) Lookup(arnStr string) (Target, error) {
+	list.RLock()
+	defer list.RUnlock()
+
+	arn, err := ParseARN(arnStr)
+	if err != nil {
+		return nil, err
+	}
+
+	id, found := list.targets[arn.TargetID]
+	if !found {
+		return nil, &ErrARNNotFound{}
+	}
+	return id, nil
+}
+
+// TargetIDResult returns result of Remove/Send operation, sets err if
+// any for the associated TargetID
+type TargetIDResult struct {
+	// ID where the remove or send were initiated.
+	ID TargetID
+	// Stores any error while removing a target or while sending an event.
+	Err error
+}
+
+// Remove - closes and removes targets by given target IDs.
+func (list *TargetList) Remove(targetIDSet TargetIDSet) {
+	list.Lock()
+	defer list.Unlock()
+
+	for id := range targetIDSet {
+		target, ok := list.targets[id]
+		if ok {
+			target.Close()
+			delete(list.targets, id)
+		}
+	}
+}
+
+// Targets - list all targets
+func (list *TargetList) Targets() []Target {
+	if list == nil {
+		return []Target{}
+	}
+
+	list.RLock()
+	defer list.RUnlock()
+
+	targets := make([]Target, 0, len(list.targets))
+	for _, tgt := range list.targets {
+		targets = append(targets, tgt)
+	}
+
+	return targets
+}
+
+// Empty returns true if targetList is empty.
+func (list *TargetList) Empty() bool {
+	list.RLock()
+	defer list.RUnlock()
+
+	return len(list.targets) == 0
+}
+
+// List - returns available target IDs.
+func (list *TargetList) List(region string) []ARN {
+	list.RLock()
+	defer list.RUnlock()
+
+	keys := make([]ARN, 0, len(list.targets))
+	for k := range list.targets {
+		keys = append(keys, k.ToARN(region))
+	}
+
+	return keys
+}
+
+// TargetMap - returns available targets.
+func (list *TargetList) TargetMap() map[TargetID]Target {
+	list.RLock()
+	defer list.RUnlock()
+
+	ntargets := make(map[TargetID]Target, len(list.targets))
+	for k, v := range list.targets {
+		ntargets[k] = v
+	}
+	return ntargets
+}
+
+// Send - sends events to targets identified by target IDs.
+func (list *TargetList) Send(event Event, id TargetID) (*http.Response, error) {
+	list.RLock()
+	target, ok := list.targets[id]
+	list.RUnlock()
+	if ok {
+		return target.Send(event)
+	}
+	return nil, ErrARNNotFound{}
+}
+
+// Stats returns stats for targets.
+func (list *TargetList) Stats() TargetStats {
+	t := TargetStats{}
+	if list == nil {
+		return t
+	}
+	list.RLock()
+	defer list.RUnlock()
+	t.TargetStats = make(map[string]TargetStat, len(list.targets))
+	for id, target := range list.targets {
+		t.TargetStats[strings.ReplaceAll(id.String(), ":", "_")] = target.Stat()
+	}
+	return t
+}
+
+// NewTargetList - creates TargetList.
+func NewTargetList() *TargetList {
+	return &TargetList{targets: make(map[TargetID]Target)}
+}