_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168600 | main | validation | func main() {
versionStr, _ := ioutil.ReadFile(filepath.Join("..", "..", "VERSION"))
// default values
info := versionInfo{
Version: strings.TrimSpace(string(versionStr)),
Dirty: true,
Hash: "UNKNOWN",
}
if strings.TrimSpace(os.Getenv("ECS_RELEASE")) == "cleanbuild" {
// 'clean' release; all other ... | go | {
"resource": ""
} |
q168601 | IsRetriableError | validation | func (err CannotStopContainerError) IsRetriableError() bool {
if _, ok := err.FromError.(NoSuchContainerError); ok {
return false
}
return true
} | go | {
"resource": ""
} |
q168602 | NewMockFile | validation | func NewMockFile(ctrl *gomock.Controller) *MockFile {
mock := &MockFile{ctrl: ctrl}
mock.recorder = &MockFileMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168603 | Chmod | validation | func (m *MockFile) Chmod(arg0 os.FileMode) error {
ret := m.ctrl.Call(m, "Chmod", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q168604 | Chmod | validation | func (mr *MockFileMockRecorder) Chmod(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chmod", reflect.TypeOf((*MockFile)(nil).Chmod), arg0)
} | go | {
"resource": ""
} |
q168605 | Write | validation | func (m *MockFile) Write(arg0 []byte) (int, error) {
ret := m.ctrl.Call(m, "Write", arg0)
ret0, _ := ret[0].(int)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168606 | NewMockOS | validation | func NewMockOS(ctrl *gomock.Controller) *MockOS {
mock := &MockOS{ctrl: ctrl}
mock.recorder = &MockOSMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168607 | Create | validation | func (mr *MockOSMockRecorder) Create(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOS)(nil).Create), arg0)
} | go | {
"resource": ""
} |
q168608 | IsNotExist | validation | func (m *MockOS) IsNotExist(arg0 error) bool {
ret := m.ctrl.Call(m, "IsNotExist", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q168609 | OpenFile | validation | func (m *MockOS) OpenFile(arg0 string, arg1 int, arg2 os.FileMode) (oswrapper.File, error) {
ret := m.ctrl.Call(m, "OpenFile", arg0, arg1, arg2)
ret0, _ := ret[0].(oswrapper.File)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168610 | RemoveAll | validation | func (m *MockOS) RemoveAll(arg0 string) error {
ret := m.ctrl.Call(m, "RemoveAll", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q168611 | NewMockSSMClientCreator | validation | func NewMockSSMClientCreator(ctrl *gomock.Controller) *MockSSMClientCreator {
mock := &MockSSMClientCreator{ctrl: ctrl}
mock.recorder = &MockSSMClientCreatorMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168612 | NewSSMClient | validation | func (m *MockSSMClientCreator) NewSSMClient(arg0 string, arg1 credentials.IAMRoleCredentials) ssm.SSMClient {
ret := m.ctrl.Call(m, "NewSSMClient", arg0, arg1)
ret0, _ := ret[0].(ssm.SSMClient)
return ret0
} | go | {
"resource": ""
} |
q168613 | NewSSMClient | validation | func (mr *MockSSMClientCreatorMockRecorder) NewSSMClient(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewSSMClient", reflect.TypeOf((*MockSSMClientCreator)(nil).NewSSMClient), arg0, arg1)
} | go | {
"resource": ""
} |
q168614 | NewMockEC2MetadataClient | validation | func NewMockEC2MetadataClient(ctrl *gomock.Controller) *MockEC2MetadataClient {
mock := &MockEC2MetadataClient{ctrl: ctrl}
mock.recorder = &MockEC2MetadataClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168615 | DefaultCredentials | validation | func (m *MockEC2MetadataClient) DefaultCredentials() (*ec2.RoleCredentials, error) {
ret := m.ctrl.Call(m, "DefaultCredentials")
ret0, _ := ret[0].(*ec2.RoleCredentials)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168616 | DefaultCredentials | validation | func (mr *MockEC2MetadataClientMockRecorder) DefaultCredentials() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultCredentials", reflect.TypeOf((*MockEC2MetadataClient)(nil).DefaultCredentials))
} | go | {
"resource": ""
} |
q168617 | GetDynamicData | validation | func (m *MockEC2MetadataClient) GetDynamicData(arg0 string) (string, error) {
ret := m.ctrl.Call(m, "GetDynamicData", arg0)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168618 | InstanceIdentityDocument | validation | func (m *MockEC2MetadataClient) InstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) {
ret := m.ctrl.Call(m, "InstanceIdentityDocument")
ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168619 | NewMockHttpClient | validation | func NewMockHttpClient(ctrl *gomock.Controller) *MockHttpClient {
mock := &MockHttpClient{ctrl: ctrl}
mock.recorder = &MockHttpClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168620 | GetInstanceIdentityDocument | validation | func (m *MockHttpClient) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) {
ret := m.ctrl.Call(m, "GetInstanceIdentityDocument")
ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168621 | GetUserData | validation | func (m *MockHttpClient) GetUserData() (string, error) {
ret := m.ctrl.Call(m, "GetUserData")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168622 | GetUserData | validation | func (mr *MockHttpClientMockRecorder) GetUserData() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserData", reflect.TypeOf((*MockHttpClient)(nil).GetUserData))
} | go | {
"resource": ""
} |
q168623 | NewMockClient | validation | func NewMockClient(ctrl *gomock.Controller) *MockClient {
mock := &MockClient{ctrl: ctrl}
mock.recorder = &MockClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168624 | DescribeECSTagsForInstance | validation | func (m *MockClient) DescribeECSTagsForInstance(arg0 string) ([]*ecs.Tag, error) {
ret := m.ctrl.Call(m, "DescribeECSTagsForInstance", arg0)
ret0, _ := ret[0].([]*ecs.Tag)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168625 | NewMockClientSDK | validation | func NewMockClientSDK(ctrl *gomock.Controller) *MockClientSDK {
mock := &MockClientSDK{ctrl: ctrl}
mock.recorder = &MockClientSDKMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168626 | CreateTags | validation | func (m *MockClientSDK) CreateTags(arg0 *ec20.CreateTagsInput) (*ec20.CreateTagsOutput, error) {
ret := m.ctrl.Call(m, "CreateTags", arg0)
ret0, _ := ret[0].(*ec20.CreateTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168627 | DescribeTags | validation | func (m *MockClientSDK) DescribeTags(arg0 *ec20.DescribeTagsInput) (*ec20.DescribeTagsOutput, error) {
ret := m.ctrl.Call(m, "DescribeTags", arg0)
ret0, _ := ret[0].(*ec20.DescribeTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168628 | DescribeTags | validation | func (mr *MockClientSDKMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockClientSDK)(nil).DescribeTags), arg0)
} | go | {
"resource": ""
} |
q168629 | NewStateManager | validation | func NewStateManager(cfg *config.Config, options ...Option) (StateManager, error) {
fi, err := os.Stat(cfg.DataDir)
if err != nil {
return nil, err
}
if !fi.IsDir() {
return nil, errors.New("State manager DataDir must exist")
}
state := &state{
Data: make(saveableState),
Version: ECSDataVersion,
}
m... | go | {
"resource": ""
} |
q168630 | Save | validation | func (manager *basicStateManager) Save() error {
defer metrics.MetricsEngineGlobal.RecordStateManagerMetric("SAVE")()
manager.saveTimesLock.Lock()
defer manager.saveTimesLock.Unlock()
if time.Since(manager.lastSave) >= minSaveInterval {
// we can just save
err := manager.ForceSave()
manager.lastSave = time.No... | go | {
"resource": ""
} |
q168631 | Load | validation | func (manager *basicStateManager) Load() error {
s := manager.state
log.Info("Loading state!")
data, err := manager.readFile()
if err != nil {
log.Error("Error reading existing state file", "err", err)
return err
}
if data == nil {
return nil
}
// Dry-run to make sure this is a version we can understand
... | go | {
"resource": ""
} |
q168632 | ValidDependencies | validation | func ValidDependencies(task *apitask.Task) bool {
unresolved := make([]*apicontainer.Container, len(task.Containers))
resolved := make([]*apicontainer.Container, 0, len(task.Containers))
copy(unresolved, task.Containers)
OuterLoop:
for len(unresolved) > 0 {
for i, tryResolve := range unresolved {
if dependen... | go | {
"resource": ""
} |
q168633 | dependenciesCanBeResolved | validation | func dependenciesCanBeResolved(target *apicontainer.Container, by []*apicontainer.Container) bool {
nameMap := make(map[string]*apicontainer.Container)
for _, cont := range by {
nameMap[cont.Name] = cont
}
if _, err := verifyContainerOrderingStatusResolvable(target, nameMap, containerOrderingDependenciesCanResol... | go | {
"resource": ""
} |
q168634 | onSteadyStateIsResolved | validation | func onSteadyStateIsResolved(target *apicontainer.Container, run *apicontainer.Container) bool {
return target.GetDesiredStatus() >= apicontainerstatus.ContainerCreated &&
run.GetKnownStatus() >= run.GetSteadyStateStatus()
} | go | {
"resource": ""
} |
q168635 | newAgent | validation | func newAgent(
ctx context.Context,
blackholeEC2Metadata bool,
acceptInsecureCert *bool) (agent, error) {
ec2MetadataClient := ec2.NewEC2MetadataClient(nil)
if blackholeEC2Metadata {
ec2MetadataClient = ec2.NewBlackholeEC2MetadataClient()
}
seelog.Info("Loading configuration")
cfg, err := config.NewConfig(e... | go | {
"resource": ""
} |
q168636 | printECSAttributes | validation | func (agent *ecsAgent) printECSAttributes() int {
capabilities, err := agent.capabilities()
if err != nil {
seelog.Warnf("Unable to obtain capabilities: %v", err)
return exitcodes.ExitError
}
for _, attr := range capabilities {
fmt.Printf("%s\t%s\n", aws.StringValue(attr.Name), aws.StringValue(attr.Value))
}... | go | {
"resource": ""
} |
q168637 | start | validation | func (agent *ecsAgent) start() int {
sighandlers.StartDebugHandler()
containerChangeEventStream := eventstream.NewEventStream(containerChangeEventStreamName, agent.ctx)
credentialsManager := credentials.NewManager()
state := dockerstate.NewTaskEngineState()
imageManager := engine.NewImageManager(agent.cfg, agent.... | go | {
"resource": ""
} |
q168638 | doStart | validation | func (agent *ecsAgent) doStart(containerChangeEventStream *eventstream.EventStream,
credentialsManager credentials.Manager,
state dockerstate.TaskEngineState,
imageManager engine.ImageManager,
client api.ECSClient) int {
// check docker version >= 1.9.0, exit agent if older
if exitcode, ok := agent.verifyRequire... | go | {
"resource": ""
} |
q168639 | newTaskEngine | validation | func (agent *ecsAgent) newTaskEngine(containerChangeEventStream *eventstream.EventStream,
credentialsManager credentials.Manager,
state dockerstate.TaskEngineState,
imageManager engine.ImageManager) (engine.TaskEngine, string, error) {
containerChangeEventStream.StartListening()
if !agent.cfg.Checkpoint {
seel... | go | {
"resource": ""
} |
q168640 | setClusterInConfig | validation | func (agent *ecsAgent) setClusterInConfig(previousCluster string) error {
// TODO Handle default cluster in a sane and unified way across the codebase
configuredCluster := agent.cfg.Cluster
if configuredCluster == "" {
seelog.Debug("Setting cluster to default; none configured")
configuredCluster = config.Default... | go | {
"resource": ""
} |
q168641 | getEC2InstanceID | validation | func (agent *ecsAgent) getEC2InstanceID() string {
instanceID, err := agent.ec2MetadataClient.InstanceID()
if err != nil {
seelog.Warnf(
"Unable to access EC2 Metadata service to determine EC2 ID: %v", err)
return ""
}
return instanceID
} | go | {
"resource": ""
} |
q168642 | constructVPCSubnetAttributes | validation | func (agent *ecsAgent) constructVPCSubnetAttributes() []*ecs.Attribute {
return []*ecs.Attribute{
{
Name: aws.String(vpcIDAttributeName),
Value: aws.String(agent.vpc),
},
{
Name: aws.String(subnetIDAttributeName),
Value: aws.String(agent.subnet),
},
}
} | go | {
"resource": ""
} |
q168643 | registerContainerInstance | validation | func (agent *ecsAgent) registerContainerInstance(
stateManager statemanager.StateManager,
client api.ECSClient,
additionalAttributes []*ecs.Attribute) error {
// Preflight request to make sure they're good
if preflightCreds, err := agent.credentialProvider.Get(); err != nil || preflightCreds.AccessKeyID == "" {
... | go | {
"resource": ""
} |
q168644 | reregisterContainerInstance | validation | func (agent *ecsAgent) reregisterContainerInstance(client api.ECSClient,
capabilities []*ecs.Attribute, tags []*ecs.Tag, registrationToken string, platformDevices []*ecs.PlatformDevice) error {
_, availabilityZone, err := client.RegisterContainerInstance(agent.containerInstanceARN, capabilities, tags, registrationTok... | go | {
"resource": ""
} |
q168645 | startAsyncRoutines | validation | func (agent *ecsAgent) startAsyncRoutines(
containerChangeEventStream *eventstream.EventStream,
credentialsManager credentials.Manager,
imageManager engine.ImageManager,
taskEngine engine.TaskEngine,
stateManager statemanager.StateManager,
deregisterInstanceEventStream *eventstream.EventStream,
client api.ECSCli... | go | {
"resource": ""
} |
q168646 | startACSSession | validation | func (agent *ecsAgent) startACSSession(
credentialsManager credentials.Manager,
taskEngine engine.TaskEngine,
stateManager statemanager.StateManager,
deregisterInstanceEventStream *eventstream.EventStream,
client api.ECSClient,
state dockerstate.TaskEngineState,
taskHandler *eventhandler.TaskHandler) int {
acs... | go | {
"resource": ""
} |
q168647 | getContainerInstanceTagsFromEC2API | validation | func (agent *ecsAgent) getContainerInstanceTagsFromEC2API() ([]*ecs.Tag, error) {
// Get instance ID from ec2 metadata client.
instanceID, err := agent.ec2MetadataClient.InstanceID()
if err != nil {
return nil, err
}
return agent.ec2Client.DescribeECSTagsForInstance(instanceID)
} | go | {
"resource": ""
} |
q168648 | mergeTags | validation | func mergeTags(localTags []*ecs.Tag, ec2Tags []*ecs.Tag) []*ecs.Tag {
tagsMap := make(map[string]string)
for _, ec2Tag := range ec2Tags {
tagsMap[aws.StringValue(ec2Tag.Key)] = aws.StringValue(ec2Tag.Value)
}
for _, localTag := range localTags {
tagsMap[aws.StringValue(localTag.Key)] = aws.StringValue(localTa... | go | {
"resource": ""
} |
q168649 | SlicesDeepEqual | validation | func SlicesDeepEqual(slice1, slice2 interface{}) bool {
s1 := reflect.ValueOf(slice1)
s2 := reflect.ValueOf(slice2)
if s1.Len() != s2.Len() {
return false
}
if s1.Len() == 0 {
return true
}
s2found := make([]int, s2.Len())
OuterLoop:
for i := 0; i < s1.Len(); i++ {
s1el := s1.Slice(i, i+1)
for j := 0;... | go | {
"resource": ""
} |
q168650 | IsAWSErrorCodeEqual | validation | func IsAWSErrorCodeEqual(err error, code string) bool {
awsErr, ok := err.(awserr.Error)
return ok && awsErr.Code() == code
} | go | {
"resource": ""
} |
q168651 | MapToTags | validation | func MapToTags(tagsMap map[string]string) []*ecs.Tag {
tags := make([]*ecs.Tag, 0)
if tagsMap == nil {
return tags
}
for key, value := range tagsMap {
tags = append(tags, &ecs.Tag{
Key: aws.String(key),
Value: aws.String(value),
})
}
return tags
} | go | {
"resource": ""
} |
q168652 | CredentialsHandlerImpl | validation | func CredentialsHandlerImpl(w http.ResponseWriter, r *http.Request, auditLogger audit.AuditLogger, credentialsManager credentials.Manager, credentialsID string, errPrefix string) {
responseJSON, arn, roleType, errorMessage, err := processCredentialsRequest(credentialsManager, r, credentialsID, errPrefix)
if err != ni... | go | {
"resource": ""
} |
q168653 | processCredentialsRequest | validation | func processCredentialsRequest(credentialsManager credentials.Manager, r *http.Request, credentialsID string, errPrefix string) ([]byte, string, string, *handlersutils.ErrorMessage, error) {
if credentialsID == "" {
errText := errPrefix + "No ID in the request"
seelog.Infof("%s. Request IP Address: %s", errText, r... | go | {
"resource": ""
} |
q168654 | NewTaskHandler | validation | func NewTaskHandler(ctx context.Context,
stateManager statemanager.Saver,
state dockerstate.TaskEngineState,
client api.ECSClient) *TaskHandler {
// Create a handler and start the periodic event drain loop
taskHandler := &TaskHandler{
ctx: ctx,
tasksToEvents: make(map[string]*task... | go | {
"resource": ""
} |
q168655 | AddStateChangeEvent | validation | func (handler *TaskHandler) AddStateChangeEvent(change statechange.Event, client api.ECSClient) error {
handler.lock.Lock()
defer handler.lock.Unlock()
switch change.GetEventType() {
case statechange.TaskEvent:
event, ok := change.(api.TaskStateChange)
if !ok {
return errors.New("eventhandler: unable to get... | go | {
"resource": ""
} |
q168656 | startDrainEventsTicker | validation | func (handler *TaskHandler) startDrainEventsTicker() {
derivedCtx, cancel := context.WithCancel(handler.ctx)
defer cancel()
ticker := utils.NewJitteredTicker(derivedCtx, handler.minDrainEventsFrequency, handler.maxDrainEventsFrequency)
for {
select {
case <-handler.ctx.Done():
seelog.Infof("TaskHandler: Stop... | go | {
"resource": ""
} |
q168657 | taskStateChangesToSend | validation | func (handler *TaskHandler) taskStateChangesToSend() []api.TaskStateChange {
handler.lock.RLock()
defer handler.lock.RUnlock()
var events []api.TaskStateChange
for taskARN := range handler.tasksToContainerStates {
// An entry for the task in tasksToContainerStates means that there
// is at least 1 container ev... | go | {
"resource": ""
} |
q168658 | batchContainerEventUnsafe | validation | func (handler *TaskHandler) batchContainerEventUnsafe(event api.ContainerStateChange) {
seelog.Infof("TaskHandler: batching container event: %s", event.String())
handler.tasksToContainerStates[event.TaskArn] = append(handler.tasksToContainerStates[event.TaskArn], event)
} | go | {
"resource": ""
} |
q168659 | flushBatchUnsafe | validation | func (handler *TaskHandler) flushBatchUnsafe(taskStateChange *api.TaskStateChange, client api.ECSClient) {
taskStateChange.Containers = append(taskStateChange.Containers,
handler.tasksToContainerStates[taskStateChange.TaskARN]...)
// All container events for the task have now been copied to the
// task state chang... | go | {
"resource": ""
} |
q168660 | getTaskEventsUnsafe | validation | func (handler *TaskHandler) getTaskEventsUnsafe(event *sendableEvent) *taskSendableEvents {
taskARN := event.taskArn()
taskEvents, ok := handler.tasksToEvents[taskARN]
if !ok {
// We are not tracking this task arn in the tasksToEvents map. Create
// a new entry
taskEvents = &taskSendableEvents{
events: ... | go | {
"resource": ""
} |
q168661 | submitTaskEvents | validation | func (handler *TaskHandler) submitTaskEvents(taskEvents *taskSendableEvents, client api.ECSClient, taskARN string) {
defer metrics.MetricsEngineGlobal.RecordECSClientMetric("SUBMIT_TASK_EVENTS")()
defer handler.removeTaskEvents(taskARN)
backoff := retry.NewExponentialBackoff(submitStateBackoffMin, submitStateBackof... | go | {
"resource": ""
} |
q168662 | sendChange | validation | func (taskEvents *taskSendableEvents) sendChange(change *sendableEvent,
client api.ECSClient,
handler *TaskHandler) {
taskEvents.lock.Lock()
defer taskEvents.lock.Unlock()
// Add event to the queue
seelog.Infof("TaskHandler: Adding event: %s", change.toString())
taskEvents.events.PushBack(change)
if !taskEve... | go | {
"resource": ""
} |
q168663 | submitFirstEvent | validation | func (taskEvents *taskSendableEvents) submitFirstEvent(handler *TaskHandler, backoff retry.Backoff) (bool, error) {
seelog.Debug("TaskHandler: Acquiring lock for sending event...")
taskEvents.lock.Lock()
defer taskEvents.lock.Unlock()
seelog.Debugf("TaskHandler: Acquired lock, processing event list: : %s", taskEve... | go | {
"resource": ""
} |
q168664 | getTasksToEventsLen | validation | func (handler *TaskHandler) getTasksToEventsLen() int {
handler.lock.RLock()
defer handler.lock.RUnlock()
return len(handler.tasksToEvents)
} | go | {
"resource": ""
} |
q168665 | handleInvalidParamException | validation | func handleInvalidParamException(err error, events *list.List, eventToSubmit *list.Element) {
if utils.IsAWSErrorCodeEqual(err, ecs.ErrCodeInvalidParameterException) {
event := eventToSubmit.Value.(*sendableEvent)
seelog.Warnf("TaskHandler: Event is sent with invalid parameters; just removing: %s", event.toString(... | go | {
"resource": ""
} |
q168666 | NewMockControl | validation | func NewMockControl(ctrl *gomock.Controller) *MockControl {
mock := &MockControl{ctrl: ctrl}
mock.recorder = &MockControlMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168667 | Exists | validation | func (m *MockControl) Exists(arg0 string) bool {
ret := m.ctrl.Call(m, "Exists", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q168668 | Init | validation | func (mr *MockControlMockRecorder) Init() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockControl)(nil).Init))
} | go | {
"resource": ""
} |
q168669 | NewQueue | validation | func NewQueue(maxSize int) *Queue {
return &Queue{
buffer: make([]UsageStats, 0, maxSize),
maxSize: maxSize,
}
} | go | {
"resource": ""
} |
q168670 | Reset | validation | func (queue *Queue) Reset() {
queue.lock.Lock()
defer queue.lock.Unlock()
queue.lastResetTime = time.Now()
queue.buffer = queue.buffer[:0]
} | go | {
"resource": ""
} |
q168671 | Add | validation | func (queue *Queue) Add(dockerStat *types.StatsJSON) error {
queue.setLastStat(dockerStat)
stat, err := dockerStatsToContainerStats(dockerStat)
if err != nil {
return err
}
queue.add(stat)
return nil
} | go | {
"resource": ""
} |
q168672 | GetLastStat | validation | func (queue *Queue) GetLastStat() *types.StatsJSON {
queue.lock.RLock()
defer queue.lock.RUnlock()
return queue.lastStat
} | go | {
"resource": ""
} |
q168673 | GetRawUsageStats | validation | func (queue *Queue) GetRawUsageStats(numStats int) ([]UsageStats, error) {
queue.lock.Lock()
defer queue.lock.Unlock()
queueLength := len(queue.buffer)
if queueLength == 0 {
return nil, fmt.Errorf("No data in the queue")
}
if numStats > queueLength {
numStats = queueLength
}
usageStats := make([]UsageSta... | go | {
"resource": ""
} |
q168674 | getCWStatsSet | validation | func (queue *Queue) getCWStatsSet(f getUsageFunc) (*ecstcs.CWStatsSet, error) {
queue.lock.Lock()
defer queue.lock.Unlock()
queueLength := len(queue.buffer)
if queueLength < 2 {
// Need at least 2 data points to calculate this.
return nil, fmt.Errorf("No data in the queue")
}
var min, max, sum float64
var ... | go | {
"resource": ""
} |
q168675 | NewMockCNIClient | validation | func NewMockCNIClient(ctrl *gomock.Controller) *MockCNIClient {
mock := &MockCNIClient{ctrl: ctrl}
mock.recorder = &MockCNIClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168676 | Capabilities | validation | func (m *MockCNIClient) Capabilities(arg0 string) ([]string, error) {
ret := m.ctrl.Call(m, "Capabilities", arg0)
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168677 | Capabilities | validation | func (mr *MockCNIClientMockRecorder) Capabilities(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Capabilities", reflect.TypeOf((*MockCNIClient)(nil).Capabilities), arg0)
} | go | {
"resource": ""
} |
q168678 | CleanupNS | validation | func (m *MockCNIClient) CleanupNS(arg0 context.Context, arg1 *ecscni.Config, arg2 time.Duration) error {
ret := m.ctrl.Call(m, "CleanupNS", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q168679 | ReleaseIPResource | validation | func (m *MockCNIClient) ReleaseIPResource(arg0 *ecscni.Config) error {
ret := m.ctrl.Call(m, "ReleaseIPResource", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q168680 | SetupNS | validation | func (m *MockCNIClient) SetupNS(arg0 context.Context, arg1 *ecscni.Config, arg2 time.Duration) (*current.Result, error) {
ret := m.ctrl.Call(m, "SetupNS", arg0, arg1, arg2)
ret0, _ := ret[0].(*current.Result)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168681 | SetupNS | validation | func (mr *MockCNIClientMockRecorder) SetupNS(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupNS", reflect.TypeOf((*MockCNIClient)(nil).SetupNS), arg0, arg1, arg2)
} | go | {
"resource": ""
} |
q168682 | ContainerAssociationsHandler | validation | func ContainerAssociationsHandler(state dockerstate.TaskEngineState) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
containerID, err := getContainerIDByRequest(r, state)
if err != nil {
responseJSON, _ := json.Marshal(
fmt.Sprintf("V3 container associations ... | go | {
"resource": ""
} |
q168683 | ContainerAssociationHandler | validation | func ContainerAssociationHandler(state dockerstate.TaskEngineState) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
taskARN, err := getTaskARNByRequest(r, state)
if err != nil {
responseJSON, _ := json.Marshal(
fmt.Sprintf("V3 container associations handler: ... | go | {
"resource": ""
} |
q168684 | NewManager | validation | func NewManager(client DockerMetadataClient, cfg *config.Config) Manager {
return &metadataManager{
client: client,
cluster: cfg.Cluster,
dataDir: cfg.DataDir,
dataDirOnHost: cfg.DataDirOnHost,
osWrap: oswrapper.NewOS(),
ioutilWrap: ioutilwrapper.NewIOUtil(),
}
} | go | {
"resource": ""
} |
q168685 | Create | validation | func (manager *metadataManager) Create(config *dockercontainer.Config, hostConfig *dockercontainer.HostConfig, task *apitask.Task, containerName string) error {
// Create task and container directories if they do not yet exist
metadataDirectoryPath, err := getMetadataFilePath(task.Arn, containerName, manager.dataDir)... | go | {
"resource": ""
} |
q168686 | Update | validation | func (manager *metadataManager) Update(ctx context.Context, dockerID string, task *apitask.Task, containerName string) error {
// Get docker container information through api call
dockerContainer, err := manager.client.InspectContainer(ctx, dockerID, dockerclient.InspectContainerTimeout)
if err != nil {
return err... | go | {
"resource": ""
} |
q168687 | Clean | validation | func (manager *metadataManager) Clean(taskARN string) error {
metadataPath, err := getTaskMetadataDir(taskARN, manager.dataDir)
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)
} | go | {
"resource": ""
} |
q168688 | parseAuthData | validation | func parseAuthData(authType string, authData json.RawMessage) dockerAuths {
intermediateAuthData := make(dockerAuths)
switch authType {
case "docker":
err := json.Unmarshal(authData, &intermediateAuthData)
if err != nil {
seelog.Warn("Could not parse 'docker' type auth config")
return dockerAuths{}
}
ca... | go | {
"resource": ""
} |
q168689 | ServeHTTP | validation | func (lh LoggingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
seelog.Debug("Handling http request", "method", r.Method, "from", r.RemoteAddr)
lh.h.ServeHTTP(w, r)
} | go | {
"resource": ""
} |
q168690 | NewJitteredTicker | validation | func NewJitteredTicker(ctx context.Context, start, end time.Duration) <-chan time.Time {
ticker := make(chan time.Time, 1)
go func() {
defer close(ticker)
for {
select {
case <-ctx.Done():
return
default:
time.Sleep(randomDuration(start, end))
sendNow(ticker)
}
}
}()
return ticker
} | go | {
"resource": ""
} |
q168691 | getTaskENIPluginVersionAttribute | validation | func (agent *ecsAgent) getTaskENIPluginVersionAttribute() (*ecs.Attribute, error) {
version, err := agent.cniClient.Version(ecscni.ECSENIPluginName)
if err != nil {
seelog.Warnf(
"Unable to determine the version of the plugin '%s': %v",
ecscni.ECSENIPluginName, err)
return nil, err
}
return &ecs.Attribut... | go | {
"resource": ""
} |
q168692 | NewMockECSSDK | validation | func NewMockECSSDK(ctrl *gomock.Controller) *MockECSSDK {
mock := &MockECSSDK{ctrl: ctrl}
mock.recorder = &MockECSSDKMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168693 | CreateCluster | validation | func (m *MockECSSDK) CreateCluster(arg0 *ecs.CreateClusterInput) (*ecs.CreateClusterOutput, error) {
ret := m.ctrl.Call(m, "CreateCluster", arg0)
ret0, _ := ret[0].(*ecs.CreateClusterOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168694 | ListTagsForResource | validation | func (m *MockECSSDK) ListTagsForResource(arg0 *ecs.ListTagsForResourceInput) (*ecs.ListTagsForResourceOutput, error) {
ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
ret0, _ := ret[0].(*ecs.ListTagsForResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168695 | NewMockECSSubmitStateSDK | validation | func NewMockECSSubmitStateSDK(ctrl *gomock.Controller) *MockECSSubmitStateSDK {
mock := &MockECSSubmitStateSDK{ctrl: ctrl}
mock.recorder = &MockECSSubmitStateSDKMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168696 | SubmitContainerStateChange | validation | func (mr *MockECSSubmitStateSDKMockRecorder) SubmitContainerStateChange(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitContainerStateChange", reflect.TypeOf((*MockECSSubmitStateSDK)(nil).SubmitContainerStateChange), arg0)
} | go | {
"resource": ""
} |
q168697 | NewMockECSClient | validation | func NewMockECSClient(ctrl *gomock.Controller) *MockECSClient {
mock := &MockECSClient{ctrl: ctrl}
mock.recorder = &MockECSClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168698 | DiscoverPollEndpoint | validation | func (mr *MockECSClientMockRecorder) DiscoverPollEndpoint(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscoverPollEndpoint", reflect.TypeOf((*MockECSClient)(nil).DiscoverPollEndpoint), arg0)
} | go | {
"resource": ""
} |
q168699 | GetResourceTags | validation | func (m *MockECSClient) GetResourceTags(arg0 string) ([]*ecs.Tag, error) {
ret := m.ctrl.Call(m, "GetResourceTags", arg0)
ret0, _ := ret[0].([]*ecs.Tag)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.