"io/ioutil"
"net"
"net/http"
"net/url"
"reflect"
"strings"
"time"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/utils"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
"github.com/gorilla/websocket"
)
var log = logger.ForModule("ws client")
const (
// ServiceName defines the service name for the agent. This is used to sign messages
// that are sent to the backend.
ServiceName = "ecs"
// wsConnectTimeout specifies the default connection timeout to the backend.
wsConnectTimeout = 30 * time.Second
// readBufSize is the size of the read buffer for the ws connection.
readBufSize = 4096
// writeBufSize is the size of the write buffer for the ws connection.
writeBufSize = 32768
)
"fmt"
"sync"
"github.com/pborman/uuid"
"github.com/aws/amazon-ecs-agent/agent/api"
"github.com/aws/amazon-ecs-agent/agent/config"
ecsengine "github.com/aws/amazon-ecs-agent/agent/engine"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/stats/resolver"
"github.com/aws/amazon-ecs-agent/agent/tcs/model/ecstcs"
"github.com/aws/aws-sdk-go/aws"
"golang.org/x/net/context"
)
var log = logger.ForModule("stats")
// DockerContainerMetadataResolver implements ContainerMetadataResolver for
// DockerTaskEngine.
type DockerContainerMetadataResolver struct {
dockerTaskEngine *ecsengine.DockerTaskEngine
}
// Engine defines methods to be implemented by the engine struct. It is
// defined to make testing easier.
type Engine interface {
GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error)
}
// DockerStatsEngine is used to monitor docker container events and to report
// utlization metrics of the same.
"encoding/json"
"net/http"
"strconv"
"sync"
"time"
"github.com/aws/amazon-ecs-agent/agent/api"
"github.com/aws/amazon-ecs-agent/agent/config"
"github.com/aws/amazon-ecs-agent/agent/engine"
"github.com/aws/amazon-ecs-agent/agent/engine/dockerstate"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/utils"
"github.com/aws/amazon-ecs-agent/agent/version"
)
var log = logger.ForModule("Handlers")
const statusBadRequest = 400
const statusNotImplemented = 501
const statusOK = 200
const statusInternalServerError = 500
const dockerIdQueryField = "dockerid"
const taskArnQueryField = "taskarn"
type RootResponse struct {
AvailableCommands []string
}
func MetadataV1RequestHandlerMaker(containerInstanceArn *string, cfg *config.Config) func(http.ResponseWriter, *http.Request) {
resp := &MetadataResponse{
// Copyright 2014-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"). You may
// not use this file except in compliance with the License. A copy of the
// License is located at
//
// http://aws.amazon.com/apache2.0/
//
// or in the "license" file accompanying this file. This file is distributed
// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.
// The 'engine' package contains code for interacting with container-running backends and handling events from them.
// It supports Docker as the sole task engine type.
package engine
import (
"github.com/aws/amazon-ecs-agent/agent/config"
"github.com/aws/amazon-ecs-agent/agent/credentials"
"github.com/aws/amazon-ecs-agent/agent/logger"
)
var log = logger.ForModule("TaskEngine")
// NewTaskEngine returns a default TaskEngine
func NewTaskEngine(cfg *config.Config, client DockerClient, credentialsManager credentials.Manager) TaskEngine {
return NewDockerTaskEngine(cfg, client, credentialsManager)
}
//
// or in the "license" file accompanying this file. This file is distributed
// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.
package eventhandler
import (
"github.com/aws/amazon-ecs-agent/agent/api"
"github.com/aws/amazon-ecs-agent/agent/engine"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/statemanager"
)
var log = logger.ForModule("eventhandler")
// statesaver is a package-wise statemanager which may be used to save any
// changes to a task or container's SentStatus
var statesaver statemanager.Saver = statemanager.NewNoopStateManager()
func HandleEngineEvents(taskEngine engine.TaskEngine, client api.ECSClient, saver statemanager.Saver) {
statesaver = saver
for {
taskEvents, containerEvents := taskEngine.TaskEvents()
for taskEvents != nil && containerEvents != nil {
select {
case event, open := <-containerEvents:
if !open {
containerEvents = nil
"github.com/aws/amazon-ecs-agent/agent/acs/update_handler/os"
"github.com/aws/amazon-ecs-agent/agent/config"
"github.com/aws/amazon-ecs-agent/agent/engine"
"github.com/aws/amazon-ecs-agent/agent/httpclient"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/sighandlers"
"github.com/aws/amazon-ecs-agent/agent/sighandlers/exitcodes"
"github.com/aws/amazon-ecs-agent/agent/statemanager"
"github.com/aws/amazon-ecs-agent/agent/utils"
"github.com/aws/amazon-ecs-agent/agent/utils/ttime"
"github.com/aws/amazon-ecs-agent/agent/wsclient"
"github.com/aws/aws-sdk-go/aws"
"github.com/cihub/seelog"
)
var log = logger.ForModule("updater")
const desiredImageFile = "desired-image"
// update describes metadata around an update 2-phase request
type updater struct {
stage updateStage
stageTime time.Time
// downloadMessageID is the most recent message id seen for this update id
downloadMessageID string
// updateID is a unique identifier for this update used to determine if a
// new update request, even with a different message id, is a duplicate or
// not
updateID string
fs os.FileSystem
acs wsclient.ClientServer
"errors"
"fmt"
"io"
"io/ioutil"
"os"
"reflect"
"strconv"
"strings"
"github.com/aws/amazon-ecs-agent/agent/ec2"
"github.com/aws/amazon-ecs-agent/agent/engine/dockerclient"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/utils"
)
var log = logger.ForModule("config")
const (
// http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=docker
DOCKER_RESERVED_PORT = 2375
DOCKER_RESERVED_SSL_PORT = 2376
SSH_PORT = 22
AGENT_INTROSPECTION_PORT = 51678
DEFAULT_CLUSTER_NAME = "default"
)
// Merge merges two config files, preferring the ones on the left. Any nil or
// zero values present in the left that are not present in the right will be
"github.com/aws/amazon-ecs-agent/agent/utils"
"github.com/aws/amazon-ecs-agent/agent/utils/ttime"
"github.com/aws/aws-sdk-go/aws/credentials"
)
const (
// defaultPublishMetricsInterval is the interval at which utilization
// metrics from stats engine are published to the backend.
defaultPublishMetricsInterval = 20 * time.Second
// The maximum time to wait between heartbeats without disconnecting
heartbeatTimeout = 5 * time.Minute
heartbeatJitter = 3 * time.Minute
)
var log = logger.ForModule("tcs handler")
// StartMetricsSession starts a metric session. It initializes the stats engine
// and invokes StartSession.
func StartMetricsSession(params TelemetrySessionParams) {
disabled, err := params.isTelemetryDisabled()
if err != nil {
log.Warn("Error getting telemetry config", "err", err)
return
}
if !disabled {
statsEngine := stats.NewDockerStatsEngine(params.Cfg)
err := statsEngine.MustInit(params.TaskEngine, params.Cfg.Cluster, params.ContainerInstanceArn)
if err != nil {
log.Warn("Error initializing metrics engine", "err", err)
import (
"crypto/rand"
"encoding/binary"
"encoding/hex"
"math"
"math/big"
"reflect"
"strconv"
"strings"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/utils/ttime"
)
var log = logger.ForModule("util")
func DefaultIfBlank(str string, default_value string) string {
if len(str) == 0 {
return default_value
}
return str
}
func ZeroOrNil(obj interface{}) bool {
value := reflect.ValueOf(obj)
if !value.IsValid() {
return true
}
if obj == nil {
return true
"errors"
"runtime"
"time"
"github.com/aws/amazon-ecs-agent/agent/ecs_client/model/ecs"
"github.com/awslabs/aws-sdk-go/aws"
"github.com/docker/docker/pkg/system"
"github.com/aws/amazon-ecs-agent/agent/config"
"github.com/aws/amazon-ecs-agent/agent/ec2"
"github.com/aws/amazon-ecs-agent/agent/httpclient"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/utils"
)
var log = logger.ForModule("api client")
// ECSClient is an interface over the ECSSDK interface which abstracts away some
// details around constructing the request and reading the response down to the
// parts the agent cares about.
// For example, the ever-present 'Cluster' member is abstracted out so that it
// may be configured once and used throughout transparently.
type ECSClient interface {
// RegisterContainerInstance calculates the appropriate resources, creates
// the default cluster if necessary, and returns the registered
// ContainerInstanceARN if successful.
RegisterContainerInstance() (string, error)
// SubmitTaskStateChange sends a state change and returns an error
// indicating if it was submitted
SubmitTaskStateChange(change TaskStateChange) utils.RetriableError
// SubmitContainerStateChange sends a state change and returns an error
// a) Add 'ACSSeqNum' top level field (backwards compatible; technically
// forwards compatible but could cause resource constraint violations)
// b) remove 'DEAD', 'UNKNOWN' state from ever being marshalled (backward and
// forward compatible)
// 3) Add 'Protocol' field to 'portMappings' and 'KnownPortBindings'
// 4) Add 'DockerConfig' struct
// 5) Add 'ImageStates' struct as part of ImageManager
const EcsDataVersion = 5
// Filename in the ECS_DATADIR
const ecsDataFile = "ecs_agent_data.json"
// How frequently to flush to disk
const minSaveInterval = 10 * time.Second
var log = logger.ForModule("statemanager")
// Saveable types should be able to be json serializable and deserializable
// Properly, this should have json.Marshaler/json.Unmarshaler here, but string
// and so on can be marshaled/unmarshaled sanely but don't fit those interfaces.
type Saveable interface{}
// Saver is a type that can be saved
type Saver interface {
Save() error
ForceSave() error
}
// Option functions are functions that may be used as part of constructing a new
// StateManager
type Option func(StateManager)
import (
"errors"
"os"
"os/signal"
"syscall"
"time"
"github.com/aws/amazon-ecs-agent/agent/engine"
"github.com/aws/amazon-ecs-agent/agent/logger"
"github.com/aws/amazon-ecs-agent/agent/sighandlers/exitcodes"
"github.com/aws/amazon-ecs-agent/agent/statemanager"
"github.com/aws/amazon-ecs-agent/agent/utils"
)
var log = logger.ForModule("TerminationHandler")
func StartTerminationHandler(saver statemanager.Saver, taskEngine engine.TaskEngine) {
signalChannel := make(chan os.Signal, 2)
signal.Notify(signalChannel, os.Interrupt, syscall.SIGTERM)
sig := <-signalChannel
log.Debug("Received termination signal", "signal", sig.String())
err := FinalSave(saver, taskEngine)
if err != nil {
log.Crit("Error saving state before final shutdown", "err", err)
// Terminal because it's a sigterm; the user doesn't want it to restart
os.Exit(exitcodes.ExitTerminal)
}
os.Exit(exitcodes.ExitSuccess)
// or in the "license" file accompanying this file. This file is distributed
// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.
package dockerstate
import (
"sync"
"github.com/aws/amazon-ecs-agent/agent/api"
"github.com/aws/amazon-ecs-agent/agent/engine/image"
"github.com/aws/amazon-ecs-agent/agent/logger"
)
var log = logger.ForModule("dockerstate")
// dockerTaskEngineState keeps track of all mappings between tasks we know about
// and containers docker runs
// It contains a mutex that can be used to ensure out-of-date state cannot be
// accessed before an update comes and to ensure multiple goroutines can safely
// work with it.
//
// The methods on it will aquire the read lock, but not all aquire the write
// lock (sometimes it is up to the caller). This is because the write lock for
// containers should encapsulate the creation of the resource as well as adding,
// and creating the resource (docker container) is outside the scope of this
// package. This isn't ideal usage and I'm open to this being reworked/improved.
//
// Some information is duplicated in the interest of having efficient lookups
type DockerTaskEngineState struct {
//
// or in the "license" file accompanying this file. This file is distributed
// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.
package dependencygraph
import (
"strings"
"github.com/aws/amazon-ecs-agent/agent/api"
"github.com/aws/amazon-ecs-agent/agent/logger"
)
var log = logger.ForModule("dependencygraph")
// Because a container may depend on another container being created
// (volumes-from) or running (links) it makes sense to abstract it out
// to each container having dependencies on another container being in any
// perticular state set. For now, these are resolved here and support only
// volume/link (created/run)
// ValidDependencies takes a task and verifies that it is possible to allow all
// containers within it to reach the desired status by proceeding in some order
func ValidDependencies(task *api.Task) bool {
unresolved := make([]*api.Container, len(task.Containers))
resolved := make([]*api.Container, 0, len(task.Containers))
copy(unresolved, task.Containers)
// express or implied. See the License for the specific language governing
// permissions and limitations under the License.
// Package dockerauth handles storing auth configuration information for Docker
// registries
package dockerauth
import (
"github.com/GoogleCloudPlatform/kubernetes/pkg/credentialprovider"
"github.com/aws/amazon-ecs-agent/agent/config"
"github.com/aws/amazon-ecs-agent/agent/engine/dockerauth/ecs"
"github.com/aws/amazon-ecs-agent/agent/logger"
docker "github.com/fsouza/go-dockerclient"
)
var log = logger.ForModule("docker auth")
var keyring credentialprovider.DockerKeyring
// SetConfig loads credentials from a config
func SetConfig(conf *config.Config) {
ecs_credentials.SetConfig(conf)
keyring = credentialprovider.NewDockerKeyring()
}
// GetAuthconfig retrieves the correct auth configuration for the given image
func GetAuthconfig(image string) docker.AuthConfiguration {
if keyring == nil {
return docker.AuthConfiguration{}
}
authConfig, ok := keyring.Lookup(image)
// permissions and limitations under the License.
// Package credentialprovider provides a credential provider as defined in
// Kubernetes's 'credentialprovider' package.
// See https://github.com/GoogleCloudPlatform/kubernetes/tree/d5e0054eb0/pkg/credentialprovider
package ecs_credentials
import (
"encoding/json"
"github.com/GoogleCloudPlatform/kubernetes/pkg/credentialprovider"
"github.com/aws/amazon-ecs-agent/agent/config"
"github.com/aws/amazon-ecs-agent/agent/logger"
)
var log = logger.ForModule("ecs credentials")
type ecsCredentials struct {
*config.Config
}
// singleton instance
var ecsCredentialsInstance = &ecsCredentials{}
func init() {
credentialprovider.RegisterCredentialProvider("ecs-config", ecsCredentialsInstance)
}
func SetConfig(cfg *config.Config) {
ecsCredentialsInstance.Config = cfg
}