id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c7200 | parentReference, options)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7201 |
ret0, _ := ret[0].([]imagepkg.HistoryResponseItem)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7202 |
ret0, _ := ret[0].([]types.ImageSummary)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7203 | quiet)
ret0, _ := ret[0].(types.ImageLoadResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7204 | options)
ret0, _ := ret[0].([]types.ImageDeleteResponseItem)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7205 | options)
ret0, _ := ret[0].([]registry.SearchResult)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7206 | reflect.TypeOf((*MockImageAPIClient)(nil).ImageSearch), ctx, term, options)
} | |
c7207 | reflect.TypeOf((*MockImageAPIClient)(nil).ImageSave), ctx, images)
} | |
c7208 | reflect.TypeOf((*MockImageAPIClient)(nil).ImagesPrune), ctx, pruneFilter)
} | |
c7209 | ctrl}
mock.recorder = &MockNetworkAPIClientMockRecorder{mock}
return mock
} | |
c7210 | "NetworkConnect", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkConnect), ctx, networkID, container, config)
} | |
c7211 | reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkCreate), ctx, name, options)
} | |
c7212 | verbose)
ret0, _ := ret[0].(types.NetworkResource)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7213 | "NetworkInspect", reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworkInspect), ctx, networkID, verbose)
} | |
c7214 | reflect.TypeOf((*MockNetworkAPIClient)(nil).NetworksPrune), ctx, pruneFilter)
} | |
c7215 |
mock.recorder = &MockNodeAPIClientMockRecorder{mock}
return mock
} | |
c7216 | := m.ctrl.Call(m, "NodeRemove", ctx, nodeID, options)
ret0, _ := ret[0].(error)
return ret0
} | |
c7217 | "NodeRemove", reflect.TypeOf((*MockNodeAPIClient)(nil).NodeRemove), ctx, nodeID, options)
} | |
c7218 | ctx, nodeID, version, node)
ret0, _ := ret[0].(error)
return ret0
} | |
c7219 | ctrl}
mock.recorder = &MockPluginAPIClientMockRecorder{mock}
return mock
} | |
c7220 | reflect.TypeOf((*MockPluginAPIClient)(nil).PluginList), ctx, filter)
} | |
c7221 | := m.ctrl.Call(m, "PluginRemove", ctx, name, options)
ret0, _ := ret[0].(error)
return ret0
} | |
c7222 | reflect.TypeOf((*MockPluginAPIClient)(nil).PluginRemove), ctx, name, options)
} | |
c7223 | := m.ctrl.Call(m, "PluginEnable", ctx, name, options)
ret0, _ := ret[0].(error)
return ret0
} | |
c7224 | := m.ctrl.Call(m, "PluginDisable", ctx, name, options)
ret0, _ := ret[0].(error)
return ret0
} | |
c7225 | registryAuth)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7226 | []string) error {
ret := m.ctrl.Call(m, "PluginSet", ctx, name, args)
ret0, _ := ret[0].(error)
return ret0
} | |
c7227 | types.PluginCreateOptions) error {
ret := m.ctrl.Call(m, "PluginCreate", ctx, createContext, options)
ret0, _ := ret[0].(error)
return ret0
} | |
c7228 | "PluginCreate", reflect.TypeOf((*MockPluginAPIClient)(nil).PluginCreate), ctx, createContext, options)
} | |
c7229 | ctrl}
mock.recorder = &MockServiceAPIClientMockRecorder{mock}
return mock
} | |
c7230 | options)
ret0, _ := ret[0].(types.ServiceCreateResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7231 | serviceID, options)
ret0, _ := ret[0].(swarm.Service)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c7232 | reflect.TypeOf((*MockServiceAPIClient)(nil).ServiceList), ctx, options)
} | |
c7233 | serviceID, version, service, options)
ret0, _ := ret[0].(types.ServiceUpdateResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7234 | serviceID, options)
ret0, _ := ret[0].(io.ReadCloser)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7235 |
ret0, _ := ret[0].([]swarm.Task)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7236 | ctrl}
mock.recorder = &MockSwarmAPIClientMockRecorder{mock}
return mock
} | |
c7237 |
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7238 |
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwarmInit", reflect.TypeOf((*MockSwarmAPIClient)(nil).SwarmInit), ctx, req)
} | |
c7239 | error {
ret := m.ctrl.Call(m, "SwarmLeave", ctx, force)
ret0, _ := ret[0].(error)
return ret0
} | |
c7240 | ctrl}
mock.recorder = &MockSystemAPIClientMockRecorder{mock}
return mock
} | |
c7241 | reflect.TypeOf((*MockSystemAPIClient)(nil).Events), ctx, options)
} | |
c7242 | ctrl}
mock.recorder = &MockVolumeAPIClientMockRecorder{mock}
return mock
} | |
c7243 | reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeCreate), ctx, options)
} | |
c7244 | _ := ret[0].(types.Volume)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c7245 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeInspectWithRaw", reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeInspectWithRaw), ctx, volumeID)
} | |
c7246 |
ret0, _ := ret[0].(volume.VolumesListOKBody)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7247 | reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumeList), ctx, filter)
} | |
c7248 | reflect.TypeOf((*MockVolumeAPIClient)(nil).VolumesPrune), ctx, pruneFilter)
} | |
c7249 | ctrl}
mock.recorder = &MockSecretAPIClientMockRecorder{mock}
return mock
} | |
c7250 |
ret0, _ := ret[0].([]swarm.Secret)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7251 | reflect.TypeOf((*MockSecretAPIClient)(nil).SecretList), ctx, options)
} | |
c7252 |
ret0, _ := ret[0].(types.SecretCreateResponse)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c7253 | reflect.TypeOf((*MockSecretAPIClient)(nil).SecretCreate), ctx, secret)
} | |
c7254 | "SecretRemove", reflect.TypeOf((*MockSecretAPIClient)(nil).SecretRemove), ctx, id)
} | |
c7255 | _ := ret[0].(swarm.Secret)
ret1, _ := ret[1].([]byte)
ret2, _ := ret[2].(error)
return ret0, ret1, ret2
} | |
c7256 | reflect.TypeOf((*MockSecretAPIClient)(nil).SecretInspectWithRaw), ctx, name)
} | |
c7257 | secret swarm.SecretSpec) error {
ret := m.ctrl.Call(m, "SecretUpdate", ctx, id, version, secret)
ret0, _ := ret[0].(error)
return ret0
} | |
c7258 | logLevel: p.LogLevel,
logFormat: p.LogFormat,
compressedTags: p.CompressedTags,
runtimeErrorChannel: c,
rpc: r,
}
go m.collectChildExitStatus(ctx)
return m
} | |
c7259 | return fmt.Errorf("cannot find process for context: %s", contextID)
}
req := &rpcwrapper.Request{
Payload: procInfo.process.Pid,
}
resp := &rpcwrapper.Response{}
c := make(chan error, 1)
go func() {
c <- p.rpc.RemoteCall(contextID, remoteenforcer.EnforcerExit, req, resp)
}()
select {
case err := <-c:
... | |
c7260 | if p.runtimeErrorChannel != nil {
if es.exitStatus != nil {
zap.L().Error("Remote enforcer exited with an error",
zap.String("nativeContextID", es.contextID),
zap.Int("pid", es.process),
zap.Error(es.exitStatus),
)
} else {
zap.L().Warn("Remote enforcer exited",
zap.Strin... | |
c7261 | {
return err
}
// Stdout/err processing
go processIOReader(stdout, contextID)
go processIOReader(stderr, contextID)
return nil
} | |
c7262 |
zap.String("command", cmdName),
zap.Strings("args", cmdArgs),
)
return execCommand(cmdName, cmdArgs...)
} | |
c7263 | newEnvVars = append(newEnvVars, constants.EnvCompressedTags+"="+string(p.compressedTags))
}
if p.logToConsole {
newEnvVars = append(newEnvVars, constants.EnvLogToConsole+"="+constants.EnvLogToConsoleEnable)
}
if p.logWithID {
newEnvVars = append(newEnvVars, constants.EnvLogID+"="+contextID)
}
// If the P... | |
c7264 | is empty")
}
return filepath.Join("/var/run/", strings.Replace(contextID, "/", "_", -1)+".sock")
} | |
c7265 | for {
str, err := reader.ReadString('\n')
if err != nil {
return
}
fmt.Print("[" + contextID + "]:" + str)
}
} | |
c7266 | start; i < (start + size); i++ {
a.allocate <- i
}
return a
} | |
c7267 | // stopped containers.
if len(p.allocate) == cap(p.allocate) {
return
}
intItem, err := strconv.Atoi(item)
if err != nil {
return
}
p.allocate <- intItem
} | |
c7268 | == 0 {
return
}
p.allocate <- item
} | |
c7269 | error {
return l.proc.Resync(ctx, nil)
} | |
c7270 | defer c.Unlock()
return len(c.Flows)
} | |
c7271 |
if len(c.Flows) == 0 {
return nil
}
retval := c.Flows
c.Flows = make(map[string]*collector.FlowRecord)
return retval
} | |
c7272 | c.Users
c.Users = map[string]*collector.UserRecord{}
return retval
} | |
c7273 |
c.ProcessedUsers = map[string]bool{}
} | |
c7274 | c.DatapathPacketReports = []*collector.PacketReport{}
return record
} | |
c7275 | defer r.Unlock()
r.items[c.name] = c
} | |
c7276 | buffer += fmt.Sprintf(" %32s : %s\n\n", "Cache Name", "max/curr")
for k, c := range r.items {
buffer += fmt.Sprintf(" %32s : %s\n", k, c.ToString())
}
return buffer
} | |
c7277 | return NewCacheWithExpirationNotifier(name, lifetime, nil)
} | |
c7278 | make(map[interface{}]entry),
lifetime: lifetime,
expirer: expirer,
}
c.max = len(c.data)
registry.Add(c)
return c
} | |
c7279 | return fmt.Sprintf("%d/%d", c.max, len(c.data))
} | |
c7280 | -1 && line.timer != nil {
if duration > 0 {
line.timer.Reset(duration)
} else {
line.timer.Reset(c.lifetime)
}
}
return line.value, nil
}
return nil, errors.New("cannot read item: not found")
} | |
c7281 | c.data[u].timer != nil {
c.data[u].timer.Stop()
}
c.data[u] = entry{
value: value,
timestamp: t,
timer: timer,
expirer: c.expirer,
}
return nil
}
return errors.New("cannot update item: not found")
} | |
c7282 | c.data[u].timer != nil {
c.data[u].timer.Stop()
}
}
c.data[u] = entry{
value: value,
timestamp: t,
timer: timer,
expirer: c.expirer,
}
if len(c.data) > c.max {
c.max = len(c.data)
}
return updated
} | |
c7283 | {
return errors.New("item is already deleted")
}
c.data[u].timer.Reset(timeout)
return nil
} | |
c7284 | {
return nil, errors.New("not found")
}
return c.data[u].value, nil
} | |
c7285 | range c.data {
list = append(list, k)
}
return list
} | |
c7286 |
}
if notify && val.expirer != nil {
val.expirer(c, u, val.value)
}
delete(c.data, u)
return nil
} | |
c7287 |
return c.removeNotify(u, false)
} | |
c7288 | item with delay", zap.String("key", fmt.Sprintf("%v", u)), zap.String("delay", duration.String()))
}
})
t := time.Now()
if c.data[u].timer != nil {
c.data[u].timer.Stop()
}
c.data[u] = entry{
value: e.value,
timestamp: t,
timer: timer,
expirer: c.expirer,
}
return nil
} | |
c7289 | c.Lock()
defer c.Unlock()
return len(c.data)
} | |
c7290 | ok := c.data[u]
if !ok {
return nil, errors.New("not found")
}
if e.timer != nil {
e.timer.Stop()
}
e.value = add(e.value, increment)
e.timer = timer
e.timestamp = t
e.expirer = c.expirer
c.data[u] = e
return e.value, nil
} | |
c7291 | ctrl}
mock.recorder = &MockTriremeControllerMockRecorder{mock}
return mock
} | |
c7292 | error {
ret := m.ctrl.Call(m, "UpdateSecrets", secrets)
ret0, _ := ret[0].(error)
return ret0
} | |
c7293 | mock.recorder = &MockDebugInfoMockRecorder{mock}
return mock
} | |
c7294 | "EnableDatapathPacketTracing", contextID, direction, interval, putype)
ret0, _ := ret[0].(error)
return ret0
} | |
c7295 | keys from file: %s", err)
}
return NewVerifierFromPEM(jwtCertPEM, redirectURI, redirectOnFail, redirectOnNoToken)
} | |
c7296 | != nil {
return nil, fmt.Errorf("failed to read JWT signing certificates or public keys from PEM: %s", err)
}
return &PKIJWTVerifier{
JWTCertPEM: jwtCertPEM,
keys: keys,
RedirectURL: redirectURI,
}, nil
} | |
c7297 | nil && err != nil {
return nil, fmt.Errorf("failed to parse JWT signing certificates or public keys from PEM: %s", err)
}
v.keys = keys
return v, nil
} | |
c7298 | if isRSAPublicKey(key) {
return key, nil
}
default:
return nil, fmt.Errorf("unsupported signing method '%T'", token.Method)
}
return nil, fmt.Errorf("signing method '%T' and public key type '%T' mismatch", token.Method, key)
})
// cover all error cases after parsing/verifying
if err != nil... | |
c7299 | (string, string, int, error) {
return "", "", 0, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.