id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168600 | above is set
// Setting UNKNOWN version allows the version committed in git to never
// have a commit hash so that it does not churn with every commit. This
// env var should not be set when building, and go generate should be
// run before any build, such that the commithash will be set correctly.
info.Hash... | |
c168601 | := err.FromError.(NoSuchContainerError); ok {
return false
}
return true
} | |
c168602 | mock.recorder = &MockFileMockRecorder{mock}
return mock
} | |
c168603 |
ret0, _ := ret[0].(error)
return ret0
} | |
c168604 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFile)(nil).Chmod), arg0)
} | |
c168605 | _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168606 | mock.recorder = &MockOSMockRecorder{mock}
return mock
} | |
c168607 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOS)(nil).Create), arg0)
} | |
c168608 | ret0, _ := ret[0].(bool)
return ret0
} | |
c168609 | ret0, _ := ret[0].(oswrapper.File)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168610 |
ret0, _ := ret[0].(error)
return ret0
} | |
c168611 | ctrl}
mock.recorder = &MockSSMClientCreatorMockRecorder{mock}
return mock
} | |
c168612 | := m.ctrl.Call(m, "NewSSMClient", arg0, arg1)
ret0, _ := ret[0].(ssm.SSMClient)
return ret0
} | |
c168613 | reflect.TypeOf((*MockSSMClientCreator)(nil).NewSSMClient), arg0, arg1)
} | |
c168614 | ctrl}
mock.recorder = &MockEC2MetadataClientMockRecorder{mock}
return mock
} | |
c168615 | := m.ctrl.Call(m, "DefaultCredentials")
ret0, _ := ret[0].(*ec2.RoleCredentials)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168616 | "DefaultCredentials", reflect.TypeOf((*MockEC2MetadataClient)(nil).DefaultCredentials))
} | |
c168617 | := m.ctrl.Call(m, "GetDynamicData", arg0)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168618 | := ret[0].(ec2metadata.EC2InstanceIdentityDocument)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168619 | mock.recorder = &MockHttpClientMockRecorder{mock}
return mock
} | |
c168620 | := m.ctrl.Call(m, "GetInstanceIdentityDocument")
ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168621 | := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168622 | "GetUserData", reflect.TypeOf((*MockHttpClient)(nil).GetUserData))
} | |
c168623 | mock.recorder = &MockClientMockRecorder{mock}
return mock
} | |
c168624 | m.ctrl.Call(m, "DescribeECSTagsForInstance", arg0)
ret0, _ := ret[0].([]*ecs.Tag)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168625 | mock.recorder = &MockClientSDKMockRecorder{mock}
return mock
} | |
c168626 | _ := ret[0].(*ec20.CreateTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168627 | _ := ret[0].(*ec20.DescribeTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168628 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockClientSDK)(nil).DescribeTags), arg0)
} | |
c168629 | Version: ECSDataVersion,
}
manager := &basicStateManager{
statePath: cfg.DataDir,
state: state,
}
for _, option := range options {
option(manager)
}
manager.platformDependencies = newPlatformDependencies()
return manager, nil
} | |
c168630 | one.
next := manager.lastSave.Add(minSaveInterval)
manager.nextPlannedSave = next
go func() {
time.Sleep(next.Sub(time.Now()))
manager.Save()
}()
}
// else nextPlannedSave wasn't Zero so there's a save planned elsewhere that'll
// fulfill this
return nil
} | |
c168631 | AddSaveable; if we unmarshal
// directly into a map with values of pointers, those pointers are lost.
// We *must* unmarshal this way because the existing pointers could have
// semi-initialized data (and are actually expected to)
var intermediate intermediateState
err = json.Unmarshal(data, &intermediate)
if e... | |
c168632 | inner loop now that we modified the slice
// we're looping over
continue OuterLoop
}
}
log.Warnf("Could not resolve some containers: [%v] for task %v", unresolved, task)
return false
}
return true
} | |
c168633 | := verifyContainerOrderingStatusResolvable(target, nameMap, containerOrderingDependenciesCanResolve); err != nil {
return false
}
return verifyStatusResolvable(target, nameMap, target.SteadyStateDependencies, onSteadyStateCanResolve)
} | |
c168634 | >= apicontainerstatus.ContainerCreated &&
run.GetKnownStatus() >= run.GetSteadyStateStatus()
} | |
c168635 | cfg,
dockerClient: dockerClient,
// We instantiate our own credentialProvider for use in acs/tcs. This tries
// to mimic roughly the way it's instantiated by the SDK for a default
// session.
credentialProvider: defaults.CredChain(defaults.Config(), defaults.Handlers()),
stateManagerFactory:... | |
c168636 | fmt.Printf("%s\t%s\n", aws.StringValue(attr.Name), aws.StringValue(attr.Value))
}
return exitcodes.ExitSuccess
} | |
c168637 | ecsclient.NewECSClient(agent.credentialProvider, agent.cfg, agent.ec2MetadataClient)
agent.initializeResourceFields(credentialsManager)
return agent.doStart(containerChangeEventStream, credentialsManager, state, imageManager, client)
} | |
c168638 | appropriate error code
seelog.Criticalf("Unable to initialize Task ENI dependencies: %v", err)
if terminal {
return exitcodes.ExitTerminal
}
return exitcodes.ExitError
}
}
// Register the container instance
err = agent.registerContainerInstance(stateManager, client, vpcSubnetAttributes)
if err !... | |
c168639 | err
}
err = agent.checkCompatibility(previousTaskEngine)
if err != nil {
seelog.Criticalf("Error checking compatibility with previously saved state: %v", err)
return nil, "", err
}
currentEC2InstanceID := agent.getEC2InstanceID()
if previousEC2InstanceID != "" && previousEC2InstanceID != currentEC2Instance... | |
c168640 | := clusterMismatchError{
fmt.Errorf(clusterMismatchErrorFormat, previousCluster, configuredCluster),
}
seelog.Criticalf("%v", err)
return err
}
agent.cfg.Cluster = previousCluster
seelog.Infof("Restored cluster '%s'", agent.cfg.Cluster)
return nil
} | |
c168641 | if err != nil {
seelog.Warnf(
"Unable to access EC2 Metadata service to determine EC2 ID: %v", err)
return ""
}
return instanceID
} | |
c168642 | aws.String(vpcIDAttributeName),
Value: aws.String(agent.vpc),
},
{
Name: aws.String(subnetIDAttributeName),
Value: aws.String(agent.subnet),
},
}
} | |
c168643 | agent.reregisterContainerInstance(client, capabilities, tags, uuid.New(), platformDevices)
}
seelog.Info("Registering Instance with ECS")
containerInstanceArn, availabilityZone, err := client.RegisterContainerInstance("", capabilities, tags, uuid.New(), platformDevices)
if err != nil {
seelog.Errorf("Error regi... | |
c168644 | //set az to agent
agent.availabilityZone = availabilityZone
if err == nil {
return nil
}
seelog.Errorf("Error re-registering: %v", err)
if apierrors.IsInstanceTypeChangedError(err) {
seelog.Criticalf(instanceTypeMismatchErrorFormat, err)
return err
}
if _, ok := err.(apierrors.AttributeError); ok {
see... | |
c168645 | Start serving the endpoint to fetch IAM Role credentials and other task metadata
if agent.cfg.TaskMetadataAZDisabled {
// send empty availability zone
go handlers.ServeTaskHTTPEndpoint(credentialsManager, state, client, agent.containerInstanceARN, agent.cfg, statsEngine, "")
} else {
go handlers.ServeTaskHTTPE... | |
c168646 | seelog.Info("Beginning Polling for updates")
err := acsSession.Start()
if err != nil {
seelog.Criticalf("Unretriable error starting communicating with ACS: %v", err)
return exitcodes.ExitTerminal
}
seelog.Critical("ACS Session handler should never exit")
return exitcodes.ExitError
} | |
c168647 | != nil {
return nil, err
}
return agent.ec2Client.DescribeECSTagsForInstance(instanceID)
} | |
c168648 | aws.StringValue(ec2Tag.Value)
}
for _, localTag := range localTags {
tagsMap[aws.StringValue(localTag.Key)] = aws.StringValue(localTag.Value)
}
return utils.MapToTags(tagsMap)
} | |
c168649 | already counted this s2 element
continue
}
s2el := s2.Slice(j, j+1)
if reflect.DeepEqual(s1el.Interface(), s2el.Interface()) {
s2found[j] = 1
continue OuterLoop
}
}
// Couldn't find something unused equal to s1
return false
}
return true
} | |
c168650 | := err.(awserr.Error)
return ok && awsErr.Code() == code
} | |
c168651 |
}
for key, value := range tagsMap {
tags = append(tags, &ecs.Tag{
Key: aws.String(key),
Value: aws.String(value),
})
}
return tags
} | |
c168652 | r, errorMessage.HTTPErrorCode, audit.GetCredentialsEventType(roleType), arn, auditLogger, errResponseJSON)
return
}
writeCredentialsRequestResponse(w, r, http.StatusOK, audit.GetCredentialsEventType(roleType), arn, auditLogger, responseJSON)
} | |
c168653 | msg := &handlersutils.ErrorMessage{
Code: ErrCredentialsUninitialized,
Message: errText,
HTTPErrorCode: http.StatusServiceUnavailable,
}
return nil, "", "", msg, errors.New(errText)
}
credentialsJSON, err := json.Marshal(credentials.IAMRoleCredentials)
if err != nil {
errText := errPr... | |
c168654 | state: state,
client: client,
minDrainEventsFrequency: minDrainEventsFrequency,
maxDrainEventsFrequency: maxDrainEventsFrequency,
}
go taskHandler.startDrainEventsTicker()
return taskHandler
} | |
c168655 |
case statechange.ContainerEvent:
event, ok := change.(api.ContainerStateChange)
if !ok {
return errors.New("eventhandler: unable to get container event from state change event")
}
handler.batchContainerEventUnsafe(event)
return nil
default:
return errors.New("eventhandler: unable to determine event ... | |
c168656 |
// Gather a list of task state changes to send. This list is
// constructed from the tasksToEvents map based on the task
// arns of containers that haven't been sent to ECS yet.
for _, taskEvent := range handler.taskStateChangesToSend() {
seelog.Infof(
"TaskHandler: Adding a state change event to ... | |
c168657 | ECS does not allow updates to
// container states once the task has moved to STOPPED.
knownStatus := task.GetKnownStatus()
if knownStatus >= apitaskstatus.TaskStopped {
continue
}
event := api.TaskStateChange{
TaskARN: taskARN,
Status: task.GetKnownStatus(),
Task: task,
}
event... | |
c168658 | event.String())
handler.tasksToContainerStates[event.TaskArn] = append(handler.tasksToContainerStates[event.TaskArn], event)
} | |
c168659 | object. Remove them from the map
delete(handler.tasksToContainerStates, taskStateChange.TaskARN)
// Prepare a given event to be sent by adding it to the handler's
// eventList
event := newSendableTaskEvent(*taskStateChange)
taskEvents := handler.getTaskEventsUnsafe(event)
// Add the event to the sendable event... | |
c168660 | taskARN,
}
handler.tasksToEvents[taskARN] = taskEvents
seelog.Debugf("TaskHandler: collecting events for new task; event: %s; events: %s ",
event.toString(), taskEvents.toStringUnsafe())
}
return taskEvents
} | |
c168661 | within this function, allowing the list to be added
// to while we're not actively sending an event
seelog.Debug("TaskHandler: Waiting on semaphore to send events...")
handler.submitSemaphore.Wait()
defer handler.submitSemaphore.Post()
var err error
done, err = taskEvents.submitFirstEvent(handler, b... | |
c168662 |
if !taskEvents.sending {
// If a send event is not already in progress, trigger the
// submitTaskEvents to start sending changes to ECS
taskEvents.sending = true
go handler.submitTaskEvents(taskEvents, client, change.taskArn())
} else {
seelog.Debugf(
"TaskHandler: Not submitting change as the task is ... | |
c168663 |
handler.client, eventToSubmit, handler.stateSaver, backoff, taskEvents); err != nil {
handleInvalidParamException(err, taskEvents.events, eventToSubmit)
return false, err
}
} else {
// Shouldn't be sent as either a task or container change event; must have been already sent
seelog.Infof("TaskHandler: N... | |
c168664 | handler.lock.RUnlock()
return len(handler.tasksToEvents)
} | |
c168665 | Event is sent with invalid parameters; just removing: %s", event.toString())
events.Remove(eventToSubmit)
}
} | |
c168666 | mock.recorder = &MockControlMockRecorder{mock}
return mock
} | |
c168667 |
ret0, _ := ret[0].(bool)
return ret0
} | |
c168668 | "Init", reflect.TypeOf((*MockControl)(nil).Init))
} | |
c168669 | make([]UsageStats, 0, maxSize),
maxSize: maxSize,
}
} | |
c168670 |
queue.lastResetTime = time.Now()
queue.buffer = queue.buffer[:0]
} | |
c168671 | dockerStatsToContainerStats(dockerStat)
if err != nil {
return err
}
queue.add(stat)
return nil
} | |
c168672 | defer queue.lock.RUnlock()
return queue.lastStat
} | |
c168673 |
usageStats := make([]UsageStats, numStats)
for i := 0; i < numStats; i++ {
// Order such that usageStats[i].timestamp > usageStats[i+1].timestamp
rawUsageStat := queue.buffer[queueLength-i-1]
usageStats[i] = UsageStats{
CPUUsagePerc: rawUsageStat.CPUUsagePerc,
MemoryUsageInMegs: rawUsageStat.Memory... | |
c168674 | := f(&stat)
if math.IsNaN(perc) {
continue
}
min = math.Min(min, perc)
max = math.Max(max, perc)
sampleCount++
sum += perc
}
return &ecstcs.CWStatsSet{
Max: &max,
Min: &min,
SampleCount: &sampleCount,
Sum: &sum,
}, nil
} | |
c168675 | mock.recorder = &MockCNIClientMockRecorder{mock}
return mock
} | |
c168676 | m.ctrl.Call(m, "Capabilities", arg0)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168677 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Capabilities", reflect.TypeOf((*MockCNIClient)(nil).Capabilities), arg0)
} | |
c168678 | time.Duration) error {
ret := m.ctrl.Call(m, "CleanupNS", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | |
c168679 | m.ctrl.Call(m, "ReleaseIPResource", arg0)
ret0, _ := ret[0].(error)
return ret0
} | |
c168680 | arg2)
ret0, _ := ret[0].(*current.Result)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168681 | reflect.TypeOf((*MockCNIClient)(nil).SetupNS), arg0, arg1, arg2)
} | |
c168682 | != nil {
responseJSON, _ := json.Marshal(
fmt.Sprintf("V3 container associations handler: unable to get task arn from request: %s", err.Error()))
utils.WriteJSONToResponse(w, http.StatusBadRequest, responseJSON, utils.RequestTypeContainerAssociations)
return
}
associationType, err := getAssociationTy... | |
c168683 | != nil {
responseJSON, _ := json.Marshal(
fmt.Sprintf("V3 container associations handler: %s", err.Error()))
utils.WriteJSONToResponse(w, http.StatusBadRequest, responseJSON, utils.RequestTypeContainerAssociation)
return
}
associationName, err := getAssociationNameByRequest(r)
if err != nil {
re... | |
c168684 | cfg.DataDir,
dataDirOnHost: cfg.DataDirOnHost,
osWrap: oswrapper.NewOS(),
ioutilWrap: ioutilwrapper.NewIOUtil(),
}
} | |
c168685 | it in JSON format to the file
metadata := manager.parseMetadataAtContainerCreate(task, containerName)
err = manager.marshalAndWrite(metadata, task.Arn, containerName)
if err != nil {
return err
}
// Add the directory of this container's metadata to the container's mount binds
// Then add the destination direc... | |
c168686 | %s: container not running or invalid", containerName, task.Arn)
}
// Acquire the metadata then write it in JSON format to the file
metadata := manager.parseMetadata(dockerContainer, task, containerName)
return manager.marshalAndWrite(metadata, task.Arn, containerName)
} | |
c168687 | if err != nil {
return fmt.Errorf("clean task metadata: unable to get metadata directory for task %s: %v", taskARN, err)
}
return manager.osWrap.RemoveAll(metadataPath)
} | |
c168688 | }
intermediateAuthData[registry] = types.AuthConfig{
Username: usernamePass[0],
Password: usernamePass[1],
}
}
case "":
// not set; no warn
return dockerAuths{}
default:
seelog.Warnf("Unknown auth configuration: %v", authType)
return dockerAuths{}
}
// Normalize intermediate registry key... | |
c168689 | request", "method", r.Method, "from", r.RemoteAddr)
lh.h.ServeHTTP(w, r)
} | |
c168690 | case <-ctx.Done():
return
default:
time.Sleep(randomDuration(start, end))
sendNow(ticker)
}
}
}()
return ticker
} | |
c168691 |
return nil, err
}
return &ecs.Attribute{
Name: aws.String(attributePrefix + cniPluginVersionSuffix),
Value: aws.String(version),
}, nil
} | |
c168692 | mock.recorder = &MockECSSDKMockRecorder{mock}
return mock
} | |
c168693 | _ := ret[0].(*ecs.CreateClusterOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168694 | ret0, _ := ret[0].(*ecs.ListTagsForResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c168695 | ctrl}
mock.recorder = &MockECSSubmitStateSDKMockRecorder{mock}
return mock
} | |
c168696 | reflect.TypeOf((*MockECSSubmitStateSDK)(nil).SubmitContainerStateChange), arg0)
} | |
c168697 | mock.recorder = &MockECSClientMockRecorder{mock}
return mock
} | |
c168698 | mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSClient)(nil).DiscoverPollEndpoint), arg0)
} | |
c168699 | m.ctrl.Call(m, "GetResourceTags", arg0)
ret0, _ := ret[0].([]*ecs.Tag)
ret1, _ := ret[1].(error)
return ret0, ret1
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.