_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q19800 | SecretCreate | train | func SecretCreate(info *model.ConfigCreateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
spec := swarm.SecretSpec{}
spec.Name = info.Name
if info.Base64 {
spec.Data, err = base64.StdEncoding.DecodeString(info.Data)
if err != nil {
return
}
} else {
spec.... | go | {
"resource": ""
} |
q19801 | SecretUpdate | train | func SecretUpdate(info *model.ConfigUpdateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var secret swarm.Secret
secret, _, err = cli.SecretInspectWithRaw(ctx, info.ID)
if err != nil {
return err
}
spec := secret.Spec
// only the Labels field can be updated on A... | go | {
"resource": ""
} |
q19802 | SecretInspect | train | func SecretInspect(id string) (secret swarm.Secret, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
secret, raw, err = cli.SecretInspectWithRaw(ctx, id)
}
return
} | go | {
"resource": ""
} |
q19803 | SecretRemove | train | func SecretRemove(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
return cli.SecretRemove(ctx, id)
})
} | go | {
"resource": ""
} |
q19804 | ContainerList | train | func ContainerList(args *model.ContainerListArgs) (infos []*model.ContainerListInfo, totalCount int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var (
containers []types.Container
opts = types.ContainerListOptions{Filters: filters.NewArgs()}
)
if args.Filter... | go | {
"resource": ""
} |
q19805 | ContainerInspect | train | func ContainerInspect(id string) (container types.ContainerJSON, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
container, err = cli.ContainerInspect(ctx, id)
return
})
return
} | go | {
"resource": ""
} |
q19806 | ContainerInspectRaw | train | func ContainerInspectRaw(id string) (container types.ContainerJSON, raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
container, raw, err = cli.ContainerInspectWithRaw(ctx, id, true)
}
return
} | go | {
"resource": ""
} |
q19807 | ContainerRemove | train | func ContainerRemove(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ContainerRemoveOptions{}
err = cli.ContainerRemove(ctx, id, opts)
return
})
} | go | {
"resource": ""
} |
q19808 | ContainerExecCreate | train | func ContainerExecCreate(id string, cmd string) (resp types.IDResponse, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ExecConfig{
AttachStdin: true,
AttachStdout: true,
AttachStderr: true,
Tty: true,
//User: "root",
Cmd: strings.Split(... | go | {
"resource": ""
} |
q19809 | ContainerExecAttach | train | func ContainerExecAttach(id string) (resp types.HijackedResponse, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ExecStartCheck{
Detach: false,
Tty: true,
}
resp, err = cli.ContainerExecAttach(ctx, id, opts)
return err
})
return
} | go | {
"resource": ""
} |
q19810 | ContainerExecStart | train | func ContainerExecStart(id string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ExecStartCheck{
Detach: false,
Tty: true,
}
return cli.ContainerExecStart(ctx, id, opts)
})
} | go | {
"resource": ""
} |
q19811 | StackMigrate | train | func (d *Dao) StackMigrate() {
d.do(func(db *database) {
logger := log.Get(app.Name)
archiveColl := db.C("archive")
// check collection is exists.
if _, err := archiveColl.Indexes(); err != nil {
return
}
archives := make([]*model.Archive, 0)
err := archiveColl.Find(nil).All(&archives)
if err != n... | go | {
"resource": ""
} |
q19812 | Image | train | func Image() (c *ImageController) {
return &ImageController{
List: imageList,
Detail: imageDetail,
Raw: imageRaw,
Delete: imageDelete,
}
} | go | {
"resource": ""
} |
q19813 | BindOptions | train | func BindOptions() {
config.BindEnv(keyDockerEndpoint, envDockerEndpoint)
config.BindEnv(keyDockerAPIVersion, envDockerAPIVersion)
config.BindEnv(keyDBType, envDBType)
config.BindEnv(keyDBAddress, envDBAddress)
config.BindEnv(keyAuthTimeout, envAuthTimeout)
} | go | {
"resource": ""
} |
q19814 | TaskList | train | func TaskList(args *model.TaskListArgs) (infos []*model.TaskInfo, totalCount int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var (
tasks []swarm.Task
opts = types.TaskListOptions{
Filters: filters.NewArgs(),
}
)
if args.PageIndex < 1 {
args.PageIndex =... | go | {
"resource": ""
} |
q19815 | TaskInspect | train | func TaskInspect(id string) (task swarm.Task, raw []byte, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
task, raw, err = cli.TaskInspectWithRaw(ctx, id)
return
})
return
} | go | {
"resource": ""
} |
q19816 | TaskLogs | train | func TaskLogs(id string, line int, timestamps bool) (stdout, stderr *bytes.Buffer, err error) {
var (
ctx context.Context
cli *client.Client
rc io.ReadCloser
)
ctx, cli, err = mgr.Client()
if err != nil {
return
}
opts := types.ContainerLogsOptions{
ShowStdout: true,
ShowStderr: true,
Tail: ... | go | {
"resource": ""
} |
q19817 | Start | train | func Start() {
const labelScale = "swirl.scale"
run.Schedule(time.Minute, func() {
args := filters.NewArgs()
args.Add("mode", "replicated")
args.Add("label", labelScale)
services, err := docker.ServiceSearch(args)
if err != nil {
log.Get("scaler").Error("scaler > Failed to search service: ", err)
ret... | go | {
"resource": ""
} |
q19818 | Container | train | func Container() (c *ContainerController) {
return &ContainerController{
List: containerList,
Detail: containerDetail,
Raw: containerRaw,
Logs: containerLogs,
FetchLogs: containerFetchLogs,
Delete: containerDelete,
Exec: containerExec,
Connect: containerConnect,
}
} | go | {
"resource": ""
} |
q19819 | Get | train | func Get() (Interface, error) {
v, err := value.Get()
if err != nil {
return nil, err
}
return v.(Interface), nil
} | go | {
"resource": ""
} |
q19820 | Chart | train | func Chart() (c *ChartController) {
return &ChartController{
List: chartList,
Query: chartQuery,
New: chartNew,
Create: chartCreate,
Detail: chartDetail,
Edit: chartEdit,
Update: chartUpdate,
Delete: chartDelete,
Data: chartData... | go | {
"resource": ""
} |
q19821 | User | train | func User() (c *UserController) {
return &UserController{
Index: userIndex,
New: userNew,
Create: userCreate,
Detail: userDetail,
Edit: userEdit,
Update: userUpdate,
Block: userBlock,
Unblock: userUnblock,
Delete: userDelete,
Search: userSearch,
}
} | go | {
"resource": ""
} |
q19822 | StackList | train | func StackList() (stacks []*model.Stack, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var services []swarm.Service
opts := types.ServiceListOptions{
Filters: filters.NewArgs(),
}
opts.Filters.Add("label", stackLabel)
services, err = cli.ServiceList(ctx, opts)
if ... | go | {
"resource": ""
} |
q19823 | StackCount | train | func StackCount() (count int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var services []swarm.Service
opts := types.ServiceListOptions{
Filters: filters.NewArgs(),
}
opts.Filters.Add("label", stackLabel)
services, err = cli.ServiceList(ctx, opts)
if err != nil ... | go | {
"resource": ""
} |
q19824 | StackDeploy | train | func StackDeploy(name, content string, authes map[string]string) error {
ctx, cli, err := mgr.Client()
if err != nil {
return err
}
cfg, err := compose.Parse(name, content)
if err != nil {
return err
}
namespace := compose.NewNamespace(name)
serviceNetworks := compose.GetServicesDeclaredNetworks(cfg.Serv... | go | {
"resource": ""
} |
q19825 | Config | train | func Config() (c *ConfigController) {
return &ConfigController{
List: configList,
Delete: configDelete,
New: configNew,
Create: configCreate,
Edit: configEdit,
Update: configUpdate,
}
} | go | {
"resource": ""
} |
q19826 | Volume | train | func Volume() (c *VolumeController) {
return &VolumeController{
List: volumeList,
New: volumeNew,
Create: volumeCreate,
Delete: volumeDelete,
Prune: volumePrune,
Detail: volumeDetail,
Raw: volumeRaw,
}
} | go | {
"resource": ""
} |
q19827 | Task | train | func Task() (c *TaskController) {
return &TaskController{
List: taskList,
Detail: taskDetail,
Raw: taskRaw,
Logs: taskLogs,
FetchLogs: taskFetchLogs,
}
} | go | {
"resource": ""
} |
q19828 | Validator | train | func Validator(setting *model.Setting) func(name, pwd string) (ticket string, err error) {
ldapRealm := createLDAPRealm(setting)
return func(name, pwd string) (ticket string, err error) {
var (
su security.User
mu *model.User
)
// try find user first
mu, err = biz.User.GetByName(name)
if err != nil {... | go | {
"resource": ""
} |
q19829 | Identifier | train | func Identifier(token string) (user web.User) {
const cacheKey = "auth_user"
session, err := biz.User.GetSession(token)
if err != nil {
log.Get(pkgName).Errorf("Load session failed: %v", err)
return
}
if session == nil || session.Expires.Before(time.Now()) {
return
}
// try find from cache first
value :... | go | {
"resource": ""
} |
q19830 | Stack | train | func Stack() (c *StackController) {
return &StackController{
List: stackList,
New: stackNew,
Create: stackCreate,
Detail: stackDetail,
Edit: stackEdit,
Update: stackUpdate,
Deploy: stackDeploy,
Shutdown: stackShutdown,
Delete: stackDelete,
}
} | go | {
"resource": ""
} |
q19831 | ServiceSearch | train | func ServiceSearch(args filters.Args) (services []swarm.Service, err error) { // nolint: gocyclo
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
opts := types.ServiceListOptions{Filters: args}
services, err = cli.ServiceList(ctx, opts)
return
})
return
} | go | {
"resource": ""
} |
q19832 | ServiceCount | train | func ServiceCount() (count int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var services []swarm.Service
if services, err = cli.ServiceList(ctx, types.ServiceListOptions{}); err == nil {
count = len(services)
}
return
})
return
} | go | {
"resource": ""
} |
q19833 | ServiceInspect | train | func ServiceInspect(name string) (service swarm.Service, raw []byte, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
service, raw, err = cli.ServiceInspectWithRaw(ctx, name, types.ServiceInspectOptions{})
return
})
return
} | go | {
"resource": ""
} |
q19834 | ServiceScale | train | func ServiceScale(name string, version, count uint64) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
service, _, err := cli.ServiceInspectWithRaw(ctx, name, types.ServiceInspectOptions{})
if err != nil {
return err
}
spec := service.Spec
if spec.Mode.Replicated == nil {... | go | {
"resource": ""
} |
q19835 | ServiceRollback | train | func ServiceRollback(name string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
service, _, err := cli.ServiceInspectWithRaw(ctx, name, types.ServiceInspectOptions{})
if err != nil {
return err
}
options := types.ServiceUpdateOptions{
Rollback: "previous",
}
resp,... | go | {
"resource": ""
} |
q19836 | NetworkList | train | func NetworkList() (networks []types.NetworkResource, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
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
... | go | {
"resource": ""
} |
q19837 | NetworkCount | train | func NetworkCount() (count int, err error) {
err = mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var networks []types.NetworkResource
networks, err = cli.NetworkList(ctx, types.NetworkListOptions{})
if err == nil {
count = len(networks)
}
return
})
return
} | go | {
"resource": ""
} |
q19838 | NetworkCreate | train | func NetworkCreate(info *model.NetworkCreateInfo) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
var (
resp types.NetworkCreateResponse
options = types.NetworkCreate{
Internal: info.Internal,
Attachable: info.Attachable,
IPAM: &network.IPAM{},
Enabl... | go | {
"resource": ""
} |
q19839 | NetworkDisconnect | train | func NetworkDisconnect(name, container string) error {
return mgr.Do(func(ctx context.Context, cli *client.Client) (err error) {
return cli.NetworkDisconnect(ctx, name, container, false)
})
} | go | {
"resource": ""
} |
q19840 | NetworkInspect | train | func NetworkInspect(name string) (network types.NetworkResource, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
network, err = cli.NetworkInspect(ctx, name, types.NetworkInspectOptions{})
}
return
} | go | {
"resource": ""
} |
q19841 | NetworkInspectRaw | train | func NetworkInspectRaw(name string) (raw []byte, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
_, raw, err = cli.NetworkInspectWithRaw(ctx, name, types.NetworkInspectOptions{})
}
return
} | go | {
"resource": ""
} |
q19842 | NetworkNames | train | func NetworkNames(ids ...string) (names []string, err error) {
var (
ctx context.Context
cli *client.Client
)
if ctx, cli, err = mgr.Client(); err == nil {
for _, id := range ids {
var n types.NetworkResource
n, err = cli.NetworkInspect(ctx, id, types.NetworkInspectOptions{})
if err != nil {
break... | go | {
"resource": ""
} |
q19843 | IndexAny | train | func IndexAny(s, chars []rune) int {
if len(chars) > 0 {
for i, c := range s {
for _, m := range chars {
if c == m {
return i
}
}
}
}
return -1
} | go | {
"resource": ""
} |
q19844 | HasPrefix | train | func HasPrefix(s, prefix []rune) bool {
return len(s) >= len(prefix) && Equal(s[0:len(prefix)], prefix)
} | go | {
"resource": ""
} |
q19845 | HasSuffix | train | func HasSuffix(s, suffix []rune) bool {
return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix):], suffix)
} | go | {
"resource": ""
} |
q19846 | MustCompile | train | func MustCompile(pattern string, separators ...rune) Glob {
g, err := Compile(pattern, separators...)
if err != nil {
panic(err)
}
return g
} | go | {
"resource": ""
} |
q19847 | minimizeTree | train | func minimizeTree(tree *ast.Node) *ast.Node {
switch tree.Kind {
case ast.KindAnyOf:
return minimizeTreeAnyOf(tree)
default:
return nil
}
} | go | {
"resource": ""
} |
q19848 | appendMerge | train | func appendMerge(target, sub []int) []int {
lt, ls := len(target), len(sub)
out := make([]int, 0, lt+ls)
for x, y := 0, 0; x < lt || y < ls; {
if x >= lt {
out = append(out, sub[y:]...)
break
}
if y >= ls {
out = append(out, target[x:]...)
break
}
xValue := target[x]
yValue := sub[y]
sw... | go | {
"resource": ""
} |
q19849 | GetDefault | train | func GetDefault() *Shortid {
return (*Shortid)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&shortid))))
} | go | {
"resource": ""
} |
q19850 | SetDefault | train | func SetDefault(sid *Shortid) {
target := (*unsafe.Pointer)(unsafe.Pointer(&shortid))
source := unsafe.Pointer(sid)
atomic.SwapPointer(target, source)
} | go | {
"resource": ""
} |
q19851 | MustNew | train | func MustNew(worker uint8, alphabet string, seed uint64) *Shortid {
sid, err := New(worker, alphabet, seed)
if err == nil {
return sid
}
panic(err)
} | go | {
"resource": ""
} |
q19852 | Generate | train | func (sid *Shortid) Generate() (string, error) {
return sid.GenerateInternal(nil, sid.epoch)
} | go | {
"resource": ""
} |
q19853 | GenerateInternal | train | func (sid *Shortid) GenerateInternal(tm *time.Time, epoch time.Time) (string, error) {
ms, count := sid.getMsAndCounter(tm, epoch)
idrunes := make([]rune, 9)
if tmp, err := sid.abc.Encode(ms, 8, 5); err == nil {
copy(idrunes, tmp) // first 8 symbols
} else {
return "", err
}
if tmp, err := sid.abc.Encode(sid.... | go | {
"resource": ""
} |
q19854 | String | train | func (sid *Shortid) String() string {
return fmt.Sprintf("Shortid(worker=%v, epoch=%v, abc=%v)", sid.worker, sid.epoch, sid.abc)
} | go | {
"resource": ""
} |
q19855 | NewAbc | train | func NewAbc(alphabet string, seed uint64) (Abc, error) {
runes := []rune(alphabet)
if len(runes) != len(DefaultABC) {
return Abc{}, fmt.Errorf("alphabet must contain %v unique characters", len(DefaultABC))
}
if nonUnique(runes) {
return Abc{}, errors.New("alphabet must contain unique characters only")
}
abc :... | go | {
"resource": ""
} |
q19856 | MustNewAbc | train | func MustNewAbc(alphabet string, seed uint64) Abc {
res, err := NewAbc(alphabet, seed)
if err == nil {
return res
}
panic(err)
} | go | {
"resource": ""
} |
q19857 | MustEncode | train | func (abc *Abc) MustEncode(val, size, digits uint) []rune {
res, err := abc.Encode(val, size, digits)
if err == nil {
return res
}
panic(err)
} | go | {
"resource": ""
} |
q19858 | newStreamWatcher | train | func newStreamWatcher(r io.ReadCloser) watchInterface {
sw := &streamWatcher{
r: r,
decoder: json.NewDecoder(r),
result: make(chan Event),
}
go sw.receive()
return sw
} | go | {
"resource": ""
} |
q19859 | NewBuilder | train | func NewBuilder(client K8sClient, schema string) resolver.Builder {
return &kubeBuilder{
k8sClient: client,
schema: schema,
}
} | go | {
"resource": ""
} |
q19860 | Build | train | func (b *kubeBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOption) (resolver.Resolver, error) {
if b.k8sClient == nil {
if cl, err := NewInClusterK8sClient(); err == nil {
b.k8sClient = cl
} else {
return nil, err
}
}
ti, err := parseResolverTarget(target)
if err != n... | go | {
"resource": ""
} |
q19861 | NewInClusterK8sClient | train | func NewInClusterK8sClient() (K8sClient, error) {
host, port := os.Getenv("KUBERNETES_SERVICE_HOST"), os.Getenv("KUBERNETES_SERVICE_PORT")
if len(host) == 0 || len(port) == 0 {
return nil, fmt.Errorf("unable to load in-cluster configuration, KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT must be defined")
}
... | go | {
"resource": ""
} |
q19862 | NewInsecureK8sClient | train | func NewInsecureK8sClient(apiURL string) K8sClient {
return &k8sClient{
host: apiURL,
httpClient: http.DefaultClient,
}
} | go | {
"resource": ""
} |
q19863 | NewService | train | func NewService(c *http.Client) *Service {
if c == nil {
c = http.DefaultClient
}
return &Service{
client: c,
URL: DefaultURL,
}
} | go | {
"resource": ""
} |
q19864 | NewRequest | train | func (s *Service) NewRequest(ctx context.Context, method, path string, body interface{}, q interface{}) (*http.Request, error) {
var ctype string
var rbody io.Reader
switch t := body.(type) {
case nil:
case string:
rbody = bytes.NewBufferString(t)
case io.Reader:
rbody = t
default:
v := reflect.ValueOf(bod... | go | {
"resource": ""
} |
q19865 | Do | train | func (s *Service) Do(ctx context.Context, v interface{}, method, path string, body interface{}, q interface{}, lr *ListRange) error {
req, err := s.NewRequest(ctx, method, path, body, q)
if err != nil {
return err
}
if lr != nil {
lr.SetHeader(req)
}
resp, err := s.client.Do(req)
if err != nil {
return err... | go | {
"resource": ""
} |
q19866 | Get | train | func (s *Service) Get(ctx context.Context, v interface{}, path string, query interface{}, lr *ListRange) error {
return s.Do(ctx, v, "GET", path, nil, query, lr)
} | go | {
"resource": ""
} |
q19867 | Post | train | func (s *Service) Post(ctx context.Context, v interface{}, path string, body interface{}) error {
return s.Do(ctx, v, "POST", path, body, nil, nil)
} | go | {
"resource": ""
} |
q19868 | Delete | train | func (s *Service) Delete(ctx context.Context, v interface{}, path string) error {
return s.Do(ctx, v, "DELETE", path, nil, nil, nil)
} | go | {
"resource": ""
} |
q19869 | SetHeader | train | func (lr *ListRange) SetHeader(req *http.Request) {
var hdrval string
if lr.Field != "" {
hdrval += lr.Field + " "
}
hdrval += lr.FirstID + ".." + lr.LastID
params := make([]string, 0, 2)
if lr.Max != 0 {
params = append(params, fmt.Sprintf("max=%d", lr.Max))
}
if lr.Descending {
params = append(params, "... | go | {
"resource": ""
} |
q19870 | AccountFeatureInfo | train | func (s *Service) AccountFeatureInfo(ctx context.Context, accountFeatureIdentity string) (*AccountFeature, error) {
var accountFeature AccountFeature
return &accountFeature, s.Get(ctx, &accountFeature, fmt.Sprintf("/account/features/%v", accountFeatureIdentity), nil, nil)
} | go | {
"resource": ""
} |
q19871 | AccountFeatureList | train | func (s *Service) AccountFeatureList(ctx context.Context, lr *ListRange) (AccountFeatureListResult, error) {
var accountFeature AccountFeatureListResult
return accountFeature, s.Get(ctx, &accountFeature, fmt.Sprintf("/account/features"), nil, lr)
} | go | {
"resource": ""
} |
q19872 | AccountFeatureUpdate | train | func (s *Service) AccountFeatureUpdate(ctx context.Context, accountFeatureIdentity string, o AccountFeatureUpdateOpts) (*AccountFeature, error) {
var accountFeature AccountFeature
return &accountFeature, s.Patch(ctx, &accountFeature, fmt.Sprintf("/account/features/%v", accountFeatureIdentity), o)
} | go | {
"resource": ""
} |
q19873 | AddOnList | train | func (s *Service) AddOnList(ctx context.Context, lr *ListRange) (AddOnListResult, error) {
var addOn AddOnListResult
return addOn, s.Get(ctx, &addOn, fmt.Sprintf("/addons"), nil, lr)
} | go | {
"resource": ""
} |
q19874 | AddOnCreate | train | func (s *Service) AddOnCreate(ctx context.Context, appIdentity string, o AddOnCreateOpts) (*AddOn, error) {
var addOn AddOn
return &addOn, s.Post(ctx, &addOn, fmt.Sprintf("/apps/%v/addons", appIdentity), o)
} | go | {
"resource": ""
} |
q19875 | AddOnDelete | train | func (s *Service) AddOnDelete(ctx context.Context, appIdentity string, addOnIdentity string) (*AddOn, error) {
var addOn AddOn
return &addOn, s.Delete(ctx, &addOn, fmt.Sprintf("/apps/%v/addons/%v", appIdentity, addOnIdentity))
} | go | {
"resource": ""
} |
q19876 | AddOnInfoByApp | train | func (s *Service) AddOnInfoByApp(ctx context.Context, appIdentity string, addOnIdentity string) (*AddOn, error) {
var addOn AddOn
return &addOn, s.Get(ctx, &addOn, fmt.Sprintf("/apps/%v/addons/%v", appIdentity, addOnIdentity), nil, nil)
} | go | {
"resource": ""
} |
q19877 | AddOnListByApp | train | func (s *Service) AddOnListByApp(ctx context.Context, appIdentity string, lr *ListRange) (AddOnListByAppResult, error) {
var addOn AddOnListByAppResult
return addOn, s.Get(ctx, &addOn, fmt.Sprintf("/apps/%v/addons", appIdentity), nil, lr)
} | go | {
"resource": ""
} |
q19878 | AddOnUpdate | train | func (s *Service) AddOnUpdate(ctx context.Context, appIdentity string, addOnIdentity string, o AddOnUpdateOpts) (*AddOn, error) {
var addOn AddOn
return &addOn, s.Patch(ctx, &addOn, fmt.Sprintf("/apps/%v/addons/%v", appIdentity, addOnIdentity), o)
} | go | {
"resource": ""
} |
q19879 | AddOnListByUser | train | func (s *Service) AddOnListByUser(ctx context.Context, accountIdentity string, lr *ListRange) (AddOnListByUserResult, error) {
var addOn AddOnListByUserResult
return addOn, s.Get(ctx, &addOn, fmt.Sprintf("/users/%v/addons", accountIdentity), nil, lr)
} | go | {
"resource": ""
} |
q19880 | AddOnListByTeam | train | func (s *Service) AddOnListByTeam(ctx context.Context, teamIdentity string, lr *ListRange) (AddOnListByTeamResult, error) {
var addOn AddOnListByTeamResult
return addOn, s.Get(ctx, &addOn, fmt.Sprintf("/teams/%v/addons", teamIdentity), nil, lr)
} | go | {
"resource": ""
} |
q19881 | AddOnActionProvision | train | func (s *Service) AddOnActionProvision(ctx context.Context, addOnIdentity string) (*AddOnActionProvisionResult, error) {
var addOnAction AddOnActionProvisionResult
return &addOnAction, s.Post(ctx, &addOnAction, fmt.Sprintf("/addons/%v/actions/provision", addOnIdentity), nil)
} | go | {
"resource": ""
} |
q19882 | AddOnActionDeprovision | train | func (s *Service) AddOnActionDeprovision(ctx context.Context, addOnIdentity string) (*AddOnActionDeprovisionResult, error) {
var addOnAction AddOnActionDeprovisionResult
return &addOnAction, s.Post(ctx, &addOnAction, fmt.Sprintf("/addons/%v/actions/deprovision", addOnIdentity), nil)
} | go | {
"resource": ""
} |
q19883 | AddOnAttachmentCreate | train | func (s *Service) AddOnAttachmentCreate(ctx context.Context, o AddOnAttachmentCreateOpts) (*AddOnAttachment, error) {
var addOnAttachment AddOnAttachment
return &addOnAttachment, s.Post(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments"), o)
} | go | {
"resource": ""
} |
q19884 | AddOnAttachmentDelete | train | func (s *Service) AddOnAttachmentDelete(ctx context.Context, addOnAttachmentIdentity string) (*AddOnAttachment, error) {
var addOnAttachment AddOnAttachment
return &addOnAttachment, s.Delete(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments/%v", addOnAttachmentIdentity))
} | go | {
"resource": ""
} |
q19885 | AddOnAttachmentInfo | train | func (s *Service) AddOnAttachmentInfo(ctx context.Context, addOnAttachmentIdentity string) (*AddOnAttachment, error) {
var addOnAttachment AddOnAttachment
return &addOnAttachment, s.Get(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments/%v", addOnAttachmentIdentity), nil, nil)
} | go | {
"resource": ""
} |
q19886 | AddOnAttachmentList | train | func (s *Service) AddOnAttachmentList(ctx context.Context, lr *ListRange) (AddOnAttachmentListResult, error) {
var addOnAttachment AddOnAttachmentListResult
return addOnAttachment, s.Get(ctx, &addOnAttachment, fmt.Sprintf("/addon-attachments"), nil, lr)
} | go | {
"resource": ""
} |
q19887 | AddOnAttachmentListByAddOn | train | func (s *Service) AddOnAttachmentListByAddOn(ctx context.Context, addOnIdentity string, lr *ListRange) (AddOnAttachmentListByAddOnResult, error) {
var addOnAttachment AddOnAttachmentListByAddOnResult
return addOnAttachment, s.Get(ctx, &addOnAttachment, fmt.Sprintf("/addons/%v/addon-attachments", addOnIdentity), nil, ... | go | {
"resource": ""
} |
q19888 | AddOnAttachmentListByApp | train | func (s *Service) AddOnAttachmentListByApp(ctx context.Context, appIdentity string, lr *ListRange) (AddOnAttachmentListByAppResult, error) {
var addOnAttachment AddOnAttachmentListByAppResult
return addOnAttachment, s.Get(ctx, &addOnAttachment, fmt.Sprintf("/apps/%v/addon-attachments", appIdentity), nil, lr)
} | go | {
"resource": ""
} |
q19889 | AddOnAttachmentInfoByApp | train | func (s *Service) AddOnAttachmentInfoByApp(ctx context.Context, appIdentity string, addOnAttachmentScopedIdentity string) (*AddOnAttachment, error) {
var addOnAttachment AddOnAttachment
return &addOnAttachment, s.Get(ctx, &addOnAttachment, fmt.Sprintf("/apps/%v/addon-attachments/%v", appIdentity, addOnAttachmentScope... | go | {
"resource": ""
} |
q19890 | AddOnConfigList | train | func (s *Service) AddOnConfigList(ctx context.Context, addOnIdentity string, lr *ListRange) (AddOnConfigListResult, error) {
var addOnConfig AddOnConfigListResult
return addOnConfig, s.Get(ctx, &addOnConfig, fmt.Sprintf("/addons/%v/config", addOnIdentity), nil, lr)
} | go | {
"resource": ""
} |
q19891 | AddOnConfigUpdate | train | func (s *Service) AddOnConfigUpdate(ctx context.Context, addOnIdentity string, o AddOnConfigUpdateOpts) (AddOnConfigUpdateResult, error) {
var addOnConfig AddOnConfigUpdateResult
return addOnConfig, s.Patch(ctx, &addOnConfig, fmt.Sprintf("/addons/%v/config", addOnIdentity), o)
} | go | {
"resource": ""
} |
q19892 | AddOnRegionCapabilityList | train | func (s *Service) AddOnRegionCapabilityList(ctx context.Context, lr *ListRange) (AddOnRegionCapabilityListResult, error) {
var addOnRegionCapability AddOnRegionCapabilityListResult
return addOnRegionCapability, s.Get(ctx, &addOnRegionCapability, fmt.Sprintf("/addon-region-capabilities"), nil, lr)
} | go | {
"resource": ""
} |
q19893 | AddOnRegionCapabilityListByAddOnService | train | func (s *Service) AddOnRegionCapabilityListByAddOnService(ctx context.Context, addOnServiceIdentity string, lr *ListRange) (AddOnRegionCapabilityListByAddOnServiceResult, error) {
var addOnRegionCapability AddOnRegionCapabilityListByAddOnServiceResult
return addOnRegionCapability, s.Get(ctx, &addOnRegionCapability, f... | go | {
"resource": ""
} |
q19894 | AddOnRegionCapabilityListByRegion | train | func (s *Service) AddOnRegionCapabilityListByRegion(ctx context.Context, regionIdentity string, lr *ListRange) (AddOnRegionCapabilityListByRegionResult, error) {
var addOnRegionCapability AddOnRegionCapabilityListByRegionResult
return addOnRegionCapability, s.Get(ctx, &addOnRegionCapability, fmt.Sprintf("/regions/%v/... | go | {
"resource": ""
} |
q19895 | AddOnServiceInfo | train | func (s *Service) AddOnServiceInfo(ctx context.Context, addOnServiceIdentity string) (*AddOnService, error) {
var addOnService AddOnService
return &addOnService, s.Get(ctx, &addOnService, fmt.Sprintf("/addon-services/%v", addOnServiceIdentity), nil, nil)
} | go | {
"resource": ""
} |
q19896 | AddOnServiceList | train | func (s *Service) AddOnServiceList(ctx context.Context, lr *ListRange) (AddOnServiceListResult, error) {
var addOnService AddOnServiceListResult
return addOnService, s.Get(ctx, &addOnService, fmt.Sprintf("/addon-services"), nil, lr)
} | go | {
"resource": ""
} |
q19897 | AddOnWebhookCreate | train | func (s *Service) AddOnWebhookCreate(ctx context.Context, addOnIdentity string, o AddOnWebhookCreateOpts) (*AddOnWebhookCreateResult, error) {
var addOnWebhook AddOnWebhookCreateResult
return &addOnWebhook, s.Post(ctx, &addOnWebhook, fmt.Sprintf("/addons/%v/webhooks", addOnIdentity), o)
} | go | {
"resource": ""
} |
q19898 | AddOnWebhookDelete | train | func (s *Service) AddOnWebhookDelete(ctx context.Context, addOnIdentity string, appWebhookIdentity string) (*AddOnWebhookDeleteResult, error) {
var addOnWebhook AddOnWebhookDeleteResult
return &addOnWebhook, s.Delete(ctx, &addOnWebhook, fmt.Sprintf("/addons/%v/webhooks/%v", addOnIdentity, appWebhookIdentity))
} | go | {
"resource": ""
} |
q19899 | AddOnWebhookInfo | train | func (s *Service) AddOnWebhookInfo(ctx context.Context, addOnIdentity string, appWebhookIdentity string) (*AddOnWebhookInfoResult, error) {
var addOnWebhook AddOnWebhookInfoResult
return &addOnWebhook, s.Get(ctx, &addOnWebhook, fmt.Sprintf("/addons/%v/webhooks/%v", addOnIdentity, appWebhookIdentity), nil, nil)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.