id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c17900 | logger,
loggers: make(map[string]Node),
loggerMaker: defaultLoggerMaker,
}
} | |
c17901 | defer self.lock.Unlock()
self.loggerMaker = maker
} | |
c17902 |
} else {
switch node.Type() {
case NodePlaceHolder:
placeHolder, _ := node.(*PlaceHolder)
placeHolder.Append(logger)
case NodeLogger:
parent = logger
default:
panic("invalid node type")
}
}
index = strings.LastIndex(parentStr, ".")
}
if parent == nil {
parent = root
}
logger.... | |
c17903 |
if !strings.HasPrefix(parent.GetName(), name) {
logger.SetParent(parent)
l.SetParent(logger)
}
}
} | |
c17904 |
FileName: fileName,
LineNo: lineNo,
FuncName: funcName,
Format: format,
UseFormat: useFormat,
Args: args,
Message: "",
}
} | |
c17905 | %s, %s, %s, %d, \"%s\">",
self.Name, self.Level, self.PathName, self.LineNo, self.Message)
} | |
c17906 | } else {
self.Message = fmt.Sprint(self.Args...)
}
}
return self.Message
} | |
c17907 | := &StreamHandler{
BaseHandler: NewBaseHandler(name, level),
stream: stream,
}
Closer.AddHandler(object)
return object
} | |
c17908 | self.stream.Write(message); err != nil {
return err
}
return nil
} | |
c17909 |
}
Closer.AddHandler(object)
return object
} | |
c17910 | attrToFunc {
buf.WriteString("|")
buf.WriteString(regexp.QuoteMeta(attr[1:]))
}
buf.WriteString("))")
re := buf.String()
return regexp.MustCompile(re)
} | |
c17911 | funs = append(funs, extractFunc)
}
return match
}
formatRe.ReplaceAllStringFunc(format, f2)
getFormatArgsFunc := func(record *LogRecord) []interface{} {
result := make([]interface{}, 0, len(funs))
for _, f := range funs {
result = append(result, f(record))
}
return result
}
var dateFormatter *str... | |
c17912 | fmt.Sprintf(self.strFormat, self.getFormatArgsFunc(record)...)
} | |
c17913 |
buf.WriteString(self.lineFormatter.Format(record))
}
buf.WriteString(self.FormatFooter(records))
}
return buf.String()
} | |
c17914 | eventHandlers,
eventFilters: eventFilters,
backgroundChans: make(map[string]chan string),
cmdChan: make(chan string),
reconnects: reconnects,
delayFunc: DelayFunc(),
logger: l,
}
if err = fsock.Connect(); err != nil {
return nil, err
}
return
} | |
c17915 | != nil)
self.fsMutex.RUnlock()
return
} | |
c17916 | != nil {
return err
} else if !strings.Contains(rply, "Reply-Text: +OK accepted") {
return fmt.Errorf("Unexpected auth reply received: <%s>", rply)
}
return nil
} | |
c17917 | return self.sendCmd(cmdStr + "\n")
} | |
c17918 | return self.sendCmd("api " + cmdStr + "\n")
} | |
c17919 | err = self.sendCmd(fmt.Sprintf("bgapi %s\nJob-UUID:%s\n", cmdStr, jobUuid))
if err != nil {
return nil, err
}
return
} | |
c17920 | reconnect
if err = self.ReconnectIfNeeded(); err != nil {
break
}
}
}
return err
} | |
c17921 | self.logger.Err(fmt.Sprintf("<FSock> Error reading headers: <%s>", err.Error()))
}
self.Disconnect()
return "", err
}
// No Error, add received to localread buffer
if len(bytes.TrimSpace(readLine)) == 0 {
break
}
bytesRead = append(bytesRead, readLine...)
}
return string(bytesRead), nil
} | |
c17922 | reading message body: <%s>", err.Error()))
}
self.Disconnect()
return "", err
}
// No Error, add received to local read buffer
bytesRead[i] = readByte
}
return string(bytesRead), nil
} | |
c17923 |
return
}
if strings.Contains(hdr, "api/response") {
self.cmdChan <- body
} else if strings.Contains(hdr, "command/reply") {
self.cmdChan <- headerVal(hdr, "Reply-Text")
} else if body != "" { // We got a body, could be event, try dispatching it
self.dispatchEvent(body)
}
}
} | |
c17924 | eventsCmd += " " + ev
}
if eventsCmd != "event plain all" {
eventsCmd += " BACKGROUND_JOB" // For bgapi
if len(customEvents) != 0 { // Add CUSTOM events subscribing in the end otherwise unexpected events are received
eventsCmd += " " + "CUSTOM" + customEvents
}
}
eventsCmd += "\n\n"
self.send(eventsC... | |
c17925 |
for _, handlerFunc := range self.eventHandlers[handleName] {
go handlerFunc(event, self.connId)
}
return
}
}
if self.logger != nil {
fmt.Printf("No dispatcher, event name: %s, handlers: %+v\n", eventName, self.eventHandlers)
self.logger.Warning(fmt.Sprintf("<FSock> No dispatcher for event: <%+v>",... | |
c17926 | with UUID %s lost!", jobUuid))
return // not a requested bgapi
}
self.fsMutex.Lock()
delete(self.backgroundChans, jobUuid)
self.fsMutex.Unlock()
out <- evMap[EventBodyTag]
} | |
c17927 | eventFilters: eventFilters,
logger: l,
allowedConns: make(chan struct{}, maxFSocks),
fSocks: make(chan *FSock, maxFSocks),
}
for i := 0; i < maxFSocks; i++ {
pool.allowedConns <- struct{}{} // Empty initiate so we do not need to wait later when we pop
}
return pool, nil
} | |
c17928 | {
continue // Loop again since we only work on filtered fields
}
fsevent[hdrVal[0]] = urlDecode(strings.TrimSpace(strings.TrimRight(hdrVal[1], "\n")))
}
}
return fsevent
} | |
c17929 | if len(hdrs) != len(chanInfo) {
continue
}
chnMp := make(map[string]string)
for iHdr, hdr := range hdrs {
chnMp[hdr] = chanInfo[iHdr]
}
chansInfoMap = append(chansInfoMap, chnMp)
}
return
} | |
c17930 |
return fmt.Sprintf("%x-%x-%x-%x-%x", b[:4], b[4:6], b[6:8], b[8:10],
b[10:])
} | |
c17931 | hdrEIdx == -1 {
hdrEIdx = len(hdrs[hdrSIdx:])
}
splt := strings.SplitN(hdrs[hdrSIdx:hdrSIdx+hdrEIdx], ": ", 2)
if len(splt) != 2 {
return ""
}
return strings.TrimSpace(strings.TrimRight(splt[1], "\n"))
} | |
c17932 | := url.QueryUnescape(hdrVal); errUnescaping == nil {
hdrVal = valUnescaped
}
return hdrVal
} | |
c17933 | s)
return (i < len(ss) && ss[i] == s)
} | |
c17934 | suspend: make(chan bool),
stop: make(chan struct{}),
},
}
go q.run()
runtime.SetFinalizer(q, (*Queue).Stop)
return q
} | |
c17935 | return q.count, len(q.buffer)
} | |
c17936 |
if err != nil {
return nil, nil, err
}
var p types.Plugin
rdr := bytes.NewReader(body)
err = json.NewDecoder(rdr).Decode(&p)
return &p, body, err
} | |
c17937 | []string{options.EncodedRegistryAuth},
}
}
query.Set("version", strconv.FormatUint(version.Index, 10))
resp, err := cli.post(ctx, "/services/"+serviceID+"/update", query, service, headers)
ensureReaderClosed(resp)
return err
} | |
c17938 | client = &http.Client{
Transport: &http.Transport{
TLSClientConfig: tlsc,
},
}
}
host := os.Getenv("DOCKER_HOST")
if host == "" {
host = DefaultDockerHost
}
version := os.Getenv("DOCKER_API_VERSION")
if version == "" {
version = DefaultVersion
}
return NewClient(host, version, client, nil)
} | |
c17939 | host,
proto: proto,
addr: addr,
basePath: basePath,
transport: transport,
version: version,
customHTTPHeaders: httpHeaders,
}, nil
} | |
c17940 | if err != nil {
return nil, err
}
query.Set("filters", filterJSON)
}
resp, err := cli.get(ctx, "/tasks", query, nil)
if err != nil {
return nil, err
}
var tasks []swarm.Task
err = json.NewDecoder(resp.body).Decode(&tasks)
ensureReaderClosed(resp)
return tasks, err
} | |
c17941 | error) {
networkResource, _, err := cli.NetworkInspectWithRaw(ctx, networkID)
return networkResource, err
} | |
c17942 | json.Marshal(a.fields)
if err != nil {
return "", err
}
return string(buf), nil
} | |
c17943 |
// Allow parsing old arguments in slice format.
// Because other libraries might be sending them in this format.
deprecated := map[string][]string{}
if deprecatedErr := d.Decode(&deprecated); deprecatedErr == nil {
m = deprecatedArgs(deprecated)
} else {
return NewArgs(), err
}
}
return Args{m}, ni... | |
c17944 | slice := make([]string, 0, len(values))
for key := range values {
slice = append(slice, key)
}
return slice
} | |
c17945 | else {
filters.fields[name] = map[string]bool{value: true}
}
} | |
c17946 | ok := filters.fields[name]; ok {
delete(filters.fields[name], value)
}
} | |
c17947 |
}
// try to match full name value to avoid O(N) regular expression matching
return fieldValues[source]
} | |
c17948 | 1 {
return false
}
// try to match full name value to avoid O(N) regular expression matching
return fieldValues[source]
} | |
c17949 | for prefix := range fieldValues {
if strings.HasPrefix(source, prefix) {
return true
}
}
return false
} | |
c17950 | ok := filters.fields[field]
return ok
} | |
c17951 | return fmt.Errorf("Invalid filter '%s'", name)
}
}
return nil
} | |
c17952 | return types.AuthResponse{}, err
}
var response types.AuthResponse
err = json.NewDecoder(resp.body).Decode(&response)
ensureReaderClosed(resp)
return response, err
} | |
c17953 | distreference.NamedTagged:
tag = x.Tag()
default:
tag = "latest"
}
return tag
} | |
c17954 | if len(options.CheckpointID) != 0 {
query.Set("checkpoint", options.CheckpointID)
}
resp, err := cli.post(ctx, "/containers/"+containerID+"/start", query, nil, nil)
ensureReaderClosed(resp)
return err
} | |
c17955 | := cli.delete(ctx, "/services/"+serviceID, nil, nil)
ensureReaderClosed(resp)
return err
} | |
c17956 | url.Values{}
if options.Force {
query.Set("force", "1")
}
resp, err := cli.delete(ctx, "/nodes/"+nodeID, query, nil)
ensureReaderClosed(resp)
return err
} | |
c17957 |
body, err := ioutil.ReadAll(serverResp.body)
if err != nil {
return swarm.Task{}, nil, err
}
var response swarm.Task
rdr := bytes.NewReader(body)
err = json.NewDecoder(rdr).Decode(&response)
return response, body, err
} | |
c17958 | cli.get(ctx, "/containers/"+container+"/checkpoints", nil, nil)
if err != nil {
return checkpoints, err
}
err = json.NewDecoder(resp.body).Decode(&checkpoints)
ensureReaderClosed(resp)
return checkpoints, err
} | |
c17959 | {
return cli.sendRequest(ctx, "POST", path, query, obj, headers)
} | |
c17960 | 0 {
filterJSON, err := filters.ToParamWithVersion(cli.version, options.Filters)
if err != nil {
return nil, err
}
query.Set("filters", filterJSON)
}
serverResponse, err := cli.get(ctx, "/events", query, nil)
if err != nil {
return nil, err
}
return serverResponse.body, nil
} | |
c17961 | {
c.Version.ImportPath = args[0]
}
return true
} | |
c17962 |
versionInfo := ""
for x := 0; x < 2 && needsUpdates; x++ {
needsUpdates = false
versionInfo, needsUpdates = v.doRepoCheck(x==0)
}
fmt.Println(versionInfo)
cmd := exec.Command(c.GoCmd, "version")
cmd.Stdout = os.Stdout
if e := cmd.Start(); e != nil {
fmt.Println("Go command error ", e)
} else {
cmd.Wai... | |
c17963 | // Only do an update on the first loop, and if specified to update
shouldUpdate := updateLibs && v.Command.Version.Update
if v.Command.Version.Update {
if localVersion == nil || (versonFromRepo != nil && versonFromRepo.Newer(localVersion)) {
needsUpdate = true
if shouldUpdate {
v.doUpdate(title, ... | |
c17964 | nil {
utils.Logger.Error("Unable to update repo", "repo", repo, "error", err)
} else if repo == "github.com/revel/cmd/revel" {
// One extra step required here to run the install for the command
utils.Logger.Fatal("Revel command tool was updated, you must manually run the following command before continuing\ngo ... | |
c17965 | {
localVersion = local.VersionString()
}
fmt.Fprintf(buffer, "%s\t:\t%s\t(%s remote master branch)\n", title, localVersion, remoteVersion)
return buffer.String()
} | |
c17966 |
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return
}
utils.Logger.Info("Got version file", "from", fullurl, "content", string(body))
return v.versionFromBytes(body)
} | |
c17967 | modulePath, err = utils.FindSrcPaths(v.Command.ImportPath, model.RevelModulesImportPath, v.Command.PackageResolver)
if err != nil {
utils.Logger.Warn("Unable to extract version information from Revel library", "error,err")
return
}
modulePath = modulePath + model.RevelModulesImportPath
v.modulesVersion, err = ... | |
c17968 | 2 {
fmt.Fprintf(os.Stderr, "%s\n%s", cmdBuild.UsageLine, cmdBuild.Long)
return false
}
c.Build.ImportPath = args[0]
c.Build.TargetPath = args[1]
if len(args) > 2 {
c.Build.Mode = args[2]
}
return true
} | |
c17969 |
if err != nil {
return err
}
// Copy files
// Included are:
// - run scripts
// - binary
// - revel
// - app
packageFolders, err := buildCopyFiles(c, app, revel_paths)
if err != nil {
return
}
err = buildCopyModules(c, revel_paths, packageFolders)
if err != nil {
return
}
err = buildWriteScripts(... | |
c17970 | folders to be packaged
packageFolders = strings.Split(revel_paths.Config.StringDefault("package.folders", "conf,public,app/views"), ",")
for i, p := range packageFolders {
// Clean spaces, reformat slash to filesystem
packageFolders[i] = filepath.FromSlash(strings.TrimSpace(p))
}
if c.Build.CopySource {
err... | |
c17971 | to load module %s (%s): %s", key[len("module."):], c.ImportPath, err)
}
modulePaths[moduleImportPath] = modPkg.Dir
}
}
// Copy the the paths for each of the modules
for importPath, fsPath := range modulePaths {
utils.Logger.Info("Copy files ", "to", filepath.Join(destPath, importPath), "from", fsPath)
... | |
c17972 |
}
utils.MustChmod(filepath.Join(c.Build.TargetPath, "run.sh"), 0755)
err = utils.GenerateTemplate(
filepath.Join(c.Build.TargetPath, "run.bat"),
PACKAGE_RUN_BAT,
tmplData,
)
if err != nil {
return
}
fmt.Println("Your application has been built in:", c.Build.TargetPath)
return
} | |
c17973 | return utils.NewBuildError("Abort: %s exists and does not look like a build directory.", "path", destPath)
}
if err := os.RemoveAll(destPath); err != nil && !os.IsNotExist(err) {
return utils.NewBuildIfError(err, "Remove all error", "path", destPath)
}
if err := os.MkdirAll(destPath, 0777); err != nil {
retu... | |
c17974 | error) RevelCallback {
return &WrappedRevelCallback{fe, ie}
} | |
c17975 | response = w.FireEventFunction(key, value)
}
return
} | |
c17976 | path failed %s:%s %s:%s ", "modulePath", moduleImportPath, "error", err)
}
}
// Drop anything between module.???.<name of module>
name := key[len("module."):]
if index := strings.Index(name, "."); index > -1 {
name = name[index+1:]
}
callback.FireEvent(REVEL_BEFORE_MODULE_LOADED, []interface{}{rp, na... | |
c17977 |
if importPath == rp.Config.StringDefault("module.testrunner", "github.com/revel/modules/testrunner") {
joinedPath := filepath.Join(rp.BasePath, "tests")
rp.CodePaths = append(rp.CodePaths, joinedPath)
}
if testsPath := filepath.Join(modulePath, "tests"); utils.DirExists(testsPath) {
rp.CodePaths = append(rp.C... | |
c17978 | return utils.GenerateTemplate(filepath.Join(paths.AppPath, dir, filename), templateSource, args)
} | |
c17979 | continue
}
addAlias(aliases, methArg.ImportPath, methArg.TypeExpr.PkgName)
}
}
}
}
// Add the "InitImportPaths", with alias "_"
for _, importPath := range src.InitImportPaths {
if _, ok := aliases[importPath]; !ok {
aliases[importPath] = "_"
}
}
return aliases
} | |
c17980 |
}
alias = makePackageAlias(aliases, pkgName)
aliases[importPath] = alias
} | |
c17981 | {
alias = fmt.Sprintf("%s%d", pkgName, i)
i++
}
return alias
} | |
c17982 |
if v == val {
return true
}
}
return false
} | |
c17983 |
var (
relFilename = string(errorMatch[1]) // e.g. "src/revel/sample/app/controllers/app.go"
absFilename = findInPaths(relFilename)
line, _ = strconv.Atoi(string(errorMatch[2]))
description = string(errorMatch[4])
compileError = &utils.Error{
SourceType: "Go code",
Title: "Go Compilation... | |
c17984 | &Error {
SourceType:source,
Title:title,
Path:path,
Description:description,
}
} | |
c17985 | "gopath", build.Default.GOPATH)
pkg, err := build.Import(fullPath, srcDir, 0)
if err != nil {
// We expect this to happen for apps using reverse routing (since we
// have not yet generated the routes). Don't log that.
if !strings.HasSuffix(fullPath, "/app/routes") {
utils.Logger.Error("Could no... | |
c17986 | }
srcPath := filepath.Join(build.Default.GOROOT, "src", "pkg")
if strings.HasPrefix(root, srcPath) {
utils.Logger.Warn("Code path should be in GOPATH, but is in GOROOT:", "path", root)
return filepath.ToSlash(root[len(srcPath)+1:])
}
utils.Logger.Error("Unexpected! Code path is not in GOPATH:", "path", root)... | |
c17987 | = s.TypesThatEmbed(RevelImportPath+".Controller", "controllers")
}
return s.controllerSpecs
} | |
c17988 | model.VERSION
}
}
}
if len(extraArgs) > 0 {
utils.Logger.Info("Found additional arguements, setting them")
if !Commands[c.Index].UpdateConfig(c, extraArgs) {
buffer := &bytes.Buffer{}
parser.WriteHelp(buffer)
err = fmt.Errorf("Invalid command line arguements %v\n%s", extraArgs, buffer.String())
... | |
c17989 | {
realPath.WriteString(string(filepath.ListSeparator))
}
realPath.WriteString(rp)
}
// Go 1.8 fails if we do not include the GOROOT
c.Env = []string{"GOPATH=" + realPath.String(), "GOROOT="+ os.Getenv("GOROOT")}
// Fetch the rest of the env variables
for _, e := range os.Environ() {
pair := strings.Split... | |
c17990 | = c.Package.TargetPath
} else {
destFile = filepath.Join(c.AppPath, c.Package.TargetPath)
}
}
if err := os.Remove(destFile); err != nil && !os.IsNotExist(err) {
return utils.NewBuildError("Unable to remove target file", "error", err, "file", destFile)
}
// Collect stuff in a temp directory.
tmpDir, err ... | |
c17991 | int, valid bool) TypeExpr {
return TypeExpr{expr, pkgName, pkgIndex, valid}
} | |
c17992 | e.Valid)
}
error = fmt.Sprintf("Failed to generate name for Map field :%v. Make sure the field name is valid.", t.Key)
case *ast.Ellipsis:
e := NewTypeExprFromAst(pkgName, t.Elt)
return NewTypeExprFromData("[]"+e.Expr, e.PkgName, e.pkgIndex+2, e.Valid)
default:
error = fmt.Sprintf("Failed to generate name ... | |
c17993 | return e.Expr
}
return e.Expr[:e.pkgIndex] + pkgName + "." + e.Expr[e.pkgIndex:]
} | |
c17994 | = path
}
} else {
if utils.Exists(filepath.Join(path, "src", c.ImportPath)) {
c.SrcRoot = path
break
}
}
}
utils.Logger.Info("Source root", "path", c.SrcRoot, "cwd", workingDir, "gopath", c.GoPath, "bestpath",bestpath)
if len(c.SrcRoot) == 0 && len(bestpath) > 0 {
c.SrcRoot = bestpath
}
/... | |
c17995 | }
if genDecl.Tok != token.CONST {
continue
}
for _, a := range genDecl.Specs {
spec := a.(*ast.ValueSpec)
r := spec.Values[0].(*ast.BasicLit)
if spec.Names[0].Name == "Version" {
c.FrameworkVersion, err = ParseVersion(strings.Replace(r.Value, `"`, ``, -1))
if err != nil {
uti... | |
c17996 | return true
}
return filepath.IsAbs(pathToCheck)
} | |
c17997 | if c.HistoricMode {
runMode = revel_path.RunMode
}
// **** Never returns.
harness.NewHarness(c, revel_path, runMode, c.Run.NoProxy).Run()
}
// Else, just build and run the app.
utils.Logger.Debug("Running in live build mode.")
app, err := harness.Build(c, revel_path)
if err != nil {
utils.Logger.Erro... | |
c17998 | = destFile.Close()
if err != nil {
return NewBuildIfError(err, "Failed to close file", "file", destFilename)
}
err = srcFile.Close()
if err != nil {
return NewBuildIfError(err, "Failed to close file", "file", srcFilename)
}
return
} | |
c17999 |
// Create the file
file, err := os.Create(filename)
if err != nil {
Logger.Fatal("Failed to create file", "error", err)
return
}
defer func() {
_ = file.Close()
}()
if _, err = file.WriteString(sourceCode); err != nil {
Logger.Fatal("Failed to write to file: ", "error", err)
}
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.