_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q25800 | analyseNewNamespace | train | func analyseNewNamespace(ce *ast.CallExpr) (first string, others []ast.Expr) {
for i, p := range ce.Args {
if i == 0 {
switch pp := p.(type) {
case *ast.BasicLit:
first = strings.Trim(pp.Value, `"`)
}
continue
}
others = append(others, p)
}
return
} | go | {
"resource": ""
} |
q25801 | String | train | func (tb *Table) String() string {
rv := fmt.Sprintf("type %s struct {\n", utils.CamelCase(tb.Name))
for _, v := range tb.Columns {
rv += v.String() + "\n"
}
rv += "}\n"
return rv
} | go | {
"resource": ""
} |
q25802 | String | train | func (tag *OrmTag) String() string {
var ormOptions []string
if tag.Column != "" {
ormOptions = append(ormOptions, fmt.Sprintf("column(%s)", tag.Column))
}
if tag.Auto {
ormOptions = append(ormOptions, "auto")
}
if tag.Size != "" {
ormOptions = append(ormOptions, fmt.Sprintf("size(%s)", tag.Size))
}
if ta... | go | {
"resource": ""
} |
q25803 | getTableObjects | train | func getTableObjects(tableNames []string, db *sql.DB, dbTransformer DbTransformer) (tables []*Table) {
// if a table has a composite pk or doesn't have pk, we can't use it yet
// these tables will be put into blacklist so that other struct will not
// reference it.
blackList := make(map[string]bool)
// process con... | go | {
"resource": ""
} |
q25804 | GetGoDataType | train | func (*MysqlDB) GetGoDataType(sqlType string) (string, error) {
if v, ok := typeMappingMysql[sqlType]; ok {
return v, nil
}
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | go | {
"resource": ""
} |
q25805 | GetTableNames | train | func (*PostgresDB) GetTableNames(db *sql.DB) (tables []string) {
rows, err := db.Query(`
SELECT table_name FROM information_schema.tables
WHERE table_catalog = current_database() AND
table_type = 'BASE TABLE' AND
table_schema NOT IN ('pg_catalog', 'information_schema')`)
if err != nil {
beeLogger.Log.Fatalf... | go | {
"resource": ""
} |
q25806 | GetConstraints | train | func (*PostgresDB) GetConstraints(db *sql.DB, table *Table, blackList map[string]bool) {
rows, err := db.Query(
`SELECT
c.constraint_type,
u.column_name,
cu.table_catalog AS referenced_table_catalog,
cu.table_name AS referenced_table_name,
cu.column_name AS referenced_column_name,
u.ordinal_positio... | go | {
"resource": ""
} |
q25807 | GetGoDataType | train | func (*PostgresDB) GetGoDataType(sqlType string) (string, error) {
if v, ok := typeMappingPostgres[sqlType]; ok {
return v, nil
}
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | go | {
"resource": ""
} |
q25808 | createPaths | train | func createPaths(mode byte, paths *MvcPath) {
if (mode & OModel) == OModel {
os.Mkdir(paths.ModelPath, 0777)
}
if (mode & OController) == OController {
os.Mkdir(paths.ControllerPath, 0777)
}
if (mode & ORouter) == ORouter {
os.Mkdir(paths.RouterPath, 0777)
}
} | go | {
"resource": ""
} |
q25809 | writeModelFiles | train | func writeModelFiles(tables []*Table, mPath string) {
w := colors.NewColorWriter(os.Stdout)
for _, tb := range tables {
filename := getFileName(tb.Name)
fpath := path.Join(mPath, filename+".go")
var f *os.File
var err error
if utils.IsExist(fpath) {
beeLogger.Log.Warnf("'%s' already exists. Do you want ... | go | {
"resource": ""
} |
q25810 | writeControllerFiles | train | func writeControllerFiles(tables []*Table, cPath string, pkgPath string) {
w := colors.NewColorWriter(os.Stdout)
for _, tb := range tables {
if tb.Pk == "" {
continue
}
filename := getFileName(tb.Name)
fpath := path.Join(cPath, filename+".go")
var f *os.File
var err error
if utils.IsExist(fpath) {
... | go | {
"resource": ""
} |
q25811 | writeRouterFile | train | func writeRouterFile(tables []*Table, rPath string, pkgPath string) {
w := colors.NewColorWriter(os.Stdout)
var nameSpaces []string
for _, tb := range tables {
if tb.Pk == "" {
continue
}
// Add namespaces
nameSpace := strings.Replace(NamespaceTPL, "{{nameSpace}}", tb.Name, -1)
nameSpace = strings.Repl... | go | {
"resource": ""
} |
q25812 | InitBanner | train | func InitBanner(out io.Writer, in io.Reader) {
if in == nil {
beeLogger.Log.Fatal("The input is nil")
}
banner, err := ioutil.ReadAll(in)
if err != nil {
beeLogger.Log.Fatalf("Error while trying to read the banner: %s", err)
}
show(out, string(banner))
} | go | {
"resource": ""
} |
q25813 | Out | train | func (c *Command) Out() io.Writer {
if c.output != nil {
return *c.output
}
return colors.NewColorWriter(os.Stderr)
} | go | {
"resource": ""
} |
q25814 | readPump | train | func (c *wsClient) readPump() {
defer func() {
c.broker.unregister <- c
c.conn.Close()
}()
for {
_, _, err := c.conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
beeLogger.Log.Errorf("An error happened when reading from the Websocket client: %v", ... | go | {
"resource": ""
} |
q25815 | handleWsRequest | train | func handleWsRequest(broker *wsBroker, w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
beeLogger.Log.Errorf("error while upgrading server connection: %v", err)
return
}
client := &wsClient{
broker: broker,
conn: conn,
send: make(chan []byte, 256),
}... | go | {
"resource": ""
} |
q25816 | LoadConfig | train | func LoadConfig() {
currentPath, err := os.Getwd()
if err != nil {
beeLogger.Log.Error(err.Error())
}
dir, err := os.Open(currentPath)
if err != nil {
beeLogger.Log.Error(err.Error())
}
defer dir.Close()
files, err := dir.Readdir(-1)
if err != nil {
beeLogger.Log.Error(err.Error())
}
for _, file := ... | go | {
"resource": ""
} |
q25817 | IsInGOPATH | train | func IsInGOPATH(thePath string) bool {
for _, gopath := range GetGOPATHs() {
if strings.Contains(thePath, filepath.Join(gopath, "src")) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q25818 | IsBeegoProject | train | func IsBeegoProject(thePath string) bool {
mainFiles := []string{}
hasBeegoRegex := regexp.MustCompile(`(?s)package main.*?import.*?\(.*?github.com/astaxie/beego".*?\).*func main()`)
c := make(chan error)
// Walk the application path tree to look for main files.
// Main files must satisfy the 'hasBeegoRegex' regul... | go | {
"resource": ""
} |
q25819 | SnakeString | train | func SnakeString(s string) string {
data := make([]byte, 0, len(s)*2)
j := false
num := len(s)
for i := 0; i < num; i++ {
d := s[i]
if i > 0 && d >= 'A' && d <= 'Z' && j {
data = append(data, '_')
}
if d != '_' {
j = true
}
data = append(data, d)
}
return strings.ToLower(string(data[:]))
} | go | {
"resource": ""
} |
q25820 | FormatSourceCode | train | func FormatSourceCode(filename string) {
cmd := exec.Command("gofmt", "-w", filename)
if err := cmd.Run(); err != nil {
beeLogger.Log.Warnf("Error while running gofmt: %s", err)
}
} | go | {
"resource": ""
} |
q25821 | WriteToFile | train | func WriteToFile(filename, content string) {
f, err := os.Create(filename)
MustCheck(err)
defer CloseFile(f)
_, err = f.WriteString(content)
MustCheck(err)
} | go | {
"resource": ""
} |
q25822 | BeeFuncMap | train | func BeeFuncMap() template.FuncMap {
return template.FuncMap{
"trim": strings.TrimSpace,
"bold": colors.Bold,
"headline": colors.MagentaBold,
"foldername": colors.RedBold,
"endline": EndLine,
"tmpltostr": TmplToString,
}
} | go | {
"resource": ""
} |
q25823 | TmplToString | train | func TmplToString(tmpl string, data interface{}) string {
t := template.New("tmpl").Funcs(BeeFuncMap())
template.Must(t.Parse(tmpl))
var doc bytes.Buffer
err := t.Execute(&doc, data)
MustCheck(err)
return doc.String()
} | go | {
"resource": ""
} |
q25824 | GetFileModTime | train | func GetFileModTime(path string) int64 {
path = strings.Replace(path, "\\", "/", -1)
f, err := os.Open(path)
if err != nil {
beeLogger.Log.Errorf("Failed to open file on '%s': %s", path, err)
return time.Now().Unix()
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
beeLogger.Log.Errorf("Failed to get... | go | {
"resource": ""
} |
q25825 | RunMigration | train | func RunMigration(cmd *commands.Command, args []string) int {
currpath, _ := os.Getwd()
gps := utils.GetGOPATHs()
if len(gps) == 0 {
beeLogger.Log.Fatal("GOPATH environment variable is not set or empty")
}
gopath := gps[0]
beeLogger.Log.Debugf("GOPATH: %s", utils.FILE(), utils.LINE(), gopath)
// Getting co... | go | {
"resource": ""
} |
q25826 | migrate | train | func migrate(goal, currpath, driver, connStr, dir string) {
if dir == "" {
dir = path.Join(currpath, "database", "migrations")
}
postfix := ""
if runtime.GOOS == "windows" {
postfix = ".exe"
}
binary := "m" + postfix
source := binary + ".go"
// Connect to database
db, err := sql.Open(driver, connStr)
if ... | go | {
"resource": ""
} |
q25827 | checkForSchemaUpdateTable | train | func checkForSchemaUpdateTable(db *sql.DB, driver string) {
showTableSQL := showMigrationsTableSQL(driver)
if rows, err := db.Query(showTableSQL); err != nil {
beeLogger.Log.Fatalf("Could not show migrations table: %s", err)
} else if !rows.Next() {
// No migrations table, create new ones
createTableSQL := cre... | go | {
"resource": ""
} |
q25828 | writeMigrationSourceFile | train | func writeMigrationSourceFile(dir, source, driver, connStr string, latestTime int64, latestName string, task string) {
changeDir(dir)
if f, err := os.OpenFile(source, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666); err != nil {
beeLogger.Log.Fatalf("Could not create file: %s", err)
} else {
content := strings.Replace(Mi... | go | {
"resource": ""
} |
q25829 | changeDir | train | func changeDir(dir string) {
if err := os.Chdir(dir); err != nil {
beeLogger.Log.Fatalf("Could not find migration directory: %s", err)
}
} | go | {
"resource": ""
} |
q25830 | removeTempFile | train | func removeTempFile(dir, file string) {
changeDir(dir)
if err := os.Remove(file); err != nil {
beeLogger.Log.Warnf("Could not remove temporary file: %s", err)
}
} | go | {
"resource": ""
} |
q25831 | formatShellErrOutput | train | func formatShellErrOutput(o string) {
for _, line := range strings.Split(o, "\n") {
if line != "" {
beeLogger.Log.Errorf("|> %s", line)
}
}
} | go | {
"resource": ""
} |
q25832 | formatShellOutput | train | func formatShellOutput(o string) {
for _, line := range strings.Split(o, "\n") {
if line != "" {
beeLogger.Log.Infof("|> %s", line)
}
}
} | go | {
"resource": ""
} |
q25833 | MigrateUpdate | train | func MigrateUpdate(currpath, driver, connStr, dir string) {
migrate("upgrade", currpath, driver, connStr, dir)
} | go | {
"resource": ""
} |
q25834 | MigrateRollback | train | func MigrateRollback(currpath, driver, connStr, dir string) {
migrate("rollback", currpath, driver, connStr, dir)
} | go | {
"resource": ""
} |
q25835 | MigrateReset | train | func MigrateReset(currpath, driver, connStr, dir string) {
migrate("reset", currpath, driver, connStr, dir)
} | go | {
"resource": ""
} |
q25836 | MigrateRefresh | train | func MigrateRefresh(currpath, driver, connStr, dir string) {
migrate("refresh", currpath, driver, connStr, dir)
} | go | {
"resource": ""
} |
q25837 | isExcluded | train | func isExcluded(filePath string) bool {
for _, p := range excludedPaths {
absP, err := path.Abs(p)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", p)
continue
}
absFilePath, err := path.Abs(filePath)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", fi... | go | {
"resource": ""
} |
q25838 | NewModeColorWriter | train | func NewModeColorWriter(w io.Writer, mode outputMode) io.Writer {
if _, ok := w.(*colorWriter); !ok {
return &colorWriter{
w: w,
mode: mode,
}
}
return w
} | go | {
"resource": ""
} |
q25839 | ShowShortVersionBanner | train | func ShowShortVersionBanner() {
output := colors.NewColorWriter(os.Stdout)
InitBanner(output, bytes.NewBufferString(colors.MagentaBold(shortVersionBanner)))
} | go | {
"resource": ""
} |
q25840 | NewWatcher | train | func NewWatcher(paths []string, files []string, isgenerate bool) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
beeLogger.Log.Fatalf("Failed to create watcher: %s", err)
}
go func() {
for {
select {
case e := <-watcher.Events:
isBuild := true
if ifStaticFile(e.Name) && config.Conf.Enabl... | go | {
"resource": ""
} |
q25841 | AutoBuild | train | func AutoBuild(files []string, isgenerate bool) {
state.Lock()
defer state.Unlock()
os.Chdir(currpath)
cmdName := "go"
var (
err error
stderr bytes.Buffer
)
// For applications use full import path like "github.com/.../.."
// are able to use "go install" to reduce build time.
if config.Conf.GoInstall... | go | {
"resource": ""
} |
q25842 | Kill | train | func Kill() {
defer func() {
if e := recover(); e != nil {
beeLogger.Log.Infof("Kill recover: %s", e)
}
}()
if cmd != nil && cmd.Process != nil {
// Windows does not support Interrupt
if runtime.GOOS == "windows" {
cmd.Process.Signal(os.Kill)
} else {
cmd.Process.Signal(os.Interrupt)
}
ch := ... | go | {
"resource": ""
} |
q25843 | Restart | train | func Restart(appname string) {
beeLogger.Log.Debugf("Kill running process", utils.FILE(), utils.LINE())
Kill()
go Start(appname)
} | go | {
"resource": ""
} |
q25844 | Start | train | func Start(appname string) {
beeLogger.Log.Infof("Restarting '%s'...", appname)
if !strings.Contains(appname, "./") {
appname = "./" + appname
}
cmd = exec.Command(appname)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if runargs != "" {
r := regexp.MustCompile("'.+'|\".+\"|\\S+")
m := r.FindAllString(run... | go | {
"resource": ""
} |
q25845 | shouldIgnoreFile | train | func shouldIgnoreFile(filename string) bool {
for _, regex := range ignoredFilesRegExps {
r, err := regexp.Compile(regex)
if err != nil {
beeLogger.Log.Fatalf("Could not compile regular expression: %s", err)
}
if r.MatchString(filename) {
return true
}
continue
}
return false
} | go | {
"resource": ""
} |
q25846 | shouldWatchFileWithExtension | train | func shouldWatchFileWithExtension(name string) bool {
for _, s := range watchExts {
if strings.HasSuffix(name, s) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q25847 | GetBeeLogger | train | func GetBeeLogger(w io.Writer) *BeeLogger {
once.Do(func() {
var (
err error
simpleLogFormat = `{{Now "2006/01/02 15:04:05"}} {{.Level}} ▶ {{.ID}} {{.Message}}{{EndLine}}`
debugLogFormat = `{{Now "2006/01/02 15:04:05"}} {{.Level}} ▶ {{.ID}} {{.Filename}}:{{.LineNo}} {{.Message}}{{EndLine}}`
)... | go | {
"resource": ""
} |
q25848 | SetOutput | train | func (l *BeeLogger) SetOutput(w io.Writer) {
l.mu.Lock()
defer l.mu.Unlock()
l.output = colors.NewColorWriter(w)
} | go | {
"resource": ""
} |
q25849 | mustLog | train | func (l *BeeLogger) mustLog(level int, message string, args ...interface{}) {
if level > logLevel {
return
}
// Acquire the lock
l.mu.Lock()
defer l.mu.Unlock()
// Create the logging record and pass into the output
record := LogRecord{
ID: fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level:... | go | {
"resource": ""
} |
q25850 | mustLogDebug | train | func (l *BeeLogger) mustLogDebug(message string, file string, line int, args ...interface{}) {
if !debugMode {
return
}
// Change the output to Stderr
l.SetOutput(os.Stderr)
// Create the log record
record := LogRecord{
ID: fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level: l.getColorL... | go | {
"resource": ""
} |
q25851 | Debug | train | func (l *BeeLogger) Debug(message string, file string, line int) {
l.mustLogDebug(message, file, line)
} | go | {
"resource": ""
} |
q25852 | Debugf | train | func (l *BeeLogger) Debugf(message string, file string, line int, vars ...interface{}) {
l.mustLogDebug(message, file, line, vars...)
} | go | {
"resource": ""
} |
q25853 | Infof | train | func (l *BeeLogger) Infof(message string, vars ...interface{}) {
l.mustLog(levelInfo, message, vars...)
} | go | {
"resource": ""
} |
q25854 | Warnf | train | func (l *BeeLogger) Warnf(message string, vars ...interface{}) {
l.mustLog(levelWarn, message, vars...)
} | go | {
"resource": ""
} |
q25855 | Errorf | train | func (l *BeeLogger) Errorf(message string, vars ...interface{}) {
l.mustLog(levelError, message, vars...)
} | go | {
"resource": ""
} |
q25856 | Fatal | train | func (l *BeeLogger) Fatal(message string) {
l.mustLog(levelFatal, message)
os.Exit(255)
} | go | {
"resource": ""
} |
q25857 | Fatalf | train | func (l *BeeLogger) Fatalf(message string, vars ...interface{}) {
l.mustLog(levelFatal, message, vars...)
os.Exit(255)
} | go | {
"resource": ""
} |
q25858 | Successf | train | func (l *BeeLogger) Successf(message string, vars ...interface{}) {
l.mustLog(levelSuccess, message, vars...)
} | go | {
"resource": ""
} |
q25859 | Hintf | train | func (l *BeeLogger) Hintf(message string, vars ...interface{}) {
l.mustLog(levelHint, message, vars...)
} | go | {
"resource": ""
} |
q25860 | Criticalf | train | func (l *BeeLogger) Criticalf(message string, vars ...interface{}) {
l.mustLog(levelCritical, message, vars...)
} | go | {
"resource": ""
} |
q25861 | GetOrganizationByName | train | func (actor Actor) GetOrganizationByName(name string) (Organization, Warnings, error) {
orgs, warnings, err := actor.CloudControllerClient.GetOrganizations(
ccv3.Query{Key: ccv3.NameFilter, Values: []string{name}},
)
if err != nil {
return Organization{}, Warnings(warnings), err
}
if len(orgs) == 0 {
return... | go | {
"resource": ""
} |
q25862 | SetOrganizationInformation | train | func (config *Config) SetOrganizationInformation(guid string, name string) {
config.ConfigFile.TargetedOrganization.GUID = guid
config.ConfigFile.TargetedOrganization.Name = name
config.ConfigFile.TargetedOrganization.QuotaDefinition = QuotaDefinition{}
} | go | {
"resource": ""
} |
q25863 | SetSpaceInformation | train | func (config *Config) SetSpaceInformation(guid string, name string, allowSSH bool) {
config.V7SetSpaceInformation(guid, name)
config.ConfigFile.TargetedSpace.AllowSSH = allowSSH
} | go | {
"resource": ""
} |
q25864 | SetTargetInformation | train | func (config *Config) SetTargetInformation(api string, apiVersion string, auth string, minCLIVersion string, doppler string, routing string, skipSSLValidation bool) {
config.ConfigFile.Target = api
config.ConfigFile.APIVersion = apiVersion
config.ConfigFile.AuthorizationEndpoint = auth
config.SetMinCLIVersion(minCL... | go | {
"resource": ""
} |
q25865 | SetUAAClientCredentials | train | func (config *Config) SetUAAClientCredentials(client string, clientSecret string) {
config.ConfigFile.UAAOAuthClient = client
config.ConfigFile.UAAOAuthClientSecret = clientSecret
} | go | {
"resource": ""
} |
q25866 | V7SetSpaceInformation | train | func (config *Config) V7SetSpaceInformation(guid string, name string) {
config.ConfigFile.TargetedSpace.GUID = guid
config.ConfigFile.TargetedSpace.Name = name
} | go | {
"resource": ""
} |
q25867 | NewActor | train | func NewActor(client CloudControllerClient, config Config, sharedActor SharedActor, uaaClient UAAClient) *Actor {
return &Actor{
CloudControllerClient: client,
Config: config,
SharedActor: sharedActor,
UAAClient: uaaClient,
}
} | go | {
"resource": ""
} |
q25868 | UnmarshalJSON | train | func (serviceBinding *ServiceBinding) UnmarshalJSON(data []byte) error {
var ccServiceBinding struct {
Metadata internal.Metadata
Entity struct {
AppGUID string `json:"app_guid"`
ServiceInstanceGUID string `json:"service_instance_guid"`
Name string `json:"... | go | {
"resource": ""
} |
q25869 | DeleteServiceBinding | train | func (client *Client) DeleteServiceBinding(serviceBindingGUID string, acceptsIncomplete bool) (ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.DeleteServiceBindingRequest,
URIParams: map[string]string{"service_binding_guid": serviceBindingGUID},
Qu... | go | {
"resource": ""
} |
q25870 | GetServiceBinding | train | func (client *Client) GetServiceBinding(guid string) (ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceBindingRequest,
URIParams: Params{"service_binding_guid": guid},
})
if err != nil {
return ServiceBinding{}, nil, err
}
var service... | go | {
"resource": ""
} |
q25871 | GetServiceBindings | train | func (client *Client) GetServiceBindings(filters ...Filter) ([]ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceBindingsRequest,
Query: ConvertFilterParameters(filters),
})
if err != nil {
return nil, nil, err
}
var fullBindingsLi... | go | {
"resource": ""
} |
q25872 | GetServiceInstanceServiceBindings | train | func (client *Client) GetServiceInstanceServiceBindings(serviceInstanceGUID string) ([]ServiceBinding, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceInstanceServiceBindingsRequest,
URIParams: map[string]string{"service_instance_guid": serviceInstanceGUID... | go | {
"resource": ""
} |
q25873 | GetConfigFeatureFlags | train | func (client Client) GetConfigFeatureFlags() ([]FeatureFlag, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetConfigFeatureFlagsRequest,
})
if err != nil {
return nil, nil, err
}
var featureFlags []FeatureFlag
response := cloudcontroller.Response{
DecodeJSON... | go | {
"resource": ""
} |
q25874 | WrapConnection | train | func (client *Client) WrapConnection(wrapper ConnectionWrapper) {
client.connection = wrapper.Wrap(client.connection)
} | go | {
"resource": ""
} |
q25875 | ClearTarget | train | func (actor Actor) ClearTarget() {
actor.Config.SetTargetInformation("", "", "", "", "", "", false)
actor.Config.SetTokenInformation("", "", "")
} | go | {
"resource": ""
} |
q25876 | UnmarshalJSON | train | func (space *Space) UnmarshalJSON(data []byte) error {
var ccSpace struct {
Metadata internal.Metadata `json:"metadata"`
Entity struct {
Name string `json:"name"`
AllowSSH bool `json:"allow_ssh"`
SpaceQuotaDefinitionGUID string `json:"space_quota_definition_guid"`
... | go | {
"resource": ""
} |
q25877 | CreateSpace | train | func (client *Client) CreateSpace(spaceName string, orgGUID string) (Space, Warnings, error) {
requestBody := createSpaceRequestBody{
Name: spaceName,
OrganizationGUID: orgGUID,
}
bodyBytes, _ := json.Marshal(requestBody)
request, err := client.newHTTPRequest(requestOptions{
RequestName: interna... | go | {
"resource": ""
} |
q25878 | DeleteSpace | train | func (client *Client) DeleteSpace(guid string) (Job, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.DeleteSpaceRequest,
URIParams: Params{"space_guid": guid},
Query: url.Values{
"recursive": {"true"},
"async": {"true"},
},
})
if err != nil {
retur... | go | {
"resource": ""
} |
q25879 | GetSecurityGroupSpaces | train | func (client *Client) GetSecurityGroupSpaces(securityGroupGUID string) ([]Space, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetSecurityGroupSpacesRequest,
URIParams: map[string]string{"security_group_guid": securityGroupGUID},
})
if err != nil {
return nil,... | go | {
"resource": ""
} |
q25880 | GetSpaces | train | func (client *Client) GetSpaces(filters ...Filter) ([]Space, Warnings, error) {
params := ConvertFilterParameters(filters)
params.Add("order-by", "name")
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetSpacesRequest,
Query: params,
})
if err != nil {
return nil, nil, err
... | go | {
"resource": ""
} |
q25881 | UpdateSpaceDeveloper | train | func (client *Client) UpdateSpaceDeveloper(spaceGUID string, uaaID string) (Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.PutSpaceDeveloperRequest,
URIParams: map[string]string{
"space_guid": spaceGUID,
"developer_guid": uaaID,
},
})
if err != nil {
... | go | {
"resource": ""
} |
q25882 | UpdateSpaceManagerByUsername | train | func (client *Client) UpdateSpaceManagerByUsername(spaceGUID string, username string) (Warnings, error) {
requestBody := updateRoleRequestBody{
Username: username,
}
bodyBytes, err := json.Marshal(requestBody)
if err != nil {
return Warnings{}, err
}
request, err := client.newHTTPRequest(requestOptions{
Re... | go | {
"resource": ""
} |
q25883 | NewInfo | train | func NewInfo(link string) Info {
var info Info
info.Links.Login = link
info.Links.UAA = link
return info
} | go | {
"resource": ""
} |
q25884 | CreateServiceKey | train | func (client *Client) CreateServiceKey(serviceInstanceGUID string, keyName string, parameters map[string]interface{}) (ServiceKey, Warnings, error) {
requestBody := serviceKeyRequestBody{
ServiceInstanceGUID: serviceInstanceGUID,
Name: keyName,
Parameters: parameters,
}
bodyBytes, err ... | go | {
"resource": ""
} |
q25885 | DownloadExecutableBinaryFromURL | train | func (actor Actor) DownloadExecutableBinaryFromURL(pluginURL string, tempPluginDir string, proxyReader plugin.ProxyReader) (string, error) {
tempFile, err := makeTempFile(tempPluginDir)
if err != nil {
return "", err
}
err = actor.client.DownloadPlugin(pluginURL, tempFile.Name(), proxyReader)
if err != nil {
... | go | {
"resource": ""
} |
q25886 | FileExists | train | func (actor Actor) FileExists(path string) bool {
_, err := os.Stat(path)
return err == nil
} | go | {
"resource": ""
} |
q25887 | PluginCommands | train | func (p Plugin) PluginCommands() []PluginCommand {
sort.Slice(p.Commands, func(i, j int) bool {
return strings.ToLower(p.Commands[i].Name) < strings.ToLower(p.Commands[j].Name)
})
return p.Commands
} | go | {
"resource": ""
} |
q25888 | String | train | func (v PluginVersion) String() string {
if v.Major == 0 && v.Minor == 0 && v.Build == 0 {
return notApplicable
}
return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Build)
} | go | {
"resource": ""
} |
q25889 | CommandName | train | func (c PluginCommand) CommandName() string {
if c.Name != "" && c.Alias != "" {
return fmt.Sprintf("%s, %s", c.Name, c.Alias)
}
return c.Name
} | go | {
"resource": ""
} |
q25890 | AddPlugin | train | func (config *Config) AddPlugin(plugin Plugin) {
config.pluginsConfig.Plugins[plugin.Name] = plugin
} | go | {
"resource": ""
} |
q25891 | GetPlugin | train | func (config *Config) GetPlugin(pluginName string) (Plugin, bool) {
plugin, exists := config.pluginsConfig.Plugins[pluginName]
return plugin, exists
} | go | {
"resource": ""
} |
q25892 | GetPluginCaseInsensitive | train | func (config *Config) GetPluginCaseInsensitive(pluginName string) (Plugin, bool) {
for name, plugin := range config.pluginsConfig.Plugins {
if strings.EqualFold(name, pluginName) {
return plugin, true
}
}
return Plugin{}, false
} | go | {
"resource": ""
} |
q25893 | RemovePlugin | train | func (config *Config) RemovePlugin(pluginName string) {
delete(config.pluginsConfig.Plugins, pluginName)
} | go | {
"resource": ""
} |
q25894 | WritePluginConfig | train | func (config *Config) WritePluginConfig() error {
// Marshal JSON
rawConfig, err := json.MarshalIndent(config.pluginsConfig, "", " ")
if err != nil {
return err
}
pluginFileDir := filepath.Join(config.PluginHome())
err = os.MkdirAll(pluginFileDir, 0700)
if err != nil {
return err
}
// Write to file
ret... | go | {
"resource": ""
} |
q25895 | NewActor | train | func NewActor(config Config, client PluginClient) *Actor {
return &Actor{config: config, client: client}
} | go | {
"resource": ""
} |
q25896 | DeleteService | train | func (client *Client) DeleteService(serviceGUID string, purge bool) (Warnings, error) {
queryParams := url.Values{}
queryParams.Set("purge", strconv.FormatBool(purge))
queryParams.Set("async", "true")
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.DeleteServiceRequest,
Query: ... | go | {
"resource": ""
} |
q25897 | UnmarshalJSON | train | func (service *Service) UnmarshalJSON(data []byte) error {
var ccService struct {
Metadata internal.Metadata
Entity struct {
Label string `json:"label"`
Description string `json:"description"`
DocumentationURL string `json:"documentation_url"`
ServiceBrokerName string `json:"servic... | go | {
"resource": ""
} |
q25898 | GetService | train | func (client *Client) GetService(serviceGUID string) (Service, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceRequest,
URIParams: Params{"service_guid": serviceGUID},
})
if err != nil {
return Service{}, nil, err
}
var service Service
response := ... | go | {
"resource": ""
} |
q25899 | GetServices | train | func (client *Client) GetServices(filters ...Filter) ([]Service, Warnings, error) {
opts := requestOptions{
RequestName: internal.GetServicesRequest,
Query: ConvertFilterParameters(filters),
}
return client.makeServicesRequest(opts)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.