id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c19800 |
if info.Template.Name != "" {
spec.Templating = &swarm.Driver{
Name: info.Template.Name,
Options: info.Template.Options,
}
}
_, err = cli.SecretCreate(ctx, spec)
return
})
} | |
c19801 | //spec.Name = info.Name
//spec.Data = []byte(info.Data)
spec.Labels = info.Labels.ToMap()
return cli.SecretUpdate(ctx, info.ID, version(info.Version), spec)
})
} | |
c19802 | cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
secret, raw, err = cli.SecretInspectWithRaw(ctx, id)
}
return
} | |
c19803 | error) {
return cli.SecretRemove(ctx, id)
})
} | |
c19804 | {
// return containers[i] < containers[j].Description.Hostname
//})
totalCount = len(containers)
start, end := misc.Page(totalCount, args.PageIndex, args.PageSize)
containers = containers[start:end]
if length := len(containers); length > 0 {
infos = make([]*model.ContainerListInfo, length)
fo... | |
c19805 | context.Context, cli *client.Client) (err error) {
container, err = cli.ContainerInspect(ctx, id)
return
})
return
} | |
c19806 | cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
container, raw, err = cli.ContainerInspectWithRaw(ctx, id, true)
}
return
} | |
c19807 | (err error) {
opts := types.ContainerRemoveOptions{}
err = cli.ContainerRemove(ctx, id, opts)
return
})
} | |
c19808 | Cmd: strings.Split(cmd, " "),
}
//cli.DialSession()
resp, err = cli.ContainerExecCreate(ctx, id, opts)
return
})
return
} | |
c19809 | true,
}
resp, err = cli.ContainerExecAttach(ctx, id, opts)
return err
})
return
} | |
c19810 | Detach: false,
Tty: true,
}
return cli.ContainerExecStart(ctx, id, opts)
})
} | |
c19811 |
archiveColl.RemoveId(archive.ID)
} else {
logger.Warnf("Failed to migrate archive '%s': %v", archive.Name, err)
errs = append(errs, err)
}
}
// drop archive collection
if len(errs) == 0 {
err = archiveColl.DropCollection()
if err != nil {
logger.Warn("Failed to drop archive collectio... | |
c19812 | imageDetail,
Raw: imageRaw,
Delete: imageDelete,
}
} | |
c19813 |
config.BindEnv(keyDBAddress, envDBAddress)
config.BindEnv(keyAuthTimeout, envAuthTimeout)
} | |
c19814 | nodes := make(map[string]string)
for _, t := range tasks {
if _, ok := nodes[t.NodeID]; !ok {
if n, _, e := cli.NodeInspectWithRaw(ctx, t.NodeID); e == nil {
if n.Spec.Name == "" {
nodes[t.NodeID] = n.Description.Hostname
} else {
nodes[t.NodeID] = n.Spec.Name
}
} else ... | |
c19815 | raw, err = cli.TaskInspectWithRaw(ctx, id)
return
})
return
} | |
c19816 | ShowStdout: true,
ShowStderr: true,
Tail: strconv.Itoa(line),
Timestamps: timestamps,
//Since: (time.Hour * 24).String()
}
if rc, err = cli.TaskLogs(ctx, id, opts); err == nil {
defer rc.Close()
stdout = &bytes.Buffer{}
stderr = &bytes.Buffer{}
_, err = stdcopy.StdCopy(stdout, stderr, rc)
}
... | |
c19817 | if err != nil {
log.Get("scaler").Error("scaler > Failed to search service: ", err)
return
}
for _, service := range services {
label := service.Spec.Labels[labelScale]
opts := data.ParseOptions(label, ",", "=")
tryScale(&service, opts)
}
}, nil)
} | |
c19818 | containerLogs,
FetchLogs: containerFetchLogs,
Delete: containerDelete,
Exec: containerExec,
Connect: containerConnect,
}
} | |
c19819 | nil, err
}
return v.(Interface), nil
} | |
c19820 | Update: chartUpdate,
Delete: chartDelete,
Data: chartData,
SaveDashboard: chartSaveDashboard,
}
} | |
c19821 | Block: userBlock,
Unblock: userUnblock,
Delete: userDelete,
Search: userSearch,
}
} | |
c19822 | labels := service.Spec.Labels
name, ok := labels[stackLabel]
if !ok {
err = fmt.Errorf("cannot get label %s for service %s(%s)", stackLabel, service.Spec.Name, service.ID)
return
}
if stack, ok := m[name]; ok {
stack.Services = append(stack.Services, service.Spec.Name)
} else {
m[name]... | |
c19823 | labels := service.Spec.Labels
if name, ok := labels[stackLabel]; ok {
m[name] = struct{}{}
} else {
mgr.Logger().Warnf("cannot get label %s for service %s(%s)", stackLabel, service.Spec.Name, service.ID)
}
}
count = len(m)
return
})
return
} | |
c19824 | nil {
return err
}
if err = createNetworks(ctx, cli, namespace, networks); err != nil {
return err
}
secrets, err := compose.Secrets(namespace, cfg.Secrets)
if err != nil {
return err
}
if err = createSecrets(ctx, cli, secrets); err != nil {
return err
}
configs, err := compose.Configs(namespace, cf... | |
c19825 | configNew,
Create: configCreate,
Edit: configEdit,
Update: configUpdate,
}
} | |
c19826 | Delete: volumeDelete,
Prune: volumePrune,
Detail: volumeDetail,
Raw: volumeRaw,
}
} | |
c19827 | Detail: taskDetail,
Raw: taskRaw,
Logs: taskLogs,
FetchLogs: taskFetchLogs,
}
} | |
c19828 | Type: model.UserTypeLDAP,
LoginName: lu.LoginName(),
Name: lu.Name(),
Email: lu.Email(),
}
err = biz.User.Create(mu, nil)
}
} else {
err = certify.ErrInvalidToken
}
// replace user session, one session is allowed per user.
if err == nil {
ticket, err = biz.User.... | |
c19829 | err)
}
u, err := biz.User.GetByID(session.UserID)
if err != nil {
log.Get(pkgName).Errorf("Load user failed: %v", err)
return
}
if u == nil {
return
}
var roles []*model.Role
if roles, err = getRoles(u); err == nil {
user = model.NewAuthUser(u, roles)
cache.Set(user, cacheKey, session.UserID)
}
r... | |
c19830 | Update: stackUpdate,
Deploy: stackDeploy,
Shutdown: stackShutdown,
Delete: stackDelete,
}
} | |
c19831 | := types.ServiceListOptions{Filters: args}
services, err = cli.ServiceList(ctx, opts)
return
})
return
} | |
c19832 | services, err = cli.ServiceList(ctx, types.ServiceListOptions{}); err == nil {
count = len(services)
}
return
})
return
} | |
c19833 | err = cli.ServiceInspectWithRaw(ctx, name, types.ServiceInspectOptions{})
return
})
return
} | |
c19834 |
ver = swarm.Version{Index: version}
}
resp, err := cli.ServiceUpdate(context.Background(), name, ver, spec, types.ServiceUpdateOptions{})
if err == nil && len(resp.Warnings) > 0 {
mgr.Logger().Warnf("service %s was scaled but got warnings: %v", name, resp.Warnings)
}
return err
})
} | |
c19835 |
resp, err := cli.ServiceUpdate(context.Background(), name, service.Version, service.Spec, options)
if err == nil && len(resp.Warnings) > 0 {
mgr.Logger().Warnf("service %s was rollbacked but got warnings: %v", name, resp.Warnings)
}
return err
})
} | |
c19836 | networks, err = cli.NetworkList(ctx, types.NetworkListOptions{})
if err == nil {
sort.Slice(networks, func(i, j int) bool {
return networks[i].Name < networks[j].Name
})
}
return
})
return
} | |
c19837 | = cli.NetworkList(ctx, types.NetworkListOptions{})
if err == nil {
count = len(networks)
}
return
})
return
} | |
c19838 | || info.IPV6.Gateway != "") {
cfg := network.IPAMConfig{
Subnet: info.IPV6.Subnet,
Gateway: info.IPV6.Gateway,
}
options.IPAM.Config = append(options.IPAM.Config, cfg)
}
resp, err = cli.NetworkCreate(ctx, info.Name, options)
if err == nil && resp.Warning != "" {
mgr.Logger().Warnf("network ... | |
c19839 | context.Context, cli *client.Client) (err error) {
return cli.NetworkDisconnect(ctx, name, container, false)
})
} | |
c19840 | network, err = cli.NetworkInspect(ctx, name, types.NetworkInspectOptions{})
}
return
} | |
c19841 | = cli.NetworkInspectWithRaw(ctx, name, types.NetworkInspectOptions{})
}
return
} | |
c19842 |
n, err = cli.NetworkInspect(ctx, id, types.NetworkInspectOptions{})
if err != nil {
break
}
names = append(names, n.Name)
}
}
return
} | |
c19843 | if c == m {
return i
}
}
}
}
return -1
} | |
c19844 | Equal(s[0:len(prefix)], prefix)
} | |
c19845 | Equal(s[len(s)-len(suffix):], suffix)
} | |
c19846 |
g, err := Compile(pattern, separators...)
if err != nil {
panic(err)
}
return g
} | |
c19847 | {
case ast.KindAnyOf:
return minimizeTreeAnyOf(tree)
default:
return nil
}
} | |
c19848 | = append(out, xValue)
x++
y++
case xValue < yValue:
out = append(out, xValue)
x++
case yValue < xValue:
out = append(out, yValue)
y++
}
}
target = append(target[:0], out...)
return target
} | |
c19849 | (atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&shortid))))
} | |
c19850 |
source := unsafe.Pointer(sid)
atomic.SwapPointer(target, source)
} | |
c19851 | {
sid, err := New(worker, alphabet, seed)
if err == nil {
return sid
}
panic(err)
} | |
c19852 | sid.GenerateInternal(nil, sid.epoch)
} | |
c19853 | err
}
if count > 0 {
if countrunes, err := sid.abc.Encode(count, 0, 6); err == nil {
// only extend if really need it
idrunes = append(idrunes, countrunes...)
} else {
return "", err
}
}
return string(idrunes), nil
} | |
c19854 | epoch=%v, abc=%v)", sid.worker, sid.epoch, sid.abc)
} | |
c19855 | contain %v unique characters", len(DefaultABC))
}
if nonUnique(runes) {
return Abc{}, errors.New("alphabet must contain unique characters only")
}
abc := Abc{alphabet: nil}
abc.shuffle(alphabet, seed)
return abc, nil
} | |
c19856 |
if err == nil {
return res
}
panic(err)
} | |
c19857 |
res, err := abc.Encode(val, size, digits)
if err == nil {
return res
}
panic(err)
} | |
c19858 | r: r,
decoder: json.NewDecoder(r),
result: make(chan Event),
}
go sw.receive()
return sw
} | |
c19859 |
k8sClient: client,
schema: schema,
}
} | |
c19860 | defaultFreq,
endpoints: endpointsForTarget.WithLabelValues(ti.String()),
addresses: addressesForTarget.WithLabelValues(ti.String()),
}
go until(func() {
r.wg.Add(1)
err := r.watch()
if err != nil && err != io.EOF {
grpclog.Errorf("kuberesolver: watching ended with error='%v', will reconnect again", ... | |
c19861 | certPool.AppendCertsFromPEM(ca)
transport := &http.Transport{TLSClientConfig: &tls.Config{
MinVersion: tls.VersionTLS10,
RootCAs: certPool,
}}
httpClient := &http.Client{Transport: transport, Timeout: time.Nanosecond * 0}
return &k8sClient{
host: "https://" + net.JoinHostPort(host, port),
token: ... | |
c19862 | apiURL,
httpClient: http.DefaultClient,
}
} | |
c19863 | &Service{
client: c,
URL: DefaultURL,
}
} | |
c19864 | != nil {
v, err := query.Values(q)
if err != nil {
return nil, err
}
query := v.Encode()
if req.URL.RawQuery != "" && query != "" {
req.URL.RawQuery += "&"
}
req.URL.RawQuery += query
}
req.Header.Set("Accept", "application/json")
req.Header.Set("User-Agent", DefaultUserAgent)
if ctype != "" {
... | |
c19865 | defer resp.Body.Close()
switch t := v.(type) {
case nil:
case io.Writer:
_, err = io.Copy(t, resp.Body)
default:
err = json.NewDecoder(resp.Body).Decode(v)
}
return err
} | |
c19866 | query interface{}, lr *ListRange) error {
return s.Do(ctx, v, "GET", path, nil, query, lr)
} | |
c19867 | string, body interface{}) error {
return s.Do(ctx, v, "POST", path, body, nil, nil)
} | |
c19868 |
return s.Do(ctx, v, "DELETE", path, nil, nil, nil)
} | |
c19869 | if lr.Descending {
params = append(params, "order=desc")
}
if len(params) > 0 {
hdrval += fmt.Sprintf("; %s", strings.Join(params, ","))
}
req.Header.Set("Range", hdrval)
return
} | |
c19870 | &accountFeature, fmt.Sprintf("/account/features/%v", accountFeatureIdentity), nil, nil)
} | |
c19871 | {
var accountFeature AccountFeatureListResult
return accountFeature, s.Get(ctx, &accountFeature, fmt.Sprintf("/account/features"), nil, lr)
} | |
c19872 | s.Patch(ctx, &accountFeature, fmt.Sprintf("/account/features/%v", accountFeatureIdentity), o)
} | |
c19873 | error) {
var addOn AddOnListResult
return addOn, s.Get(ctx, &addOn, fmt.Sprintf("/addons"), nil, lr)
} | |
c19874 | &addOn, s.Post(ctx, &addOn, fmt.Sprintf("/apps/%v/addons", appIdentity), o)
} | |
c19875 | &addOn, s.Delete(ctx, &addOn, fmt.Sprintf("/apps/%v/addons/%v", appIdentity, addOnIdentity))
} | |
c19876 | s.Get(ctx, &addOn, fmt.Sprintf("/apps/%v/addons/%v", appIdentity, addOnIdentity), nil, nil)
} | |
c19877 | s.Get(ctx, &addOn, fmt.Sprintf("/apps/%v/addons", appIdentity), nil, lr)
} | |
c19878 | &addOn, s.Patch(ctx, &addOn, fmt.Sprintf("/apps/%v/addons/%v", appIdentity, addOnIdentity), o)
} | |
c19879 | s.Get(ctx, &addOn, fmt.Sprintf("/users/%v/addons", accountIdentity), nil, lr)
} | |
c19880 | s.Get(ctx, &addOn, fmt.Sprintf("/teams/%v/addons", teamIdentity), nil, lr)
} | |
c19881 | s.Post(ctx, &addOnAction, fmt.Sprintf("/addons/%v/actions/provision", addOnIdentity), nil)
} | |
c19882 | s.Post(ctx, &addOnAction, fmt.Sprintf("/addons/%v/actions/deprovision", addOnIdentity), nil)
} | |
c19883 | error) {
var addOnAttachment AddOnAttachment
return &addOnAttachment, s.Post(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments"), o)
} | |
c19884 | {
var addOnAttachment AddOnAttachment
return &addOnAttachment, s.Delete(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments/%v", addOnAttachmentIdentity))
} | |
c19885 | &addOnAttachment, fmt.Sprintf("/addon-attachments/%v", addOnAttachmentIdentity), nil, nil)
} | |
c19886 | {
var addOnAttachment AddOnAttachmentListResult
return addOnAttachment, s.Get(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments"), nil, lr)
} | |
c19887 | s.Get(ctx, &addOnAttachment, fmt.Sprintf("/addons/%v/addon-attachments", addOnIdentity), nil, lr)
} | |
c19888 | s.Get(ctx, &addOnAttachment, fmt.Sprintf("/apps/%v/addon-attachments", appIdentity), nil, lr)
} | |
c19889 | s.Get(ctx, &addOnAttachment, fmt.Sprintf("/apps/%v/addon-attachments/%v", appIdentity, addOnAttachmentScopedIdentity), nil, nil)
} | |
c19890 | s.Get(ctx, &addOnConfig, fmt.Sprintf("/addons/%v/config", addOnIdentity), nil, lr)
} | |
c19891 | error) {
var addOnConfig AddOnConfigUpdateResult
return addOnConfig, s.Patch(ctx, &addOnConfig, fmt.Sprintf("/addons/%v/config", addOnIdentity), o)
} | |
c19892 | {
var addOnRegionCapability AddOnRegionCapabilityListResult
return addOnRegionCapability, s.Get(ctx, &addOnRegionCapability, fmt.Sprintf("/addon-region-capabilities"), nil, lr)
} | |
c19893 | s.Get(ctx, &addOnRegionCapability, fmt.Sprintf("/addon-services/%v/region-capabilities", addOnServiceIdentity), nil, lr)
} | |
c19894 | s.Get(ctx, &addOnRegionCapability, fmt.Sprintf("/regions/%v/addon-region-capabilities", regionIdentity), nil, lr)
} | |
c19895 | &addOnService, fmt.Sprintf("/addon-services/%v", addOnServiceIdentity), nil, nil)
} | |
c19896 | error) {
var addOnService AddOnServiceListResult
return addOnService, s.Get(ctx, &addOnService, fmt.Sprintf("/addon-services"), nil, lr)
} | |
c19897 | error) {
var addOnWebhook AddOnWebhookCreateResult
return &addOnWebhook, s.Post(ctx, &addOnWebhook, fmt.Sprintf("/addons/%v/webhooks", addOnIdentity), o)
} | |
c19898 | s.Delete(ctx, &addOnWebhook, fmt.Sprintf("/addons/%v/webhooks/%v", addOnIdentity, appWebhookIdentity))
} | |
c19899 | s.Get(ctx, &addOnWebhook, fmt.Sprintf("/addons/%v/webhooks/%v", addOnIdentity, appWebhookIdentity), nil, nil)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.