_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168400 | parseInt | validation | func parseInt(s string) (int64, error) {
if s == "" {
return 0, nil
}
result, err := strconv.ParseInt(s, 10, 64)
if err != nil {
return 0, errors.Wrap(err, "parseInt")
}
return result, nil
} | go | {
"resource": ""
} |
q168401 | parseJSON | validation | func parseJSON(s string) (interface{}, error) {
if s == "" {
return map[string]interface{}{}, nil
}
var data interface{}
if err := json.Unmarshal([]byte(s), &data); err != nil {
return nil, err
}
return data, nil
} | go | {
"resource": ""
} |
q168402 | parseUint | validation | func parseUint(s string) (uint64, error) {
if s == "" {
return 0, nil
}
result, err := strconv.ParseUint(s, 10, 64)
if err != nil {
return 0, errors.Wrap(err, "parseUint")
}
return result, nil
} | go | {
"resource": ""
} |
q168403 | plugin | validation | func plugin(name string, args ...string) (string, error) {
if name == "" {
return "", nil
}
stdout, stderr := new(bytes.Buffer), new(bytes.Buffer)
// Strip and trim each arg or else some plugins get confused with the newline
// characters
jsons := make([]string, 0, len(args))
for _, arg := range args {
if ... | go | {
"resource": ""
} |
q168404 | replaceAll | validation | func replaceAll(f, t, s string) (string, error) {
return strings.Replace(s, f, t, -1), nil
} | go | {
"resource": ""
} |
q168405 | regexReplaceAll | validation | func regexReplaceAll(re, pl, s string) (string, error) {
compiled, err := regexp.Compile(re)
if err != nil {
return "", err
}
return compiled.ReplaceAllString(s, pl), nil
} | go | {
"resource": ""
} |
q168406 | regexMatch | validation | func regexMatch(re, s string) (bool, error) {
compiled, err := regexp.Compile(re)
if err != nil {
return false, err
}
return compiled.MatchString(s), nil
} | go | {
"resource": ""
} |
q168407 | split | validation | func split(sep, s string) ([]string, error) {
s = strings.TrimSpace(s)
if s == "" {
return []string{}, nil
}
return strings.Split(s, sep), nil
} | go | {
"resource": ""
} |
q168408 | timestamp | validation | func timestamp(s ...string) (string, error) {
switch len(s) {
case 0:
return now().Format(time.RFC3339), nil
case 1:
if s[0] == "unix" {
return strconv.FormatInt(now().Unix(), 10), nil
}
return now().Format(s[0]), nil
default:
return "", fmt.Errorf("timestamp: wrong number of arguments, expected 0 or 1... | go | {
"resource": ""
} |
q168409 | toJSON | validation | func toJSON(i interface{}) (string, error) {
result, err := json.Marshal(i)
if err != nil {
return "", errors.Wrap(err, "toJSON")
}
return string(bytes.TrimSpace(result)), err
} | go | {
"resource": ""
} |
q168410 | toJSONPretty | validation | func toJSONPretty(m map[string]interface{}) (string, error) {
result, err := json.MarshalIndent(m, "", " ")
if err != nil {
return "", errors.Wrap(err, "toJSONPretty")
}
return string(bytes.TrimSpace(result)), err
} | go | {
"resource": ""
} |
q168411 | toYAML | validation | func toYAML(m map[string]interface{}) (string, error) {
result, err := yaml.Marshal(m)
if err != nil {
return "", errors.Wrap(err, "toYAML")
}
return string(bytes.TrimSpace(result)), nil
} | go | {
"resource": ""
} |
q168412 | toTOML | validation | func toTOML(m map[string]interface{}) (string, error) {
buf := bytes.NewBuffer([]byte{})
enc := toml.NewEncoder(buf)
if err := enc.Encode(m); err != nil {
return "", errors.Wrap(err, "toTOML")
}
result, err := ioutil.ReadAll(buf)
if err != nil {
return "", errors.Wrap(err, "toTOML")
}
return string(bytes.Tr... | go | {
"resource": ""
} |
q168413 | add | validation | func add(b, a interface{}) (interface{}, error) {
av := reflect.ValueOf(a)
bv := reflect.ValueOf(b)
switch av.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Int() ... | go | {
"resource": ""
} |
q168414 | modulo | validation | func modulo(b, a interface{}) (interface{}, error) {
av := reflect.ValueOf(a)
bv := reflect.ValueOf(b)
switch av.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch bv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return av.Int... | go | {
"resource": ""
} |
q168415 | Expired | validation | func (item Item) Expired() bool {
if item.Expiration == 0 {
return false
}
return time.Now().UnixNano() > item.Expiration
} | go | {
"resource": ""
} |
q168416 | SetDefault | validation | func (c *cache) SetDefault(k string, x interface{}) {
c.Set(k, x, DefaultExpiration)
} | go | {
"resource": ""
} |
q168417 | Add | validation | func (c *cache) Add(k string, x interface{}, d time.Duration) error {
c.mu.Lock()
_, found := c.get(k)
if found {
c.mu.Unlock()
return fmt.Errorf("Item %s already exists", k)
}
c.set(k, x, d)
c.mu.Unlock()
return nil
} | go | {
"resource": ""
} |
q168418 | Get | validation | func (c *cache) Get(k string) (interface{}, bool) {
c.mu.RLock()
// "Inlining" of get and Expired
item, found := c.items[k]
if !found {
c.mu.RUnlock()
return nil, false
}
if item.Expiration > 0 {
if time.Now().UnixNano() > item.Expiration {
c.mu.RUnlock()
return nil, false
}
}
c.mu.RUnlock()
retu... | go | {
"resource": ""
} |
q168419 | IncrementInt | validation | func (c *cache) IncrementInt(k string, n int) (int, error) {
c.mu.Lock()
v, found := c.items[k]
if !found || v.Expired() {
c.mu.Unlock()
return 0, fmt.Errorf("Item %s not found", k)
}
rv, ok := v.Object.(int)
if !ok {
c.mu.Unlock()
return 0, fmt.Errorf("The value for %s is not an int", k)
}
nv := rv + n... | go | {
"resource": ""
} |
q168420 | Delete | validation | func (c *cache) Delete(k string) {
c.mu.Lock()
v, evicted := c.delete(k)
c.mu.Unlock()
if evicted {
c.onEvicted(k, v)
}
} | go | {
"resource": ""
} |
q168421 | DeleteExpired | validation | func (c *cache) DeleteExpired() {
var evictedItems []keyAndValue
now := time.Now().UnixNano()
c.mu.Lock()
for k, v := range c.items {
// "Inlining" of expired
if v.Expiration > 0 && now > v.Expiration {
ov, evicted := c.delete(k)
if evicted {
evictedItems = append(evictedItems, keyAndValue{k, ov})
... | go | {
"resource": ""
} |
q168422 | Items | validation | func (c *cache) Items() map[string]Item {
c.mu.RLock()
defer c.mu.RUnlock()
m := make(map[string]Item, len(c.items))
now := time.Now().UnixNano()
for k, v := range c.items {
// "Inlining" of Expired
if v.Expiration > 0 {
if now > v.Expiration {
continue
}
}
m[k] = v
}
return m
} | go | {
"resource": ""
} |
q168423 | ItemCount | validation | func (c *cache) ItemCount() int {
c.mu.RLock()
n := len(c.items)
c.mu.RUnlock()
return n
} | go | {
"resource": ""
} |
q168424 | Flush | validation | func (c *cache) Flush() {
c.mu.Lock()
c.items = map[string]Item{}
c.mu.Unlock()
} | go | {
"resource": ""
} |
q168425 | djb33 | validation | func djb33(seed uint32, k string) uint32 {
var (
l = uint32(len(k))
d = 5381 + seed + l
i = uint32(0)
)
// Why is all this 5x faster than a for loop?
if l >= 4 {
for i < l-4 {
d = (d * 33) ^ uint32(k[i])
d = (d * 33) ^ uint32(k[i+1])
d = (d * 33) ^ uint32(k[i+2])
d = (d * 33) ^ uint32(k[i+3])
... | go | {
"resource": ""
} |
q168426 | LinkByName | validation | func (NetLinkClient) LinkByName(name string) (netlink.Link, error) {
return netlink.LinkByName(name)
} | go | {
"resource": ""
} |
q168427 | NewMockTaskEngine | validation | func NewMockTaskEngine(ctrl *gomock.Controller) *MockTaskEngine {
mock := &MockTaskEngine{ctrl: ctrl}
mock.recorder = &MockTaskEngineMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168428 | AddTask | validation | func (mr *MockTaskEngineMockRecorder) AddTask(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTask", reflect.TypeOf((*MockTaskEngine)(nil).AddTask), arg0)
} | go | {
"resource": ""
} |
q168429 | GetTaskByArn | validation | func (m *MockTaskEngine) GetTaskByArn(arg0 string) (*task.Task, bool) {
ret := m.ctrl.Call(m, "GetTaskByArn", arg0)
ret0, _ := ret[0].(*task.Task)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q168430 | ListTasks | validation | func (m *MockTaskEngine) ListTasks() ([]*task.Task, error) {
ret := m.ctrl.Call(m, "ListTasks")
ret0, _ := ret[0].([]*task.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168431 | MarshalJSON | validation | func (m *MockTaskEngine) MarshalJSON() ([]byte, error) {
ret := m.ctrl.Call(m, "MarshalJSON")
ret0, _ := ret[0].([]byte)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168432 | MustInit | validation | func (m *MockTaskEngine) MustInit(arg0 context.Context) {
m.ctrl.Call(m, "MustInit", arg0)
} | go | {
"resource": ""
} |
q168433 | StateChangeEvents | validation | func (m *MockTaskEngine) StateChangeEvents() chan statechange.Event {
ret := m.ctrl.Call(m, "StateChangeEvents")
ret0, _ := ret[0].(chan statechange.Event)
return ret0
} | go | {
"resource": ""
} |
q168434 | Version | validation | func (mr *MockTaskEngineMockRecorder) Version() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockTaskEngine)(nil).Version))
} | go | {
"resource": ""
} |
q168435 | NewMockImageManager | validation | func NewMockImageManager(ctrl *gomock.Controller) *MockImageManager {
mock := &MockImageManager{ctrl: ctrl}
mock.recorder = &MockImageManagerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168436 | AddAllImageStates | validation | func (m *MockImageManager) AddAllImageStates(arg0 []*image.ImageState) {
m.ctrl.Call(m, "AddAllImageStates", arg0)
} | go | {
"resource": ""
} |
q168437 | AddAllImageStates | validation | func (mr *MockImageManagerMockRecorder) AddAllImageStates(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAllImageStates", reflect.TypeOf((*MockImageManager)(nil).AddAllImageStates), arg0)
} | go | {
"resource": ""
} |
q168438 | GetImageStateFromImageName | validation | func (m *MockImageManager) GetImageStateFromImageName(arg0 string) (*image.ImageState, bool) {
ret := m.ctrl.Call(m, "GetImageStateFromImageName", arg0)
ret0, _ := ret[0].(*image.ImageState)
ret1, _ := ret[1].(bool)
return ret0, ret1
} | go | {
"resource": ""
} |
q168439 | RecordContainerReference | validation | func (m *MockImageManager) RecordContainerReference(arg0 *container.Container) error {
ret := m.ctrl.Call(m, "RecordContainerReference", arg0)
ret0, _ := ret[0].(error)
return ret0
} | go | {
"resource": ""
} |
q168440 | StartImageCleanupProcess | validation | func (m *MockImageManager) StartImageCleanupProcess(arg0 context.Context) {
m.ctrl.Call(m, "StartImageCleanupProcess", arg0)
} | go | {
"resource": ""
} |
q168441 | NewEC2MetadataClient | validation | func NewEC2MetadataClient(client HttpClient) EC2MetadataClient {
if client == nil {
return &ec2MetadataClientImpl{
client: ec2metadata.New(
session.New(), aws.NewConfig().WithMaxRetries(metadataRetries)),
}
} else {
return &ec2MetadataClientImpl{client: client}
}
} | go | {
"resource": ""
} |
q168442 | DefaultCredentials | validation | func (c *ec2MetadataClientImpl) DefaultCredentials() (*RoleCredentials, error) {
securityCredential, err := c.client.GetMetadata(SecurityCrednetialsResource)
if err != nil {
return nil, err
}
securityCredentialList := strings.Split(strings.TrimSpace(securityCredential), "\n")
if len(securityCredentialList) == 0... | go | {
"resource": ""
} |
q168443 | GetDynamicData | validation | func (c *ec2MetadataClientImpl) GetDynamicData(path string) (string, error) {
return c.client.GetDynamicData(path)
} | go | {
"resource": ""
} |
q168444 | GetMetadata | validation | func (c *ec2MetadataClientImpl) GetMetadata(path string) (string, error) {
return c.client.GetMetadata(path)
} | go | {
"resource": ""
} |
q168445 | VPCID | validation | func (c *ec2MetadataClientImpl) VPCID(mac string) (string, error) {
return c.client.GetMetadata(fmt.Sprintf(VPCIDResourceFormat, mac))
} | go | {
"resource": ""
} |
q168446 | SubnetID | validation | func (c *ec2MetadataClientImpl) SubnetID(mac string) (string, error) {
return c.client.GetMetadata(fmt.Sprintf(SubnetIDResourceFormat, mac))
} | go | {
"resource": ""
} |
q168447 | newRefreshCredentialsHandler | validation | func newRefreshCredentialsHandler(ctx context.Context, cluster string, containerInstanceArn string, acsClient wsclient.ClientServer, credentialsManager credentials.Manager, taskEngine engine.TaskEngine) refreshCredentialsHandler {
// Create a cancelable context from the parent context
derivedContext, cancel := contex... | go | {
"resource": ""
} |
q168448 | handlerFunc | validation | func (refreshHandler *refreshCredentialsHandler) handlerFunc() func(message *ecsacs.IAMRoleCredentialsMessage) {
// return a function that just enqueues IAMRoleCredentials messages into the message buffer
return func(message *ecsacs.IAMRoleCredentialsMessage) {
refreshHandler.messageBuffer <- message
}
} | go | {
"resource": ""
} |
q168449 | ackMessage | validation | func (refreshHandler *refreshCredentialsHandler) ackMessage(ack *ecsacs.IAMRoleCredentialsAckRequest) {
err := refreshHandler.acsClient.MakeRequest(ack)
if err != nil {
seelog.Warnf("Error 'ack'ing request with messageID: %s, error: %v", aws.StringValue(ack.MessageId), err)
}
seelog.Debugf("Acking credentials mes... | go | {
"resource": ""
} |
q168450 | handleMessages | validation | func (refreshHandler *refreshCredentialsHandler) handleMessages() {
for {
select {
case message := <-refreshHandler.messageBuffer:
refreshHandler.handleSingleMessage(message)
case <-refreshHandler.ctx.Done():
return
}
}
} | go | {
"resource": ""
} |
q168451 | handleSingleMessage | validation | func (refreshHandler *refreshCredentialsHandler) handleSingleMessage(message *ecsacs.IAMRoleCredentialsMessage) error {
// Validate fields in the message
err := validateIAMRoleCredentialsMessage(message)
if err != nil {
seelog.Errorf("Error validating credentials message: %v", err)
return err
}
taskArn := aws.... | go | {
"resource": ""
} |
q168452 | validRoleType | validation | func validRoleType(roleType string) bool {
switch roleType {
case credentials.ApplicationRoleType:
return true
case credentials.ExecutionRoleType:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q168453 | newPayloadRequestHandler | validation | func newPayloadRequestHandler(
ctx context.Context,
taskEngine engine.TaskEngine,
ecsClient api.ECSClient,
cluster string,
containerInstanceArn string,
acsClient wsclient.ClientServer,
saver statemanager.Saver,
refreshHandler refreshCredentialsHandler,
credentialsManager credentials.Manager,
taskHandler *even... | go | {
"resource": ""
} |
q168454 | handlerFunc | validation | func (payloadHandler *payloadRequestHandler) handlerFunc() func(payload *ecsacs.PayloadMessage) {
// return a function that just enqueues PayloadMessages into the message buffer
return func(payload *ecsacs.PayloadMessage) {
payloadHandler.messageBuffer <- payload
}
} | go | {
"resource": ""
} |
q168455 | ackMessageId | validation | func (payloadHandler *payloadRequestHandler) ackMessageId(messageID string) {
seelog.Debugf("Acking payload message id: %s", messageID)
err := payloadHandler.acsClient.MakeRequest(&ecsacs.AckRequest{
Cluster: aws.String(payloadHandler.cluster),
ContainerInstance: aws.String(payloadHandler.containerInsta... | go | {
"resource": ""
} |
q168456 | handleMessages | validation | func (payloadHandler *payloadRequestHandler) handleMessages() {
for {
select {
case payload := <-payloadHandler.messageBuffer:
payloadHandler.handleSingleMessage(payload)
case <-payloadHandler.ctx.Done():
return
}
}
} | go | {
"resource": ""
} |
q168457 | handleSingleMessage | validation | func (payloadHandler *payloadRequestHandler) handleSingleMessage(payload *ecsacs.PayloadMessage) error {
if aws.StringValue(payload.MessageId) == "" {
seelog.Criticalf("Received a payload with no message id")
return fmt.Errorf("received a payload with no message id")
}
seelog.Debugf("Received payload message, me... | go | {
"resource": ""
} |
q168458 | addPayloadTasks | validation | func (payloadHandler *payloadRequestHandler) addPayloadTasks(payload *ecsacs.PayloadMessage) ([]*ecsacs.IAMRoleCredentialsAckRequest, bool) {
// verify that we were able to work with all tasks in this payload so we know whether to ack the whole thing or not
allTasksOK := true
validTasks := make([]*apitask.Task, 0, ... | go | {
"resource": ""
} |
q168459 | addTasks | validation | func (payloadHandler *payloadRequestHandler) addTasks(payload *ecsacs.PayloadMessage, tasks []*apitask.Task, skipAddTask skipAddTaskComparatorFunc) ([]*ecsacs.IAMRoleCredentialsAckRequest, bool) {
allTasksOK := true
var credentialsAcks []*ecsacs.IAMRoleCredentialsAckRequest
for _, task := range tasks {
if skipAddT... | go | {
"resource": ""
} |
q168460 | handleUnrecognizedTask | validation | func (payloadHandler *payloadRequestHandler) handleUnrecognizedTask(task *ecsacs.Task, err error, payload *ecsacs.PayloadMessage) {
seelog.Warnf("Received unexpected acs message, messageID: %s, task: %v, err: %v",
aws.StringValue(payload.MessageId), aws.StringValue(task.Arn), err)
if aws.StringValue(task.Arn) == "... | go | {
"resource": ""
} |
q168461 | v2HandlersSetup | validation | func v2HandlersSetup(muxRouter *mux.Router,
state dockerstate.TaskEngineState,
ecsClient api.ECSClient,
statsEngine stats.Engine,
cluster string,
credentialsManager credentials.Manager,
auditLogger audit.AuditLogger,
availabilityZone string,
containerInstanceArn string) {
muxRouter.HandleFunc(v2.CredentialsPat... | go | {
"resource": ""
} |
q168462 | v3HandlersSetup | validation | func v3HandlersSetup(muxRouter *mux.Router,
state dockerstate.TaskEngineState,
ecsClient api.ECSClient,
statsEngine stats.Engine,
cluster string,
availabilityZone string,
containerInstanceArn string) {
muxRouter.HandleFunc(v3.ContainerMetadataPath, v3.ContainerMetadataHandler(state))
muxRouter.HandleFunc(v3.Tas... | go | {
"resource": ""
} |
q168463 | NewMockProvider | validation | func NewMockProvider(ctrl *gomock.Controller) *MockProvider {
mock := &MockProvider{ctrl: ctrl}
mock.recorder = &MockProviderMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168464 | IsExpired | validation | func (m *MockProvider) IsExpired() bool {
ret := m.ctrl.Call(m, "IsExpired")
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q168465 | IsExpired | validation | func (mr *MockProviderMockRecorder) IsExpired() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExpired", reflect.TypeOf((*MockProvider)(nil).IsExpired))
} | go | {
"resource": ""
} |
q168466 | Retrieve | validation | func (m *MockProvider) Retrieve() (credentials.Value, error) {
ret := m.ctrl.Call(m, "Retrieve")
ret0, _ := ret[0].(credentials.Value)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168467 | NewMockContainerMetadataResolver | validation | func NewMockContainerMetadataResolver(ctrl *gomock.Controller) *MockContainerMetadataResolver {
mock := &MockContainerMetadataResolver{ctrl: ctrl}
mock.recorder = &MockContainerMetadataResolverMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168468 | ResolveContainer | validation | func (m *MockContainerMetadataResolver) ResolveContainer(arg0 string) (*container.DockerContainer, error) {
ret := m.ctrl.Call(m, "ResolveContainer", arg0)
ret0, _ := ret[0].(*container.DockerContainer)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168469 | ResolveContainer | validation | func (mr *MockContainerMetadataResolverMockRecorder) ResolveContainer(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveContainer", reflect.TypeOf((*MockContainerMetadataResolver)(nil).ResolveContainer), arg0)
} | go | {
"resource": ""
} |
q168470 | ResolveTask | validation | func (m *MockContainerMetadataResolver) ResolveTask(arg0 string) (*task.Task, error) {
ret := m.ctrl.Call(m, "ResolveTask", arg0)
ret0, _ := ret[0].(*task.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q168471 | NewTaskResponse | validation | func NewTaskResponse(taskARN string,
state dockerstate.TaskEngineState,
ecsClient api.ECSClient,
cluster string,
az string,
containerInstanceArn string,
propagateTags bool) (*TaskResponse, error) {
task, ok := state.TaskByArn(taskARN)
if !ok {
return nil, errors.Errorf("v2 task response: unable to find task '... | go | {
"resource": ""
} |
q168472 | NewContainerResponse | validation | func NewContainerResponse(containerID string,
state dockerstate.TaskEngineState) (*ContainerResponse, error) {
dockerContainer, ok := state.ContainerByID(containerID)
if !ok {
return nil, errors.Errorf(
"v2 container response: unable to find container '%s'", containerID)
}
task, ok := state.TaskByID(container... | go | {
"resource": ""
} |
q168473 | New | validation | func New(arguments []string) (*Args, error) {
flagset := flag.NewFlagSet("Amazon ECS Agent", flag.ContinueOnError)
args := &Args{
Version: flagset.Bool(versionFlagName, false, versionUsage),
LogLevel: flagset.String(logLevelFlagName, "", logLevelUsage),
AcceptInsecureCert: flagset.Bo... | go | {
"resource": ""
} |
q168474 | DefaultConfig | validation | func DefaultConfig() Config {
programData := utils.DefaultIfBlank(os.Getenv("ProgramData"), `C:\ProgramData`)
ecsRoot := filepath.Join(programData, "Amazon", "ECS")
dataDir := filepath.Join(ecsRoot, "data")
platformVariables := PlatformVariables{
CPUUnbounded: false,
}
return Config{
DockerEndpoint: "npipe://... | go | {
"resource": ""
} |
q168475 | New | validation | func New(timeout time.Duration, insecureSkipVerify bool) *http.Client {
// Transport is the transport requests will be made over
// Note, these defaults are taken from the golang http library. We do not
// explicitly do not use theirs to avoid changing their behavior.
transport := &http.Transport{
Proxy: http.Pro... | go | {
"resource": ""
} |
q168476 | RemoveFromTaskArray | validation | func RemoveFromTaskArray(arr []*Task, ndx int) []*Task {
if ndx < 0 || ndx >= len(arr) {
return arr
}
return append(arr[0:ndx], arr[ndx+1:]...)
} | go | {
"resource": ""
} |
q168477 | adjustForPlatform | validation | func (task *Task) adjustForPlatform(cfg *config.Config) {
task.downcaseAllVolumePaths()
platformFields := PlatformFields{
CpuUnbounded: cfg.PlatformVariables.CPUUnbounded,
}
task.PlatformFields = platformFields
} | go | {
"resource": ""
} |
q168478 | platformHostConfigOverride | validation | func (task *Task) platformHostConfigOverride(hostConfig *dockercontainer.HostConfig) error {
// Convert the CPUShares to CPUPercent
hostConfig.CPUPercent = hostConfig.CPUShares * percentageFactor / int64(cpuShareScaleFactor)
if hostConfig.CPUPercent == 0 && hostConfig.CPUShares != 0 {
// if CPU percent is too low,... | go | {
"resource": ""
} |
q168479 | String | validation | func (eni *ENIAttachmentStatus) String() string {
for k, v := range eniAttachmentStatusMap {
if v == *eni {
return k
}
}
return "NONE"
} | go | {
"resource": ""
} |
q168480 | _main | validation | func _main() int {
var typesOnly bool
flag.BoolVar(&typesOnly, "typesOnly", false, "only generate types")
flag.Parse()
apiFile := "./api/api-2.json"
var err error
if typesOnly {
err = genTypesOnlyAPI(apiFile)
} else {
err = genFull(apiFile)
}
if err != nil {
fmt.Println(err)
return 1
}
return 0
} | go | {
"resource": ""
} |
q168481 | RetryRules | validation | func (retrier *oneDayRetrier) RetryRules(r *request.Request) time.Duration {
// This logic is the same as the default retrier, but duplicated here such
// that upstream changes do not invalidate the math done above.
if r.RetryCount <= submitStateChangeInitialRetries {
delay := int(math.Pow(2, float64(r.RetryCount)... | go | {
"resource": ""
} |
q168482 | NewMockTime | validation | func NewMockTime(ctrl *gomock.Controller) *MockTime {
mock := &MockTime{ctrl: ctrl}
mock.recorder = &MockTimeMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168483 | After | validation | func (m *MockTime) After(arg0 time.Duration) <-chan time.Time {
ret := m.ctrl.Call(m, "After", arg0)
ret0, _ := ret[0].(<-chan time.Time)
return ret0
} | go | {
"resource": ""
} |
q168484 | AfterFunc | validation | func (m *MockTime) AfterFunc(arg0 time.Duration, arg1 func()) ttime.Timer {
ret := m.ctrl.Call(m, "AfterFunc", arg0, arg1)
ret0, _ := ret[0].(ttime.Timer)
return ret0
} | go | {
"resource": ""
} |
q168485 | Now | validation | func (m *MockTime) Now() time.Time {
ret := m.ctrl.Call(m, "Now")
ret0, _ := ret[0].(time.Time)
return ret0
} | go | {
"resource": ""
} |
q168486 | Now | validation | func (mr *MockTimeMockRecorder) Now() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Now", reflect.TypeOf((*MockTime)(nil).Now))
} | go | {
"resource": ""
} |
q168487 | Sleep | validation | func (m *MockTime) Sleep(arg0 time.Duration) {
m.ctrl.Call(m, "Sleep", arg0)
} | go | {
"resource": ""
} |
q168488 | Sleep | validation | func (mr *MockTimeMockRecorder) Sleep(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sleep", reflect.TypeOf((*MockTime)(nil).Sleep), arg0)
} | go | {
"resource": ""
} |
q168489 | NewMockTimer | validation | func NewMockTimer(ctrl *gomock.Controller) *MockTimer {
mock := &MockTimer{ctrl: ctrl}
mock.recorder = &MockTimerMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q168490 | Reset | validation | func (m *MockTimer) Reset(arg0 time.Duration) bool {
ret := m.ctrl.Call(m, "Reset", arg0)
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q168491 | Reset | validation | func (mr *MockTimerMockRecorder) Reset(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTimer)(nil).Reset), arg0)
} | go | {
"resource": ""
} |
q168492 | Stop | validation | func (m *MockTimer) Stop() bool {
ret := m.ctrl.Call(m, "Stop")
ret0, _ := ret[0].(bool)
return ret0
} | go | {
"resource": ""
} |
q168493 | Stop | validation | func (mr *MockTimerMockRecorder) Stop() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTimer)(nil).Stop))
} | go | {
"resource": ""
} |
q168494 | AddAgentUpdateHandlers | validation | func AddAgentUpdateHandlers(cs wsclient.ClientServer, cfg *config.Config, saver statemanager.Saver, taskEngine engine.TaskEngine) {
singleUpdater := &updater{
acs: cs,
config: cfg,
fs: os.Default,
httpclient: httpclient.New(updateDownloadTimeout, false),
}
cs.AddRequestHandler(singleUpdate... | go | {
"resource": ""
} |
q168495 | sdkDockerClient | validation | func (dg *dockerGoClient) sdkDockerClient() (sdkclient.Client, error) {
if dg.version == "" {
return dg.sdkClientFactory.GetDefaultClient()
}
return dg.sdkClientFactory.GetClient(dg.version)
} | go | {
"resource": ""
} |
q168496 | DockerStateToState | validation | func DockerStateToState(state *types.ContainerState) apicontainerstatus.ContainerStatus {
if state.Running {
return apicontainerstatus.ContainerRunning
}
if state.Dead {
return apicontainerstatus.ContainerStopped
}
// StartAt field in ContainerState is a string and need to convert to compare to zero time ins... | go | {
"resource": ""
} |
q168497 | MetadataFromContainer | validation | func MetadataFromContainer(dockerContainer *types.ContainerJSON) DockerContainerMetadata {
var bindings []apicontainer.PortBinding
var err apierrors.NamedError
if dockerContainer.NetworkSettings != nil {
// Convert port bindings into the format our container expects
bindings, err = apicontainer.PortBindingFromDo... | go | {
"resource": ""
} |
q168498 | ContainerEvents | validation | func (dg *dockerGoClient) ContainerEvents(ctx context.Context) (<-chan DockerContainerChangeEvent, error) {
client, err := dg.sdkDockerClient()
if err != nil {
return nil, err
}
events := make(chan *events.Message)
buffer := NewInfiniteBuffer()
derivedCtx, cancel := context.WithCancel(ctx)
dockerEvents, even... | go | {
"resource": ""
} |
q168499 | ListContainers | validation | func (dg *dockerGoClient) ListContainers(ctx context.Context, all bool, timeout time.Duration) ListContainersResponse {
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
// Buffered channel so in the case of timeout it takes one write, never gets
// read, and can still be GC'd
response := make(chan ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.