id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c25800 |
first = strings.Trim(pp.Value, `"`)
}
continue
}
others = append(others, p)
}
return
} | |
c25801 | utils.CamelCase(tb.Name))
for _, v := range tb.Columns {
rv += v.String() + "\n"
}
rv += "}\n"
return rv
} | |
c25802 | ormOptions = append(ormOptions, fmt.Sprintf("digits(%s);decimals(%s)", tag.Digits, tag.Decimals))
}
if tag.RelFk {
ormOptions = append(ormOptions, "rel(fk)")
}
if tag.RelOne {
ormOptions = append(ormOptions, "rel(one)")
}
if tag.ReverseOne {
ormOptions = append(ormOptions, "reverse(one)")
}
if tag.Rever... | |
c25803 | = tableName
tb.Fk = make(map[string]*ForeignKey)
dbTransformer.GetConstraints(db, tb, blackList)
tables = append(tables, tb)
}
// process columns, ignoring blacklisted tables
for _, tb := range tables {
dbTransformer.GetColumns(db, tb, blackList)
}
return
} | |
c25804 | }
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | |
c25805 |
}
defer rows.Close()
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
beeLogger.Log.Fatalf("Could not show tables: %s", err)
}
tables = append(tables, name)
}
return
} | |
c25806 | string(refTableSchemaBytes),
string(refTableNameBytes), string(refColumnNameBytes), string(refOrdinalPosBytes)
if constraintType == "PRIMARY KEY" {
if refOrdinalPos == "1" {
table.Pk = columnName
} else {
table.Pk = ""
// add table to blacklist so that other struct will not reference it, because... | |
c25807 | }
return "", fmt.Errorf("data type '%s' not found", sqlType)
} | |
c25808 | {
os.Mkdir(paths.ControllerPath, 0777)
}
if (mode & ORouter) == ORouter {
os.Mkdir(paths.RouterPath, 0777)
}
} | |
c25809 |
fileStr = strings.Replace(fileStr, "{{tableName}}", tb.Name, -1)
// If table contains time field, import time.Time package
timePkg := ""
importTimePkg := ""
if tb.ImportTimePkg {
timePkg = "\"time\"\n"
importTimePkg = "import \"time\"\n"
}
fileStr = strings.Replace(fileStr, "{{timePkg}}", timePkg,... | |
c25810 |
beeLogger.Log.Warnf("%s", err)
continue
}
}
fileStr := strings.Replace(CtrlTPL, "{{ctrlName}}", utils.CamelCase(tb.Name), -1)
fileStr = strings.Replace(fileStr, "{{pkgPath}}", pkgPath, -1)
if _, err := f.WriteString(fileStr); err != nil {
beeLogger.Log.Fatalf("Could not write controller file to '... | |
c25811 | else {
beeLogger.Log.Warnf("Skipped create file '%s'", fpath)
return
}
} else {
f, err = os.OpenFile(fpath, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
beeLogger.Log.Warnf("%s", err)
return
}
}
if _, err := f.WriteString(routerStr); err != nil {
beeLogger.Log.Fatalf("Could not write router fi... | |
c25812 | != nil {
beeLogger.Log.Fatalf("Error while trying to read the banner: %s", err)
}
show(out, string(banner))
} | |
c25813 |
return colors.NewColorWriter(os.Stderr)
} | |
c25814 | beeLogger.Log.Errorf("An error happened when reading from the Websocket client: %v", err)
}
break
}
}
} | |
c25815 | broker: broker,
conn: conn,
send: make(chan []byte, 256),
}
client.broker.register <- client
go client.writePump()
client.readPump()
} | |
c25816 | }
}
}
// Check format version
if Conf.Version != confVer {
beeLogger.Log.Warn("Your configuration file is outdated. Please do consider updating it.")
beeLogger.Log.Hint("Check the latest version of bee's configuration file.")
}
// Set variables
if len(Conf.DirStruct.Controllers) == 0 {
Conf.DirStruct... | |
c25817 | strings.Contains(thePath, filepath.Join(gopath, "src")) {
return true
}
}
return false
} | |
c25818 | return nil
}
if len(hasBeegoRegex.Find(data)) > 0 {
mainFiles = append(mainFiles, fpath)
}
}
return nil
})
close(c)
}()
if err := <-c; err != nil {
beeLogger.Log.Fatalf("Unable to walk '%s' tree: %s", thePath, err)
}
if len(mainFiles) > 0 {
return true
}
return false
} | |
c25819 | != '_' {
j = true
}
data = append(data, d)
}
return strings.ToLower(string(data[:]))
} | |
c25820 | {
beeLogger.Log.Warnf("Error while running gofmt: %s", err)
}
} | |
c25821 | CloseFile(f)
_, err = f.WriteString(content)
MustCheck(err)
} | |
c25822 | colors.Bold,
"headline": colors.MagentaBold,
"foldername": colors.RedBold,
"endline": EndLine,
"tmpltostr": TmplToString,
}
} | |
c25823 |
template.Must(t.Parse(tmpl))
var doc bytes.Buffer
err := t.Execute(&doc, data)
MustCheck(err)
return doc.String()
} | |
c25824 | fi, err := f.Stat()
if err != nil {
beeLogger.Log.Errorf("Failed to get file stats: %s", err)
return time.Now().Unix()
}
return fi.ModTime().Unix()
} | |
c25825 | == 0 {
// run all outstanding migrations
beeLogger.Log.Info("Running all outstanding migrations")
MigrateUpdate(currpath, driverStr, connStr, dirStr)
} else {
mcmd := args[0]
switch mcmd {
case "rollback":
beeLogger.Log.Info("Rolling back the last migration operation")
MigrateRollback(currpath, driv... | |
c25826 | if err != nil {
beeLogger.Log.Fatalf("Could not connect to database using '%s': %s", connStr, err)
}
defer db.Close()
checkForSchemaUpdateTable(db, driver)
latestName, latestTime := getLatestMigration(db, goal)
writeMigrationSourceFile(dir, source, driver, connStr, latestTime, latestName, goal)
buildMigration... | |
c25827 | "auto_increment" {
beeLogger.Log.Hint("Expecting KEY: PRI, EXTRA: auto_increment")
beeLogger.Log.Fatalf("Column migration.id_migration type mismatch: KEY: %s, EXTRA: %s", keyStr, extraStr)
}
} else if fieldStr == "name" {
if !strings.HasPrefix(typeStr, "varchar") || nullStr != "YES" {
beeLogg... | |
c25828 | content = strings.Replace(content, "{{LatestTime}}", strconv.FormatInt(latestTime, 10), -1)
content = strings.Replace(content, "{{LatestName}}", latestName, -1)
content = strings.Replace(content, "{{Task}}", task, -1)
if _, err := f.WriteString(content); err != nil {
beeLogger.Log.Fatalf("Could not write to ... | |
c25829 | beeLogger.Log.Fatalf("Could not find migration directory: %s", err)
}
} | |
c25830 | os.Remove(file); err != nil {
beeLogger.Log.Warnf("Could not remove temporary file: %s", err)
}
} | |
c25831 |
beeLogger.Log.Errorf("|> %s", line)
}
}
} | |
c25832 |
beeLogger.Log.Infof("|> %s", line)
}
}
} | |
c25833 | migrate("upgrade", currpath, driver, connStr, dir)
} | |
c25834 | migrate("rollback", currpath, driver, connStr, dir)
} | |
c25835 | migrate("reset", currpath, driver, connStr, dir)
} | |
c25836 | migrate("refresh", currpath, driver, connStr, dir)
} | |
c25837 | }
absFilePath, err := path.Abs(filePath)
if err != nil {
beeLogger.Log.Errorf("Cannot get absolute path of '%s'", filePath)
break
}
if strings.HasPrefix(absFilePath, absP) {
beeLogger.Log.Infof("'%s' is not being watched", filePath)
return true
}
}
return false
} | |
c25838 | &colorWriter{
w: w,
mode: mode,
}
}
return w
} | |
c25839 | bytes.NewBufferString(colors.MagentaBold(shortVersionBanner)))
} | |
c25840 | time.Now().Add(1 * time.Second)
time.Sleep(time.Until(scheduleTime))
AutoBuild(files, isgenerate)
if config.Conf.EnableReload {
// Wait 100ms more before refreshing the browser
time.Sleep(100 * time.Millisecond)
sendReload(e.String())
}
}()
}
case err := <-watc... | |
c25841 |
}
args := []string{"build"}
args = append(args, "-o", appName)
if buildTags != "" {
args = append(args, "-tags", buildTags)
}
args = append(args, files...)
bcmd := exec.Command(cmdName, args...)
bcmd.Env = append(os.Environ(), "GOGC=off")
bcmd.Stderr = &stderr
err = bcmd.Run()
if err != nil ... | |
c25842 | select {
case <-ch:
return
case <-time.After(10 * time.Second):
beeLogger.Log.Info("Timeout. Force kill cmd process")
err := cmd.Process.Kill()
if err != nil {
beeLogger.Log.Errorf("Error while killing cmd process: %s", err)
}
return
}
}
} | |
c25843 | running process", utils.FILE(), utils.LINE())
Kill()
go Start(appname)
} | |
c25844 | append([]string{appname}, m...)
} else {
cmd.Args = append([]string{appname}, config.Conf.CmdArgs...)
}
cmd.Env = append(os.Environ(), config.Conf.Envs...)
go cmd.Run()
beeLogger.Log.Successf("'%s' is running...", appname)
started <- true
} | |
c25845 | if err != nil {
beeLogger.Log.Fatalf("Could not compile regular expression: %s", err)
}
if r.MatchString(filename) {
return true
}
continue
}
return false
} | |
c25846 | := range watchExts {
if strings.HasSuffix(name, s) {
return true
}
}
return false
} | |
c25847 | logRecordTemplate, err = template.New("simpleLogFormat").Funcs(funcs).Parse(simpleLogFormat)
if err != nil {
panic(err)
}
debugLogRecordTemplate, err = template.New("debugLogFormat").Funcs(funcs).Parse(debugLogFormat)
if err != nil {
panic(err)
}
instance = &BeeLogger{output: colors.NewColorWriter(w... | |
c25848 | l.output = colors.NewColorWriter(w)
} | |
c25849 | fmt.Sprintf("%04d", atomic.AddUint64(&sequenceNo, 1)),
Level: l.getColorLevel(level),
Message: fmt.Sprintf(message, args...),
}
err := logRecordTemplate.Execute(l.output, record)
if err != nil {
panic(err)
}
} | |
c25850 | l.getColorLevel(levelDebug),
Message: fmt.Sprintf(message, args...),
LineNo: line,
Filename: filepath.Base(file),
}
err := debugLogRecordTemplate.Execute(l.output, record)
if err != nil {
panic(err)
}
} | |
c25851 |
l.mustLogDebug(message, file, line)
} | |
c25852 | {
l.mustLogDebug(message, file, line, vars...)
} | |
c25853 | ...interface{}) {
l.mustLog(levelInfo, message, vars...)
} | |
c25854 | ...interface{}) {
l.mustLog(levelWarn, message, vars...)
} | |
c25855 | ...interface{}) {
l.mustLog(levelError, message, vars...)
} | |
c25856 | l.mustLog(levelFatal, message)
os.Exit(255)
} | |
c25857 | l.mustLog(levelFatal, message, vars...)
os.Exit(255)
} | |
c25858 | l.mustLog(levelSuccess, message, vars...)
} | |
c25859 | ...interface{}) {
l.mustLog(levelHint, message, vars...)
} | |
c25860 | l.mustLog(levelCritical, message, vars...)
} | |
c25861 |
if len(orgs) == 0 {
return Organization{}, Warnings(warnings), actionerror.OrganizationNotFoundError{Name: name}
}
return Organization(orgs[0]), Warnings(warnings), nil
} | |
c25862 | = name
config.ConfigFile.TargetedOrganization.QuotaDefinition = QuotaDefinition{}
} | |
c25863 | name)
config.ConfigFile.TargetedSpace.AllowSSH = allowSSH
} | |
c25864 | config.ConfigFile.DopplerEndpoint = doppler
config.ConfigFile.RoutingEndpoint = routing
config.ConfigFile.SkipSSLValidation = skipSSLValidation
config.UnsetOrganizationAndSpaceInformation()
} | |
c25865 | string) {
config.ConfigFile.UAAOAuthClient = client
config.ConfigFile.UAAOAuthClientSecret = clientSecret
} | |
c25866 | guid
config.ConfigFile.TargetedSpace.Name = name
} | |
c25867 | config,
SharedActor: sharedActor,
UAAClient: uaaClient,
}
} | |
c25868 |
serviceBinding.GUID = ccServiceBinding.Metadata.GUID
serviceBinding.ServiceInstanceGUID = ccServiceBinding.Entity.ServiceInstanceGUID
serviceBinding.Name = ccServiceBinding.Entity.Name
serviceBinding.LastOperation = ccServiceBinding.Entity.LastOperation
return nil
} | |
c25869 | Query: url.Values{"accepts_incomplete": {fmt.Sprint(acceptsIncomplete)}},
})
if err != nil {
return ServiceBinding{}, nil, err
}
var response cloudcontroller.Response
var serviceBinding ServiceBinding
if acceptsIncomplete {
response = cloudcontroller.Response{
DecodeJSONResponseInto: &serviceBindin... | |
c25870 |
var serviceBinding ServiceBinding
response := cloudcontroller.Response{
DecodeJSONResponseInto: &serviceBinding,
}
err = client.connection.Make(request, &response)
return serviceBinding, response.Warnings, err
} | |
c25871 |
}
var fullBindingsList []ServiceBinding
warnings, err := client.paginate(request, ServiceBinding{}, func(item interface{}) error {
if binding, ok := item.(ServiceBinding); ok {
fullBindingsList = append(fullBindingsList, binding)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceBi... | |
c25872 | := item.(ServiceBinding); ok {
fullBindingsList = append(fullBindingsList, binding)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceBinding{},
Unexpected: item,
}
}
return nil
})
return fullBindingsList, warnings, err
} | |
c25873 | var featureFlags []FeatureFlag
response := cloudcontroller.Response{
DecodeJSONResponseInto: &featureFlags,
}
err = client.connection.Make(request, &response)
return featureFlags, response.Warnings, err
} | |
c25874 | {
client.connection = wrapper.Wrap(client.connection)
} | |
c25875 | "", "", "", "", "", false)
actor.Config.SetTokenInformation("", "", "")
} | |
c25876 | }
space.GUID = ccSpace.Metadata.GUID
space.Name = ccSpace.Entity.Name
space.AllowSSH = ccSpace.Entity.AllowSSH
space.SpaceQuotaDefinitionGUID = ccSpace.Entity.SpaceQuotaDefinitionGUID
space.OrganizationGUID = ccSpace.Entity.OrganizationGUID
return nil
} | |
c25877 | client.newHTTPRequest(requestOptions{
RequestName: internal.PostSpaceRequest,
Body: bytes.NewReader(bodyBytes),
})
if err != nil {
return Space{}, nil, err
}
var space Space
response := cloudcontroller.Response{
DecodeJSONResponseInto: &space,
}
err = client.connection.Make(request, &response)... | |
c25878 |
}
var job Job
response := cloudcontroller.Response{
DecodeJSONResponseInto: &job,
}
err = client.connection.Make(request, &response)
return job, response.Warnings, err
} | |
c25879 | := item.(Space); ok {
fullSpacesList = append(fullSpacesList, space)
} else {
return ccerror.UnknownObjectInListError{
Expected: Space{},
Unexpected: item,
}
}
return nil
})
return fullSpacesList, warnings, err
} | |
c25880 | item.(Space); ok {
fullSpacesList = append(fullSpacesList, space)
} else {
return ccerror.UnknownObjectInListError{
Expected: Space{},
Unexpected: item,
}
}
return nil
})
return fullSpacesList, warnings, err
} | |
c25881 | URIParams: map[string]string{
"space_guid": spaceGUID,
"developer_guid": uaaID,
},
})
if err != nil {
return Warnings{}, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c25882 |
Body: bytes.NewReader(bodyBytes),
})
if err != nil {
return nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c25883 |
info.Links.UAA = link
return info
} | |
c25884 |
})
if err != nil {
return ServiceKey{}, nil, err
}
var serviceKey ServiceKey
response := cloudcontroller.Response{
DecodeJSONResponseInto: &serviceKey,
}
err = client.connection.Make(request, &response)
return serviceKey, response.Warnings, err
} | |
c25885 | err = actor.client.DownloadPlugin(pluginURL, tempFile.Name(), proxyReader)
if err != nil {
return "", err
}
return tempFile.Name(), nil
} | |
c25886 | err := os.Stat(path)
return err == nil
} | |
c25887 | j int) bool {
return strings.ToLower(p.Commands[i].Name) < strings.ToLower(p.Commands[j].Name)
})
return p.Commands
} | |
c25888 | notApplicable
}
return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Build)
} | |
c25889 | fmt.Sprintf("%s, %s", c.Name, c.Alias)
}
return c.Name
} | |
c25890 | config.pluginsConfig.Plugins[plugin.Name] = plugin
} | |
c25891 | := config.pluginsConfig.Plugins[pluginName]
return plugin, exists
} | |
c25892 | := range config.pluginsConfig.Plugins {
if strings.EqualFold(name, pluginName) {
return plugin, true
}
}
return Plugin{}, false
} | |
c25893 | string) {
delete(config.pluginsConfig.Plugins, pluginName)
} | |
c25894 | {
return err
}
// Write to file
return ioutil.WriteFile(filepath.Join(pluginFileDir, "config.json"), rawConfig, 0600)
} | |
c25895 | &Actor{config: config, client: client}
} | |
c25896 | Params{"service_guid": serviceGUID},
})
if err != nil {
return nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c25897 | (see test stub JSON
// response). This unmarshal strips escaped quotes, at which time we can then
// unmarshal into the ServiceExtra object.
// If 'extra' is null or not provided, this means sharing is NOT enabled
if len(ccService.Entity.Extra) != 0 {
extra := ServiceExtra{}
err = json.Unmarshal([]byte(ccServi... | |
c25898 |
}
var service Service
response := cloudcontroller.Response{
DecodeJSONResponseInto: &service,
}
err = client.connection.Make(request, &response)
return service, response.Warnings, err
} | |
c25899 | ConvertFilterParameters(filters),
}
return client.makeServicesRequest(opts)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.