_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q169300 | IAMRoleCredentialsFromACS | validation | func IAMRoleCredentialsFromACS(roleCredentials *ecsacs.IAMRoleCredentials, roleType string) IAMRoleCredentials {
return IAMRoleCredentials{
CredentialsID: aws.StringValue(roleCredentials.CredentialsId),
SessionToken: aws.StringValue(roleCredentials.SessionToken),
RoleArn: aws.StringValue(roleCredent... | go | {
"resource": ""
} |
q169301 | SetTaskCredentials | validation | func (manager *credentialsManager) SetTaskCredentials(taskCredentials *TaskIAMRoleCredentials) error {
manager.taskCredentialsLock.Lock()
defer manager.taskCredentialsLock.Unlock()
credentials := taskCredentials.IAMRoleCredentials
// Validate that credentials id is not empty
if credentials.CredentialsID == "" {
... | go | {
"resource": ""
} |
q169302 | GetTaskCredentials | validation | func (manager *credentialsManager) GetTaskCredentials(id string) (TaskIAMRoleCredentials, bool) {
manager.taskCredentialsLock.RLock()
defer manager.taskCredentialsLock.RUnlock()
taskCredentials, ok := manager.idToTaskCredentials[id]
if !ok {
return TaskIAMRoleCredentials{}, ok
}
return TaskIAMRoleCredentials{... | go | {
"resource": ""
} |
q169303 | RemoveCredentials | validation | func (manager *credentialsManager) RemoveCredentials(id string) {
manager.taskCredentialsLock.Lock()
defer manager.taskCredentialsLock.Unlock()
delete(manager.idToTaskCredentials, id)
} | go | {
"resource": ""
} |
q169304 | verifyResponseFieldNames | validation | func verifyResponseFieldNames(expectedFields []string, responseBody []byte, responseName string) error {
var responseMap map[string]json.RawMessage
if err := json.Unmarshal(responseBody, &responseMap); err != nil {
fmt.Errorf("unable to unmarshal %s response to response map", responseName)
}
for _, field := rang... | go | {
"resource": ""
} |
q169305 | Getpid | validation | func (m *MockOS) Getpid() int {
ret := m.ctrl.Call(m, "Getpid")
ret0, _ := ret[0].(int)
return ret0
} | go | {
"resource": ""
} |
q169306 | Getpid | validation | func (mr *MockOSMockRecorder) Getpid() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Getpid", reflect.TypeOf((*MockOS)(nil).Getpid))
} | go | {
"resource": ""
} |
q169307 | AppMeshFromACS | validation | func AppMeshFromACS(proxyConfig *ecsacs.ProxyConfiguration) (*AppMesh, error) {
if *proxyConfig.Type != appMesh {
return nil, fmt.Errorf("agent does not support proxy type other than app mesh")
}
return &AppMesh{
ContainerName: aws.StringValue(proxyConfig.ContainerName),
IgnoredUID: aws.StringVa... | go | {
"resource": ""
} |
q169308 | buildAppPorts | validation | func buildAppPorts(proxyConfig *ecsacs.ProxyConfiguration) []string {
var inputAppPorts []string
if proxyConfig.Properties[appPorts] != nil {
inputAppPorts = strings.Split(*proxyConfig.Properties[appPorts], splitter)
}
return inputAppPorts
} | go | {
"resource": ""
} |
q169309 | buildEgressIgnoredIPs | validation | func buildEgressIgnoredIPs(proxyConfig *ecsacs.ProxyConfiguration) []string {
var inputEgressIgnoredIPs []string
if proxyConfig.Properties[egressIgnoredIPs] != nil {
inputEgressIgnoredIPs = strings.Split(*proxyConfig.Properties[egressIgnoredIPs], splitter)
}
// append agent default egress ignored IPs
return appe... | go | {
"resource": ""
} |
q169310 | buildEgressIgnoredPorts | validation | func buildEgressIgnoredPorts(proxyConfig *ecsacs.ProxyConfiguration) []string {
var inputEgressIgnoredPorts []string
if proxyConfig.Properties[egressIgnoredPorts] != nil {
inputEgressIgnoredPorts = strings.Split(*proxyConfig.Properties[egressIgnoredPorts], splitter)
}
return inputEgressIgnoredPorts
} | go | {
"resource": ""
} |
q169311 | appendDefaultEgressIgnoredIPs | validation | func appendDefaultEgressIgnoredIPs(egressIgnoredIPs []string) []string {
hasTaskMetadataEndpointIP := false
hasInstanceMetadataEndpointIP := false
for _, egressIgnoredIP := range egressIgnoredIPs {
if strings.TrimSpace(egressIgnoredIP) == taskMetadataEndpointIP {
hasTaskMetadataEndpointIP = true
}
if string... | go | {
"resource": ""
} |
q169312 | IsInstanceTypeChangedError | validation | func IsInstanceTypeChangedError(err error) bool {
if awserr, ok := err.(awserr.Error); ok {
return strings.Contains(awserr.Message(), InstanceTypeChangedErrorMessage)
}
return false
} | go | {
"resource": ""
} |
q169313 | NewNamedError | validation | func NewNamedError(err error) *DefaultNamedError {
if namedErr, ok := err.(NamedError); ok {
return &DefaultNamedError{Err: namedErr.Error(), Name: namedErr.ErrorName()}
}
return &DefaultNamedError{Err: err.Error()}
} | go | {
"resource": ""
} |
q169314 | Error | validation | func (err *ResourceInitError) Error() string {
return fmt.Sprintf("resource cannot be initialized for task %s: %v", err.taskARN, err.origErr)
} | go | {
"resource": ""
} |
q169315 | BuildLinuxResourceSpec | validation | func (task *Task) BuildLinuxResourceSpec() (specs.LinuxResources, error) {
linuxResourceSpec := specs.LinuxResources{}
// If task level CPU limits are requested, set CPU quota + CPU period
// Else set CPU shares
if task.CPU > 0 {
linuxCPUSpec, err := task.buildExplicitLinuxCPUSpec()
if err != nil {
return s... | go | {
"resource": ""
} |
q169316 | buildExplicitLinuxCPUSpec | validation | func (task *Task) buildExplicitLinuxCPUSpec() (specs.LinuxCPU, error) {
if task.CPU > maxTaskVCPULimit {
return specs.LinuxCPU{},
errors.Errorf("task CPU spec builder: unsupported CPU limits, requested=%f, max-supported=%d",
task.CPU, maxTaskVCPULimit)
}
taskCPUPeriod := uint64(defaultCPUPeriod / time.Micro... | go | {
"resource": ""
} |
q169317 | buildImplicitLinuxCPUSpec | validation | func (task *Task) buildImplicitLinuxCPUSpec() specs.LinuxCPU {
// If task level CPU limits are missing,
// aggregate container CPU shares when present
var taskCPUShares uint64
for _, container := range task.Containers {
if container.CPU > 0 {
taskCPUShares += uint64(container.CPU)
}
}
// If there are are ... | go | {
"resource": ""
} |
q169318 | buildLinuxMemorySpec | validation | func (task *Task) buildLinuxMemorySpec() (specs.LinuxMemory, error) {
// If task memory limit is not present, cgroup parent memory is not set
// If task memory limit is set, ensure that no container
// of this task has a greater request
for _, container := range task.Containers {
containerMemoryLimit := int64(con... | go | {
"resource": ""
} |
q169319 | platformHostConfigOverride | validation | func (task *Task) platformHostConfigOverride(hostConfig *dockercontainer.HostConfig) error {
// Override cgroup parent
return task.overrideCgroupParent(hostConfig)
} | go | {
"resource": ""
} |
q169320 | overrideCgroupParent | validation | func (task *Task) overrideCgroupParent(hostConfig *dockercontainer.HostConfig) error {
task.lock.RLock()
defer task.lock.RUnlock()
if task.MemoryCPULimitsEnabled {
cgroupRoot, err := task.BuildCgroupRoot()
if err != nil {
return errors.Wrapf(err, "task cgroup override: unable to obtain cgroup root for task: %... | go | {
"resource": ""
} |
q169321 | GetMACAddress | validation | func GetMACAddress(ctx context.Context,
timeout time.Duration,
dev string,
netlinkClient netlinkwrapper.NetLink) (string, error) {
retriever := &macAddressRetriever{
dev: dev,
netlinkClient: netlinkClient,
ctx: ctx,
timeout: timeout,
}
return retriever.retrieve()
} | go | {
"resource": ""
} |
q169322 | retrieve | validation | func (retriever *macAddressRetriever) retrieve() (string, error) {
backoff := retry.NewExponentialBackoff(macAddressBackoffMin, macAddressBackoffMax,
macAddressBackoffJitter, macAddressBackoffMultiple)
ctx, cancel := context.WithTimeout(retriever.ctx, retriever.timeout)
defer cancel()
err := retry.RetryWithBacko... | go | {
"resource": ""
} |
q169323 | retrieveOnce | validation | func (retriever *macAddressRetriever) retrieveOnce() error {
dev := filepath.Base(retriever.dev)
link, err := retriever.netlinkClient.LinkByName(dev)
if err != nil {
return apierrors.NewRetriableError(apierrors.NewRetriable(false), err)
}
retriever.macAddress = link.Attrs().HardwareAddr.String()
return nil
} | go | {
"resource": ""
} |
q169324 | IsValidNetworkDevice | validation | func IsValidNetworkDevice(devicePath string) bool {
/*
* DevicePath Samples:
* eth1 -> /devices/pci0000:00/0000:00:05.0/net/eth1
* eth0 -> ../../devices/pci0000:00/0000:00:03.0/net/eth0
* lo -> ../../devices/virtual/net/lo
*/
splitDevLink := strings.SplitN(devicePath, "devices/", 2)
if len(splitDevLink) != 2... | go | {
"resource": ""
} |
q169325 | ReceiveMessage | validation | func (r *eventLogReceiver) ReceiveMessage(message string, level seelog.LogLevel, context seelog.LogContextInterface) error {
switch level {
case seelog.DebugLvl, seelog.InfoLvl:
return eventLog.Info(eventLogID, message)
case seelog.WarnLvl:
return eventLog.Warning(eventLogID, message)
case seelog.ErrorLvl, seel... | go | {
"resource": ""
} |
q169326 | GetAuthorizationToken | validation | func (client *ecrClient) GetAuthorizationToken(registryId string) (*ecrapi.AuthorizationData, error) {
log.Debugf("Calling GetAuthorizationToken for %q", registryId)
output, err := client.sdkClient.GetAuthorizationToken(&ecrapi.GetAuthorizationTokenInput{
RegistryIds: []*string{aws.String(registryId)},
})
if er... | go | {
"resource": ""
} |
q169327 | NewMockEngine | validation | func NewMockEngine(ctrl *gomock.Controller) *MockEngine {
mock := &MockEngine{ctrl: ctrl}
mock.recorder = &MockEngineMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169328 | ContainerDockerStats | validation | func (m *MockEngine) ContainerDockerStats(arg0, arg1 string) (*types.StatsJSON, error) {
ret := m.ctrl.Call(m, "ContainerDockerStats", arg0, arg1)
ret0, _ := ret[0].(*types.StatsJSON)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169329 | ContainerDockerStats | validation | func (mr *MockEngineMockRecorder) ContainerDockerStats(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerDockerStats", reflect.TypeOf((*MockEngine)(nil).ContainerDockerStats), arg0, arg1)
} | go | {
"resource": ""
} |
q169330 | GetInstanceMetrics | validation | func (m *MockEngine) GetInstanceMetrics() (*ecstcs.MetricsMetadata, []*ecstcs.TaskMetric, error) {
ret := m.ctrl.Call(m, "GetInstanceMetrics")
ret0, _ := ret[0].(*ecstcs.MetricsMetadata)
ret1, _ := ret[1].([]*ecstcs.TaskMetric)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | {
"resource": ""
} |
q169331 | GetInstanceMetrics | validation | func (mr *MockEngineMockRecorder) GetInstanceMetrics() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceMetrics", reflect.TypeOf((*MockEngine)(nil).GetInstanceMetrics))
} | go | {
"resource": ""
} |
q169332 | GetTaskHealthMetrics | validation | func (m *MockEngine) GetTaskHealthMetrics() (*ecstcs.HealthMetadata, []*ecstcs.TaskHealth, error) {
ret := m.ctrl.Call(m, "GetTaskHealthMetrics")
ret0, _ := ret[0].(*ecstcs.HealthMetadata)
ret1, _ := ret[1].([]*ecstcs.TaskHealth)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | go | {
"resource": ""
} |
q169333 | RetryWithBackoff | validation | func RetryWithBackoff(backoff Backoff, fn func() error) error {
return RetryWithBackoffCtx(context.Background(), backoff, fn)
} | go | {
"resource": ""
} |
q169334 | RetryWithBackoffCtx | validation | func RetryWithBackoffCtx(ctx context.Context, backoff Backoff, fn func() error) error {
var err error
for {
select {
case <-ctx.Done():
return nil
default:
}
err = fn()
retriableErr, isRetriableErr := err.(apierrors.Retriable)
if err == nil || (isRetriableErr && !retriableErr.Retry()) {
return ... | go | {
"resource": ""
} |
q169335 | RetryNWithBackoff | validation | func RetryNWithBackoff(backoff Backoff, n int, fn func() error) error {
return RetryNWithBackoffCtx(context.Background(), backoff, n, fn)
} | go | {
"resource": ""
} |
q169336 | RetryNWithBackoffCtx | validation | func RetryNWithBackoffCtx(ctx context.Context, backoff Backoff, n int, fn func() error) error {
var err error
RetryWithBackoffCtx(ctx, backoff, func() error {
err = fn()
n--
if n == 0 {
// Break out after n tries
return nil
}
return err
})
return err
} | go | {
"resource": ""
} |
q169337 | AddJitter | validation | func AddJitter(duration time.Duration, jitter time.Duration) time.Duration {
var randJitter int64
if jitter.Nanoseconds() == 0 {
randJitter = 0
} else {
randJitter = rand.Int63n(jitter.Nanoseconds())
}
return time.Duration(duration.Nanoseconds() + randJitter)
} | go | {
"resource": ""
} |
q169338 | NewMockIOUtil | validation | func NewMockIOUtil(ctrl *gomock.Controller) *MockIOUtil {
mock := &MockIOUtil{ctrl: ctrl}
mock.recorder = &MockIOUtilMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169339 | WriteFile | validation | func (m *MockIOUtil) WriteFile(arg0 string, arg1 []byte, arg2 os.FileMode) error {
ret := m.ctrl.Call(m, "WriteFile", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169340 | WriteFile | validation | func (mr *MockIOUtilMockRecorder) WriteFile(arg0, arg1, arg2 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteFile", reflect.TypeOf((*MockIOUtil)(nil).WriteFile), arg0, arg1, arg2)
} | go | {
"resource": ""
} |
q169341 | DescribeECSTagsForInstance | validation | func (c *ClientImpl) DescribeECSTagsForInstance(instanceID string) ([]*ecs.Tag, error) {
describeTagsInput := ec2sdk.DescribeTagsInput{
Filters: []*ec2sdk.Filter{
{
Name: aws.String(ResourceIDFilterName),
Values: []*string{aws.String(instanceID)},
},
{
Name: aws.String(ResourceTypeFilterName... | go | {
"resource": ""
} |
q169342 | TaskContainerStatsHandler | validation | func TaskContainerStatsHandler(state dockerstate.TaskEngineState, statsEngine stats.Engine) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
taskARN, err := getTaskARNByRequest(r, state)
if err != nil {
errResponseJSON, _ := json.Marshal(
fmt.Sprintf("Unable t... | go | {
"resource": ""
} |
q169343 | WriteTaskStatsResponse | validation | func WriteTaskStatsResponse(w http.ResponseWriter,
taskARN string,
state dockerstate.TaskEngineState,
statsEngine stats.Engine) {
taskStatsResponse, err := NewTaskStatsResponse(taskARN, state, statsEngine)
if err != nil {
seelog.Warnf("Unable to get task stats for task '%s': %v", taskARN, err)
errResponseJSON... | go | {
"resource": ""
} |
q169344 | WriteContainerStatsResponse | validation | func WriteContainerStatsResponse(w http.ResponseWriter,
taskARN string,
containerID string,
statsEngine stats.Engine) {
dockerStats, err := statsEngine.ContainerDockerStats(taskARN, containerID)
if err != nil {
errResponseJSON, _ := json.Marshal("Unable to get container stats for: " + containerID)
utils.WriteJ... | go | {
"resource": ""
} |
q169345 | NewTaskResponse | validation | func NewTaskResponse(task *apitask.Task, containerMap map[string]*apicontainer.DockerContainer) *TaskResponse {
containers := []ContainerResponse{}
for _, container := range containerMap {
if container.Container.IsInternal() {
continue
}
containerResponse := NewContainerResponse(container, task.GetTaskENI())... | go | {
"resource": ""
} |
q169346 | NewContainerResponse | validation | func NewContainerResponse(dockerContainer *apicontainer.DockerContainer, eni *apieni.ENI) ContainerResponse {
container := dockerContainer.Container
resp := ContainerResponse{
Name: container.Name,
DockerID: dockerContainer.DockerID,
DockerName: dockerContainer.DockerName,
}
resp.Ports = NewPortBindi... | go | {
"resource": ""
} |
q169347 | NewPortBindingsResponse | validation | func NewPortBindingsResponse(dockerContainer *apicontainer.DockerContainer, eni *apieni.ENI) []PortResponse {
container := dockerContainer.Container
resp := []PortResponse{}
bindings := container.GetKnownPortBindings()
// if KnownPortBindings list is empty, then we use the port mapping
// information that was pa... | go | {
"resource": ""
} |
q169348 | NewVolumesResponse | validation | func NewVolumesResponse(dockerContainer *apicontainer.DockerContainer) []VolumeResponse {
container := dockerContainer.Container
var resp []VolumeResponse
volumes := container.GetVolumes()
for _, volume := range volumes {
volResp := VolumeResponse{
DockerName: volume.Name,
Source: volume.Source,
... | go | {
"resource": ""
} |
q169349 | NewTasksResponse | validation | func NewTasksResponse(state dockerstate.TaskEngineState) *TasksResponse {
allTasks := state.AllTasks()
taskResponses := make([]*TaskResponse, len(allTasks))
for ndx, task := range allTasks {
containerMap, _ := state.ContainerMapByArn(task.Arn)
taskResponses[ndx] = NewTaskResponse(task, containerMap)
}
return ... | go | {
"resource": ""
} |
q169350 | NewPublishMetricsRequest | validation | func NewPublishMetricsRequest(metadata *MetricsMetadata, taskMetrics []*TaskMetric) *PublishMetricsRequest {
return &PublishMetricsRequest{
Metadata: metadata,
TaskMetrics: taskMetrics,
Timestamp: aws.Time(time.Now()),
}
} | go | {
"resource": ""
} |
q169351 | NewPublishHealthMetricsRequest | validation | func NewPublishHealthMetricsRequest(metadata *HealthMetadata, healthMetrics []*TaskHealth) *PublishHealthRequest {
return &PublishHealthRequest{
Metadata: metadata,
Tasks: healthMetrics,
Timestamp: aws.Time(time.Now()),
}
} | go | {
"resource": ""
} |
q169352 | StartListening | validation | func (buffer *InfiniteBuffer) StartListening(ctx context.Context, eventChan <-chan events.Message) {
for {
select {
// If context is cancelled, drain remaining events and return
case <-ctx.Done():
for len(eventChan) > 0 {
event := <-eventChan
go buffer.CopyEvents(&event)
}
return
case event :=... | go | {
"resource": ""
} |
q169353 | CopyEvents | validation | func (buffer *InfiniteBuffer) CopyEvents(event *events.Message) {
if event.ID == "" || event.Type != containerTypeEvent {
return
}
// Only add the events agent is interested
for _, containerEvent := range containerEvents {
if event.Status == containerEvent {
buffer.lock.Lock()
defer buffer.lock.Unlock()
... | go | {
"resource": ""
} |
q169354 | Consume | validation | func (buffer *InfiniteBuffer) Consume(in chan<- *events.Message) {
for {
buffer.lock.Lock()
if len(buffer.events) == 0 {
// Mark the buffer as empty and start waiting for events
buffer.empty = true
buffer.waitForEvent.Add(1)
buffer.lock.Unlock()
buffer.waitForEvent.Wait()
} else {
event := buf... | go | {
"resource": ""
} |
q169355 | ContainerStatsHandler | validation | func ContainerStatsHandler(state dockerstate.TaskEngineState, statsEngine stats.Engine) func(http.ResponseWriter, *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
taskARN, err := getTaskARNByRequest(r, state)
if err != nil {
errResponseJSON, _ := json.Marshal(
fmt.Sprintf("V3 container... | go | {
"resource": ""
} |
q169356 | NewMetricsClient | validation | func NewMetricsClient(api APIType, registry *prometheus.Registry) MetricsClient {
switch api {
case DockerAPI:
return NewGenericMetricsClient(DockerSubsystem, registry)
case TaskEngine:
return NewGenericMetricsClient(TaskEngineSubsystem, registry)
case StateManager:
return NewGenericMetricsClient(StateManager... | go | {
"resource": ""
} |
q169357 | NewMockECRSDK | validation | func NewMockECRSDK(ctrl *gomock.Controller) *MockECRSDK {
mock := &MockECRSDK{ctrl: ctrl}
mock.recorder = &MockECRSDKMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169358 | NewMockECRFactory | validation | func NewMockECRFactory(ctrl *gomock.Controller) *MockECRFactory {
mock := &MockECRFactory{ctrl: ctrl}
mock.recorder = &MockECRFactoryMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169359 | GetClient | validation | func (mr *MockECRFactoryMockRecorder) GetClient(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockECRFactory)(nil).GetClient), arg0)
} | go | {
"resource": ""
} |
q169360 | NewMockECRClient | validation | func NewMockECRClient(ctrl *gomock.Controller) *MockECRClient {
mock := &MockECRClient{ctrl: ctrl}
mock.recorder = &MockECRClientMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169361 | GetCredentialsEventType | validation | func GetCredentialsEventType(roleType string) string {
switch roleType {
case credentials.ApplicationRoleType:
return getCredentialsEventType
case credentials.ExecutionRoleType:
return getCredentialsTaskExecutionEventType
default:
return getCredentialsInvalidRoleTypeEventType
}
} | go | {
"resource": ""
} |
q169362 | NewMockGPUManager | validation | func NewMockGPUManager(ctrl *gomock.Controller) *MockGPUManager {
mock := &MockGPUManager{ctrl: ctrl}
mock.recorder = &MockGPUManagerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169363 | GetDevices | validation | func (m *MockGPUManager) GetDevices() []*ecs.PlatformDevice {
ret := m.ctrl.Call(m, "GetDevices")
ret0, _ := ret[0].([]*ecs.PlatformDevice)
return ret0
} | go | {
"resource": ""
} |
q169364 | GetGPUIDsUnsafe | validation | func (m *MockGPUManager) GetGPUIDsUnsafe() []string {
ret := m.ctrl.Call(m, "GetGPUIDsUnsafe")
ret0, _ := ret[0].([]string)
return ret0
} | go | {
"resource": ""
} |
q169365 | SetDevices | validation | func (mr *MockGPUManagerMockRecorder) SetDevices() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDevices", reflect.TypeOf((*MockGPUManager)(nil).SetDevices))
} | go | {
"resource": ""
} |
q169366 | SetDriverVersion | validation | func (m *MockGPUManager) SetDriverVersion(arg0 string) {
m.ctrl.Call(m, "SetDriverVersion", arg0)
} | go | {
"resource": ""
} |
q169367 | SetDriverVersion | validation | func (mr *MockGPUManagerMockRecorder) SetDriverVersion(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDriverVersion", reflect.TypeOf((*MockGPUManager)(nil).SetDriverVersion), arg0)
} | go | {
"resource": ""
} |
q169368 | SetGPUIDs | validation | func (m *MockGPUManager) SetGPUIDs(arg0 []string) {
m.ctrl.Call(m, "SetGPUIDs", arg0)
} | go | {
"resource": ""
} |
q169369 | SetRuntimeVersion | validation | func (m *MockGPUManager) SetRuntimeVersion(arg0 string) {
m.ctrl.Call(m, "SetRuntimeVersion", arg0)
} | go | {
"resource": ""
} |
q169370 | NewMockRoundTripper | validation | func NewMockRoundTripper(ctrl *gomock.Controller) *MockRoundTripper {
mock := &MockRoundTripper{ctrl: ctrl}
mock.recorder = &MockRoundTripperMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169371 | RoundTrip | validation | func (m *MockRoundTripper) RoundTrip(arg0 *http.Request) (*http.Response, error) {
ret := m.ctrl.Call(m, "RoundTrip", arg0)
ret0, _ := ret[0].(*http.Response)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169372 | RoundTrip | validation | func (mr *MockRoundTripperMockRecorder) RoundTrip(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTrip", reflect.TypeOf((*MockRoundTripper)(nil).RoundTrip), arg0)
} | go | {
"resource": ""
} |
q169373 | NewMockNetLink | validation | func NewMockNetLink(ctrl *gomock.Controller) *MockNetLink {
mock := &MockNetLink{ctrl: ctrl}
mock.recorder = &MockNetLinkMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169374 | LinkByName | validation | func (m *MockNetLink) LinkByName(arg0 string) (netlink.Link, error) {
ret := m.ctrl.Call(m, "LinkByName", arg0)
ret0, _ := ret[0].(netlink.Link)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169375 | LinkByName | validation | func (mr *MockNetLinkMockRecorder) LinkByName(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkByName", reflect.TypeOf((*MockNetLink)(nil).LinkByName), arg0)
} | go | {
"resource": ""
} |
q169376 | LinkList | validation | func (m *MockNetLink) LinkList() ([]netlink.Link, error) {
ret := m.ctrl.Call(m, "LinkList")
ret0, _ := ret[0].([]netlink.Link)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169377 | LinkList | validation | func (mr *MockNetLinkMockRecorder) LinkList() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkList", reflect.TypeOf((*MockNetLink)(nil).LinkList))
} | go | {
"resource": ""
} |
q169378 | NewMockCNI | validation | func NewMockCNI(ctrl *gomock.Controller) *MockCNI {
mock := &MockCNI{ctrl: ctrl}
mock.recorder = &MockCNIMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q169379 | AddNetwork | validation | func (m *MockCNI) AddNetwork(arg0 *libcni.NetworkConfig, arg1 *libcni.RuntimeConf) (types.Result, error) {
ret := m.ctrl.Call(m, "AddNetwork", arg0, arg1)
ret0, _ := ret[0].(types.Result)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169380 | AddNetworkList | validation | func (m *MockCNI) AddNetworkList(arg0 *libcni.NetworkConfigList, arg1 *libcni.RuntimeConf) (types.Result, error) {
ret := m.ctrl.Call(m, "AddNetworkList", arg0, arg1)
ret0, _ := ret[0].(types.Result)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q169381 | DelNetwork | validation | func (m *MockCNI) DelNetwork(arg0 *libcni.NetworkConfig, arg1 *libcni.RuntimeConf) error {
ret := m.ctrl.Call(m, "DelNetwork", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169382 | DelNetwork | validation | func (mr *MockCNIMockRecorder) DelNetwork(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DelNetwork", reflect.TypeOf((*MockCNI)(nil).DelNetwork), arg0, arg1)
} | go | {
"resource": ""
} |
q169383 | DelNetworkList | validation | func (m *MockCNI) DelNetworkList(arg0 *libcni.NetworkConfigList, arg1 *libcni.RuntimeConf) error {
ret := m.ctrl.Call(m, "DelNetworkList", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q169384 | NewLRUCache | validation | func NewLRUCache(size int, ttl time.Duration) Cache {
lru := &lruCache{size: size,
ttl: ttl,
cache: make(map[string]*entry),
evictList: list.New(),
}
return lru
} | go | {
"resource": ""
} |
q169385 | Get | validation | func (lru *lruCache) Get(key string) (Value, bool) {
lru.Lock()
defer lru.Unlock()
entry, ok := lru.cache[key]
if !ok {
return nil, false
}
ok = lru.evictStale(entry, key)
if !ok {
return nil, false
}
lru.updateAccessed(key)
return entry.value, true
} | go | {
"resource": ""
} |
q169386 | Set | validation | func (lru *lruCache) Set(key string, value Value) {
lru.Lock()
defer lru.Unlock()
lru.cache[key] = &entry{value: value, added: time.Now()}
// Remove from the evict list if an entry already existed
lru.removeFromEvictList(key)
lru.evictList.PushBack(key)
lru.purgeSize()
} | go | {
"resource": ""
} |
q169387 | Delete | validation | func (lru *lruCache) Delete(key string) {
lru.Lock()
defer lru.Unlock()
lru.removeFromEvictList(key)
delete(lru.cache, key)
} | go | {
"resource": ""
} |
q169388 | StartTimer | validation | func (eni *ENIAttachment) StartTimer(timeoutFunc func()) error {
eni.guard.Lock()
defer eni.guard.Unlock()
if eni.ackTimer != nil {
// The timer has already been initialized, do nothing
return nil
}
now := time.Now()
duration := eni.ExpiresAt.Sub(now)
if duration <= 0 {
return errors.Errorf("eni attachmen... | go | {
"resource": ""
} |
q169389 | IsSent | validation | func (eni *ENIAttachment) IsSent() bool {
eni.guard.RLock()
defer eni.guard.RUnlock()
return eni.AttachStatusSent
} | go | {
"resource": ""
} |
q169390 | SetSentStatus | validation | func (eni *ENIAttachment) SetSentStatus() {
eni.guard.Lock()
defer eni.guard.Unlock()
eni.AttachStatusSent = true
} | go | {
"resource": ""
} |
q169391 | StopAckTimer | validation | func (eni *ENIAttachment) StopAckTimer() {
eni.guard.Lock()
defer eni.guard.Unlock()
eni.ackTimer.Stop()
} | go | {
"resource": ""
} |
q169392 | HasExpired | validation | func (eni *ENIAttachment) HasExpired() bool {
eni.guard.RLock()
defer eni.guard.RUnlock()
return time.Now().After(eni.ExpiresAt)
} | go | {
"resource": ""
} |
q169393 | String | validation | func (eni *ENIAttachment) String() string {
eni.guard.RLock()
defer eni.guard.RUnlock()
return eni.stringUnsafe()
} | go | {
"resource": ""
} |
q169394 | stringUnsafe | validation | func (eni *ENIAttachment) stringUnsafe() string {
return fmt.Sprintf(
"ENI Attachment: task=%s;attachment=%s;attachmentSent=%t;mac=%s;status=%s;expiresAt=%s",
eni.TaskARN, eni.AttachmentARN, eni.AttachStatusSent, eni.MACAddress, eni.Status.String(), eni.ExpiresAt.String())
} | go | {
"resource": ""
} |
q169395 | StartMetricsSession | validation | func StartMetricsSession(params *TelemetrySessionParams) {
ok, err := params.isContainerHealthMetricsDisabled()
if err != nil {
seelog.Warnf("Error starting metrics session: %v", err)
return
}
if ok {
seelog.Warnf("Metrics were disabled, not starting the telemetry session")
return
}
err = params.StatsEng... | go | {
"resource": ""
} |
q169396 | StartSession | validation | func StartSession(params *TelemetrySessionParams, statsEngine stats.Engine) error {
backoff := retry.NewExponentialBackoff(time.Second, 1*time.Minute, 0.2, 2)
for {
tcsError := startTelemetrySession(params, statsEngine)
if tcsError == nil || tcsError == io.EOF {
seelog.Info("TCS Websocket connection closed for... | go | {
"resource": ""
} |
q169397 | heartbeatHandler | validation | func heartbeatHandler(timer *time.Timer) func(*ecstcs.HeartbeatMessage) {
return func(*ecstcs.HeartbeatMessage) {
seelog.Debug("Received HeartbeatMessage from tcs")
timer.Reset(retry.AddJitter(defaultHeartbeatTimeout, defaultHeartbeatJitter))
}
} | go | {
"resource": ""
} |
q169398 | ackPublishMetricHandler | validation | func ackPublishMetricHandler(timer *time.Timer) func(*ecstcs.AckPublishMetric) {
return func(*ecstcs.AckPublishMetric) {
seelog.Debug("Received AckPublishMetric from tcs")
timer.Reset(retry.AddJitter(defaultHeartbeatTimeout, defaultHeartbeatJitter))
}
} | go | {
"resource": ""
} |
q169399 | ackPublishHealthMetricHandler | validation | func ackPublishHealthMetricHandler(timer *time.Timer) func(*ecstcs.AckPublishHealth) {
return func(*ecstcs.AckPublishHealth) {
seelog.Debug("Received ACKPublishHealth from tcs")
timer.Reset(retry.AddJitter(defaultHeartbeatTimeout, defaultHeartbeatJitter))
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.