_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17900 | NewManager | train | func NewManager(logger Logger) *Manager {
return &Manager{
root: logger,
loggers: make(map[string]Node),
loggerMaker: defaultLoggerMaker,
}
} | go | {
"resource": ""
} |
q17901 | SetLoggerMaker | train | func (self *Manager) SetLoggerMaker(maker LoggerMaker) {
self.lock.Lock()
defer self.lock.Unlock()
self.loggerMaker = maker
} | go | {
"resource": ""
} |
q17902 | fixupParents | train | func (self *Manager) fixupParents(logger Logger) {
name := logger.GetName()
index := strings.LastIndex(name, ".")
var parent Logger
for (index > 0) && (parent == nil) {
parentStr := name[:index]
node, ok := self.loggers[parentStr]
if !ok {
self.loggers[parentStr] = NewPlaceHolder(logger)
} else {
swit... | go | {
"resource": ""
} |
q17903 | fixupChildren | train | func (self *Manager) fixupChildren(placeHolder *PlaceHolder, logger Logger) {
name := logger.GetName()
for e := placeHolder.Loggers.Front(); e != nil; e = e.Next() {
l, _ := e.Value.(Logger)
parent := l.GetParent()
if !strings.HasPrefix(parent.GetName(), name) {
logger.SetParent(parent)
l.SetParent(logger... | go | {
"resource": ""
} |
q17904 | NewLogRecord | train | func NewLogRecord(
name string,
level LogLevelType,
pathName string,
fileName string,
lineNo uint32,
funcName string,
format string,
useFormat bool,
args []interface{}) *LogRecord {
return &LogRecord{
CreatedTime: time.Now(),
Name: name,
Level: level,
PathName: pathName,
FileName: ... | go | {
"resource": ""
} |
q17905 | String | train | func (self *LogRecord) String() string {
return fmt.Sprintf("<LogRecord: %s, %s, %s, %d, \"%s\">",
self.Name, self.Level, self.PathName, self.LineNo, self.Message)
} | go | {
"resource": ""
} |
q17906 | GetMessage | train | func (self *LogRecord) GetMessage() string {
if len(self.Message) == 0 {
if self.UseFormat {
self.Message = fmt.Sprintf(self.Format, self.Args...)
} else {
self.Message = fmt.Sprint(self.Args...)
}
}
return self.Message
} | go | {
"resource": ""
} |
q17907 | NewStreamHandler | train | func NewStreamHandler(
name string, level LogLevelType, stream Stream) *StreamHandler {
object := &StreamHandler{
BaseHandler: NewBaseHandler(name, level),
stream: stream,
}
Closer.AddHandler(object)
return object
} | go | {
"resource": ""
} |
q17908 | Emit2 | train | func (self *StreamHandler) Emit2(
handler Handler, record *LogRecord) error {
message := handler.Format(record)
if err := self.stream.Write(message); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q17909 | NewNullHandler | train | func NewNullHandler() *NullHandler {
object := &NullHandler{
BaseHandler: NewBaseHandler("", LevelNotset),
}
Closer.AddHandler(object)
return object
} | go | {
"resource": ""
} |
q17910 | initFormatRegexp | train | func initFormatRegexp() *regexp.Regexp {
var buf bytes.Buffer
buf.WriteString("(%(?:%")
for attr, _ := range attrToFunc {
buf.WriteString("|")
buf.WriteString(regexp.QuoteMeta(attr[1:]))
}
buf.WriteString("))")
re := buf.String()
return regexp.MustCompile(re)
} | go | {
"resource": ""
} |
q17911 | NewStandardFormatter | train | func NewStandardFormatter(format string, dateFormat string) *StandardFormatter {
toFormatTime := false
size := 0
f1 := func(match string) string {
if match == "%%" {
return "%"
}
if match == "%(asctime)s" {
toFormatTime = true
}
size++
return "%s"
}
strFormat := formatRe.ReplaceAllStringFunc(form... | go | {
"resource": ""
} |
q17912 | FormatAll | train | func (self *StandardFormatter) FormatAll(record *LogRecord) string {
return fmt.Sprintf(self.strFormat, self.getFormatArgsFunc(record)...)
} | go | {
"resource": ""
} |
q17913 | Format | train | func (self *BufferingFormatter) Format(records []*LogRecord) string {
var buf bytes.Buffer
if len(records) > 0 {
buf.WriteString(self.FormatHeader(records))
for _, record := range records {
buf.WriteString(self.lineFormatter.Format(record))
}
buf.WriteString(self.FormatFooter(records))
}
return buf.Strin... | go | {
"resource": ""
} |
q17914 | NewFSock | train | func NewFSock(fsaddr, fspaswd string, reconnects int, eventHandlers map[string][]func(string, string), eventFilters map[string][]string, l *syslog.Writer, connId string) (fsock *FSock, err error) {
fsock = &FSock{
fsMutex: new(sync.RWMutex),
connId: connId,
fsaddress: fsaddr,
fspaswd: ... | go | {
"resource": ""
} |
q17915 | Connected | train | func (self *FSock) Connected() (ok bool) {
self.fsMutex.RLock()
ok = (self.conn != nil)
self.fsMutex.RUnlock()
return
} | go | {
"resource": ""
} |
q17916 | auth | train | func (self *FSock) auth() error {
self.send(fmt.Sprintf("auth %s\n\n", self.fspaswd))
if rply, err := self.readHeaders(); err != nil {
return err
} else if !strings.Contains(rply, "Reply-Text: +OK accepted") {
return fmt.Errorf("Unexpected auth reply received: <%s>", rply)
}
return nil
} | go | {
"resource": ""
} |
q17917 | SendCmd | train | func (self *FSock) SendCmd(cmdStr string) (string, error) {
return self.sendCmd(cmdStr + "\n")
} | go | {
"resource": ""
} |
q17918 | SendApiCmd | train | func (self *FSock) SendApiCmd(cmdStr string) (string, error) {
return self.sendCmd("api " + cmdStr + "\n")
} | go | {
"resource": ""
} |
q17919 | SendBgapiCmd | train | func (self *FSock) SendBgapiCmd(cmdStr string) (out chan string, err error) {
jobUuid := genUUID()
out = make(chan string)
self.fsMutex.Lock()
self.backgroundChans[jobUuid] = out
self.fsMutex.Unlock()
_, err = self.sendCmd(fmt.Sprintf("bgapi %s\nJob-UUID:%s\n", cmdStr, jobUuid))
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q17920 | ReadEvents | train | func (self *FSock) ReadEvents() (err error) {
var opened bool
for {
if err, opened = <-self.errReadEvents; !opened {
return nil
} else if err == io.EOF { // Disconnected, try reconnect
if err = self.ReconnectIfNeeded(); err != nil {
break
}
}
}
return err
} | go | {
"resource": ""
} |
q17921 | readHeaders | train | func (self *FSock) readHeaders() (header string, err error) {
bytesRead := make([]byte, 0)
var readLine []byte
for {
readLine, err = self.buffer.ReadBytes('\n')
if err != nil {
if self.logger != nil {
self.logger.Err(fmt.Sprintf("<FSock> Error reading headers: <%s>", err.Error()))
}
self.Disconnect... | go | {
"resource": ""
} |
q17922 | readBody | train | func (self *FSock) readBody(noBytes int) (body string, err error) {
bytesRead := make([]byte, noBytes)
var readByte byte
for i := 0; i < noBytes; i++ {
if readByte, err = self.buffer.ReadByte(); err != nil {
if self.logger != nil {
self.logger.Err(fmt.Sprintf("<FSock> Error reading message body: <%s>", err... | go | {
"resource": ""
} |
q17923 | readEvents | train | func (self *FSock) readEvents() {
for {
select {
case <-self.stopReadEvents:
return
default: // Unlock waiting here
}
hdr, body, err := self.readEvent()
if err != nil {
self.errReadEvents <- err
return
}
if strings.Contains(hdr, "api/response") {
self.cmdChan <- body
} else if strings.Con... | go | {
"resource": ""
} |
q17924 | eventsPlain | train | func (self *FSock) eventsPlain(events []string) error {
// if len(events) == 0 {
// return nil
// }
eventsCmd := "event plain"
customEvents := ""
for _, ev := range events {
if ev == "ALL" {
eventsCmd = "event plain all"
break
}
if strings.HasPrefix(ev, "CUSTOM") {
customEvents += ev[6:] // will c... | go | {
"resource": ""
} |
q17925 | dispatchEvent | train | func (self *FSock) dispatchEvent(event string) {
eventName := headerVal(event, "Event-Name")
if eventName == "BACKGROUND_JOB" { // for bgapi BACKGROUND_JOB
go self.doBackgroudJob(event)
return
}
if eventName == "CUSTOM" {
eventSubclass := headerVal(event, "Event-Subclass")
if len(eventSubclass) != 0 {
e... | go | {
"resource": ""
} |
q17926 | doBackgroudJob | train | func (self *FSock) doBackgroudJob(event string) { // add mutex protection
evMap := EventToMap(event)
jobUuid, has := evMap["Job-UUID"]
if !has {
self.logger.Err("<FSock> BACKGROUND_JOB with no Job-UUID")
return
}
var out chan string
self.fsMutex.RLock()
out, has = self.backgroundChans[jobUuid]
self.fsMutex... | go | {
"resource": ""
} |
q17927 | NewFSockPool | train | func NewFSockPool(maxFSocks int, fsaddr, fspasswd string, reconnects int, maxWaitConn time.Duration,
eventHandlers map[string][]func(string, string), eventFilters map[string][]string, l *syslog.Writer, connId string) (*FSockPool, error) {
pool := &FSockPool{
connId: connId,
fsAddr: fsaddr,
fsPassw... | go | {
"resource": ""
} |
q17928 | FSEventStrToMap | train | func FSEventStrToMap(fsevstr string, headers []string) map[string]string {
fsevent := make(map[string]string)
filtered := (len(headers) != 0)
for _, strLn := range strings.Split(fsevstr, "\n") {
if hdrVal := strings.SplitN(strLn, ": ", 2); len(hdrVal) == 2 {
if filtered && isSliceMember(headers, hdrVal[0]) {
... | go | {
"resource": ""
} |
q17929 | MapChanData | train | func MapChanData(chanInfoStr string) (chansInfoMap []map[string]string) {
chansInfoMap = make([]map[string]string, 0)
spltChanInfo := strings.Split(chanInfoStr, "\n")
if len(spltChanInfo) <= 4 {
return
}
hdrs := strings.Split(spltChanInfo[0], ",")
for _, chanInfoLn := range spltChanInfo[1 : len(spltChanInfo)-3]... | go | {
"resource": ""
} |
q17930 | genUUID | train | func genUUID() string {
b := make([]byte, 16)
_, err := io.ReadFull(rand.Reader, b)
if err != nil {
log.Fatal(err)
}
b[6] = (b[6] & 0x0F) | 0x40
b[8] = (b[8] &^ 0x40) | 0x80
return fmt.Sprintf("%x-%x-%x-%x-%x", b[:4], b[4:6], b[6:8], b[8:10],
b[10:])
} | go | {
"resource": ""
} |
q17931 | headerVal | train | func headerVal(hdrs, hdr string) string {
var hdrSIdx, hdrEIdx int
if hdrSIdx = strings.Index(hdrs, hdr); hdrSIdx == -1 {
return ""
} else if hdrEIdx = strings.Index(hdrs[hdrSIdx:], "\n"); hdrEIdx == -1 {
hdrEIdx = len(hdrs[hdrSIdx:])
}
splt := strings.SplitN(hdrs[hdrSIdx:hdrSIdx+hdrEIdx], ": ", 2)
if len(spl... | go | {
"resource": ""
} |
q17932 | urlDecode | train | func urlDecode(hdrVal string) string {
if valUnescaped, errUnescaping := url.QueryUnescape(hdrVal); errUnescaping == nil {
hdrVal = valUnescaped
}
return hdrVal
} | go | {
"resource": ""
} |
q17933 | isSliceMember | train | func isSliceMember(ss []string, s string) bool {
sort.Strings(ss)
i := sort.SearchStrings(ss, s)
return (i < len(ss) && ss[i] == s)
} | go | {
"resource": ""
} |
q17934 | NewQueue | train | func NewQueue(handler Handler, concurrencyLimit int) *Queue {
q := &Queue{
&queue{
Handler: handler,
ConcurrencyLimit: concurrencyLimit,
push: make(chan interface{}),
pop: make(chan struct{}),
suspend: make(chan bool),
stop: make(chan struct{}... | go | {
"resource": ""
} |
q17935 | Len | train | func (q *Queue) Len() (_, _ int) {
return q.count, len(q.buffer)
} | go | {
"resource": ""
} |
q17936 | PluginInspectWithRaw | train | func (cli *Client) PluginInspectWithRaw(ctx context.Context, name string) (*types.Plugin, []byte, error) {
resp, err := cli.get(ctx, "/plugins/"+name, nil, nil)
if err != nil {
return nil, nil, err
}
defer ensureReaderClosed(resp)
body, err := ioutil.ReadAll(resp.body)
if err != nil {
return nil, nil, err
}... | go | {
"resource": ""
} |
q17937 | ServiceUpdate | train | func (cli *Client) ServiceUpdate(ctx context.Context, serviceID string, version swarm.Version, service swarm.ServiceSpec, options types.ServiceUpdateOptions) error {
var (
headers map[string][]string
query = url.Values{}
)
if options.EncodedRegistryAuth != "" {
headers = map[string][]string{
"X-Registry-... | go | {
"resource": ""
} |
q17938 | NewEnvClient | train | func NewEnvClient() (*Client, error) {
var client *http.Client
if dockerCertPath := os.Getenv("DOCKER_CERT_PATH"); dockerCertPath != "" {
options := tlsconfig.Options{
CAFile: filepath.Join(dockerCertPath, "ca.pem"),
CertFile: filepath.Join(dockerCertPath, "cert.pem"),
KeyFile: ... | go | {
"resource": ""
} |
q17939 | NewClient | train | func NewClient(host string, version string, client *http.Client, httpHeaders map[string]string) (*Client, error) {
proto, addr, basePath, err := ParseHost(host)
if err != nil {
return nil, err
}
transport, err := transport.NewTransportWithHTTP(proto, addr, client)
if err != nil {
return nil, err
}
return &... | go | {
"resource": ""
} |
q17940 | TaskList | train | func (cli *Client) TaskList(ctx context.Context, options types.TaskListOptions) ([]swarm.Task, error) {
query := url.Values{}
if options.Filter.Len() > 0 {
filterJSON, err := filters.ToParam(options.Filter)
if err != nil {
return nil, err
}
query.Set("filters", filterJSON)
}
resp, err := cli.get(ctx, ... | go | {
"resource": ""
} |
q17941 | NetworkInspect | train | func (cli *Client) NetworkInspect(ctx context.Context, networkID string) (types.NetworkResource, error) {
networkResource, _, err := cli.NetworkInspectWithRaw(ctx, networkID)
return networkResource, err
} | go | {
"resource": ""
} |
q17942 | ToParam | train | func ToParam(a Args) (string, error) {
// this way we don't URL encode {}, just empty space
if a.Len() == 0 {
return "", nil
}
buf, err := json.Marshal(a.fields)
if err != nil {
return "", err
}
return string(buf), nil
} | go | {
"resource": ""
} |
q17943 | FromParam | train | func FromParam(p string) (Args, error) {
if len(p) == 0 {
return NewArgs(), nil
}
r := strings.NewReader(p)
d := json.NewDecoder(r)
m := map[string]map[string]bool{}
if err := d.Decode(&m); err != nil {
r.Seek(0, 0)
// Allow parsing old arguments in slice format.
// Because other libraries might be sen... | go | {
"resource": ""
} |
q17944 | Get | train | func (filters Args) Get(field string) []string {
values := filters.fields[field]
if values == nil {
return make([]string, 0)
}
slice := make([]string, 0, len(values))
for key := range values {
slice = append(slice, key)
}
return slice
} | go | {
"resource": ""
} |
q17945 | Add | train | func (filters Args) Add(name, value string) {
if _, ok := filters.fields[name]; ok {
filters.fields[name][value] = true
} else {
filters.fields[name] = map[string]bool{value: true}
}
} | go | {
"resource": ""
} |
q17946 | Del | train | func (filters Args) Del(name, value string) {
if _, ok := filters.fields[name]; ok {
delete(filters.fields[name], value)
}
} | go | {
"resource": ""
} |
q17947 | ExactMatch | train | func (filters Args) ExactMatch(field, source string) bool {
fieldValues, ok := filters.fields[field]
//do not filter if there is no filter set or cannot determine filter
if !ok || len(fieldValues) == 0 {
return true
}
// try to match full name value to avoid O(N) regular expression matching
return fieldValues[... | go | {
"resource": ""
} |
q17948 | UniqueExactMatch | train | func (filters Args) UniqueExactMatch(field, source string) bool {
fieldValues := filters.fields[field]
//do not filter if there is no filter set or cannot determine filter
if len(fieldValues) == 0 {
return true
}
if len(filters.fields[field]) != 1 {
return false
}
// try to match full name value to avoid O(... | go | {
"resource": ""
} |
q17949 | FuzzyMatch | train | func (filters Args) FuzzyMatch(field, source string) bool {
if filters.ExactMatch(field, source) {
return true
}
fieldValues := filters.fields[field]
for prefix := range fieldValues {
if strings.HasPrefix(source, prefix) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q17950 | Include | train | func (filters Args) Include(field string) bool {
_, ok := filters.fields[field]
return ok
} | go | {
"resource": ""
} |
q17951 | Validate | train | func (filters Args) Validate(accepted map[string]bool) error {
for name := range filters.fields {
if !accepted[name] {
return fmt.Errorf("Invalid filter '%s'", name)
}
}
return nil
} | go | {
"resource": ""
} |
q17952 | RegistryLogin | train | func (cli *Client) RegistryLogin(ctx context.Context, auth types.AuthConfig) (types.AuthResponse, error) {
resp, err := cli.post(ctx, "/auth", url.Values{}, auth, nil)
if resp.statusCode == http.StatusUnauthorized {
return types.AuthResponse{}, unauthorizedError{err}
}
if err != nil {
return types.AuthResponse... | go | {
"resource": ""
} |
q17953 | GetTagFromNamedRef | train | func GetTagFromNamedRef(ref distreference.Named) string {
var tag string
switch x := ref.(type) {
case distreference.Digested:
tag = x.Digest().String()
case distreference.NamedTagged:
tag = x.Tag()
default:
tag = "latest"
}
return tag
} | go | {
"resource": ""
} |
q17954 | ContainerStart | train | func (cli *Client) ContainerStart(ctx context.Context, containerID string, options types.ContainerStartOptions) error {
query := url.Values{}
if len(options.CheckpointID) != 0 {
query.Set("checkpoint", options.CheckpointID)
}
resp, err := cli.post(ctx, "/containers/"+containerID+"/start", query, nil, nil)
ensur... | go | {
"resource": ""
} |
q17955 | ServiceRemove | train | func (cli *Client) ServiceRemove(ctx context.Context, serviceID string) error {
resp, err := cli.delete(ctx, "/services/"+serviceID, nil, nil)
ensureReaderClosed(resp)
return err
} | go | {
"resource": ""
} |
q17956 | NodeRemove | train | func (cli *Client) NodeRemove(ctx context.Context, nodeID string, options types.NodeRemoveOptions) error {
query := url.Values{}
if options.Force {
query.Set("force", "1")
}
resp, err := cli.delete(ctx, "/nodes/"+nodeID, query, nil)
ensureReaderClosed(resp)
return err
} | go | {
"resource": ""
} |
q17957 | TaskInspectWithRaw | train | func (cli *Client) TaskInspectWithRaw(ctx context.Context, taskID string) (swarm.Task, []byte, error) {
serverResp, err := cli.get(ctx, "/tasks/"+taskID, nil, nil)
if err != nil {
if serverResp.statusCode == http.StatusNotFound {
return swarm.Task{}, nil, taskNotFoundError{taskID}
}
return swarm.Task{}, nil,... | go | {
"resource": ""
} |
q17958 | CheckpointList | train | func (cli *Client) CheckpointList(ctx context.Context, container string) ([]types.Checkpoint, error) {
var checkpoints []types.Checkpoint
resp, err := cli.get(ctx, "/containers/"+container+"/checkpoints", nil, nil)
if err != nil {
return checkpoints, err
}
err = json.NewDecoder(resp.body).Decode(&checkpoints)
... | go | {
"resource": ""
} |
q17959 | post | train | func (cli *Client) post(ctx context.Context, path string, query url.Values, obj interface{}, headers map[string][]string) (serverResponse, error) {
return cli.sendRequest(ctx, "POST", path, query, obj, headers)
} | go | {
"resource": ""
} |
q17960 | Events | train | func (cli *Client) Events(ctx context.Context, options types.EventsOptions) (io.ReadCloser, error) {
query := url.Values{}
ref := time.Now()
if options.Since != "" {
ts, err := timetypes.GetTimestamp(options.Since, ref)
if err != nil {
return nil, err
}
query.Set("since", ts)
}
if options.Until != "" {... | go | {
"resource": ""
} |
q17961 | UpdateConfig | train | func (v *VersionCommand) UpdateConfig(c *model.CommandConfig, args []string) bool {
if len(args) > 0 {
c.Version.ImportPath = args[0]
}
return true
} | go | {
"resource": ""
} |
q17962 | RunWith | train | func (v *VersionCommand) RunWith(c *model.CommandConfig) (err error) {
utils.Logger.Info("Requesting version information", "config", c)
v.Command = c
// Update the versions with the local values
v.updateLocalVersions()
needsUpdates := true
versionInfo := ""
for x := 0; x < 2 && needsUpdates; x++ {
needsUpdat... | go | {
"resource": ""
} |
q17963 | doRepoCheck | train | func (v *VersionCommand) doRepoCheck(updateLibs bool) (versionInfo string, needsUpdate bool) {
var (
title string
localVersion *model.Version
)
for _, repo := range []string{"revel", "cmd", "modules"} {
versonFromRepo, err := v.versionFromRepo(repo, "", "version.go")
if err != nil {
utils.Logger.Info("Fai... | go | {
"resource": ""
} |
q17964 | doUpdate | train | func (v *VersionCommand) doUpdate(title, repo string, local, remote *model.Version) {
utils.Logger.Info("Updating package", "package", title, "repo",repo)
fmt.Println("Attempting to update package", title)
if err := v.Command.PackageResolver(repo); err != nil {
utils.Logger.Error("Unable to update repo", "repo", r... | go | {
"resource": ""
} |
q17965 | outputVersion | train | func (v *VersionCommand) outputVersion(title, repo string, local, remote *model.Version) (output string) {
buffer := &bytes.Buffer{}
remoteVersion := "Unknown"
if remote != nil {
remoteVersion = remote.VersionString()
}
localVersion := "Unknown"
if local != nil {
localVersion = local.VersionString()
}
fmt.... | go | {
"resource": ""
} |
q17966 | versionFromRepo | train | func (v *VersionCommand) versionFromRepo(repoName, branchName, fileName string) (version *model.Version, err error) {
if branchName == "" {
branchName = "master"
}
// Try to download the version of file from the repo, just use an http connection to retrieve the source
// Assuming that the repo is github
fullurl ... | go | {
"resource": ""
} |
q17967 | updateLocalVersions | train | func (v *VersionCommand) updateLocalVersions() {
v.cmdVersion = &model.Version{}
v.cmdVersion.ParseVersion(cmd.Version)
v.cmdVersion.BuildDate = cmd.BuildDate
v.cmdVersion.MinGoVersion = cmd.MinimumGoVersion
var modulePath, revelPath string
_, revelPath, err := utils.FindSrcPaths(v.Command.ImportPath, model.Rev... | go | {
"resource": ""
} |
q17968 | updateBuildConfig | train | func updateBuildConfig(c *model.CommandConfig, args []string) bool {
c.Index = model.BUILD
// If arguments were passed in then there must be two
if len(args) < 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 ... | go | {
"resource": ""
} |
q17969 | buildApp | train | func buildApp(c *model.CommandConfig) (err error) {
appImportPath, destPath, mode := c.ImportPath, c.Build.TargetPath, DefaultRunMode
if len(c.Build.Mode) > 0 {
mode = c.Build.Mode
}
// Convert target to absolute path
c.Build.TargetPath, _ = filepath.Abs(destPath)
c.Build.Mode = mode
c.Build.ImportPath = appI... | go | {
"resource": ""
} |
q17970 | buildCopyFiles | train | func buildCopyFiles(c *model.CommandConfig, app *harness.App, revel_paths *model.RevelContainer) (packageFolders []string, err error) {
appImportPath, destPath := c.ImportPath, c.Build.TargetPath
// Revel and the app are in a directory structure mirroring import path
srcPath := filepath.Join(destPath, "src")
destB... | go | {
"resource": ""
} |
q17971 | buildCopyModules | train | func buildCopyModules(c *model.CommandConfig, revel_paths *model.RevelContainer, packageFolders []string) (err error) {
destPath := filepath.Join(c.Build.TargetPath, "src")
// Find all the modules used and copy them over.
config := revel_paths.Config.Raw()
modulePaths := make(map[string]string) // import path => fi... | go | {
"resource": ""
} |
q17972 | buildWriteScripts | train | func buildWriteScripts(c *model.CommandConfig, app *harness.App) (err error) {
tmplData := map[string]interface{}{
"BinName": filepath.Base(app.BinaryPath),
"ImportPath": c.Build.ImportPath,
"Mode": c.Build.Mode,
}
err = utils.GenerateTemplate(
filepath.Join(c.Build.TargetPath, "run.sh"),
PACKAGE... | go | {
"resource": ""
} |
q17973 | buildSafetyCheck | train | func buildSafetyCheck(destPath string) error {
// First, verify that it is either already empty or looks like a previous
// build (to avoid clobbering anything)
if utils.Exists(destPath) && !utils.Empty(destPath) && !utils.Exists(filepath.Join(destPath, "run.sh")) {
return utils.NewBuildError("Abort: %s exists an... | go | {
"resource": ""
} |
q17974 | NewWrappedRevelCallback | train | func NewWrappedRevelCallback(fe func(key Event, value interface{}) (response EventResponse), ie func(pkgName string) error) RevelCallback {
return &WrappedRevelCallback{fe, ie}
} | go | {
"resource": ""
} |
q17975 | FireEvent | train | func (w *WrappedRevelCallback) FireEvent(key Event, value interface{}) (response EventResponse) {
if w.FireEventFunction != nil {
response = w.FireEventFunction(key, value)
}
return
} | go | {
"resource": ""
} |
q17976 | loadModules | train | func (rp *RevelContainer) loadModules(callback RevelCallback) (err error) {
keys := []string{}
for _, key := range rp.Config.Options("module.") {
keys = append(keys, key)
}
// Reorder module order by key name, a poor mans sort but at least it is consistent
sort.Strings(keys)
for _, key := range keys {
module... | go | {
"resource": ""
} |
q17977 | addModulePaths | train | func (rp *RevelContainer) addModulePaths(name, importPath, modulePath string) {
if codePath := filepath.Join(modulePath, "app"); utils.DirExists(codePath) {
rp.CodePaths = append(rp.CodePaths, codePath)
rp.ModulePathMap[name] = modulePath
if viewsPath := filepath.Join(modulePath, "app", "views"); utils.DirExists... | go | {
"resource": ""
} |
q17978 | genSource | train | func genSource(paths *model.RevelContainer, dir, filename, templateSource string, args map[string]interface{}) error {
return utils.GenerateTemplate(filepath.Join(paths.AppPath, dir, filename), templateSource, args)
} | go | {
"resource": ""
} |
q17979 | calcImportAliases | train | func calcImportAliases(src *model.SourceInfo) map[string]string {
aliases := make(map[string]string)
typeArrays := [][]*model.TypeInfo{src.ControllerSpecs(), src.TestSuites()}
for _, specs := range typeArrays {
for _, spec := range specs {
addAlias(aliases, spec.ImportPath, spec.PackageName)
for _, methSpec... | go | {
"resource": ""
} |
q17980 | addAlias | train | func addAlias(aliases map[string]string, importPath, pkgName string) {
alias, ok := aliases[importPath]
if ok {
return
}
alias = makePackageAlias(aliases, pkgName)
aliases[importPath] = alias
} | go | {
"resource": ""
} |
q17981 | makePackageAlias | train | func makePackageAlias(aliases map[string]string, pkgName string) string {
i := 0
alias := pkgName
for containsValue(aliases, alias) || alias == "revel" {
alias = fmt.Sprintf("%s%d", pkgName, i)
i++
}
return alias
} | go | {
"resource": ""
} |
q17982 | containsValue | train | func containsValue(m map[string]string, val string) bool {
for _, v := range m {
if v == val {
return true
}
}
return false
} | go | {
"resource": ""
} |
q17983 | newCompileError | train | func newCompileError(paths *model.RevelContainer, output []byte) *utils.Error {
errorMatch := regexp.MustCompile(`(?m)^([^:#]+):(\d+):(\d+:)? (.*)$`).
FindSubmatch(output)
if errorMatch == nil {
errorMatch = regexp.MustCompile(`(?m)^(.*?):(\d+):\s(.*?)$`).FindSubmatch(output)
if errorMatch == nil {
utils.Lo... | go | {
"resource": ""
} |
q17984 | NewError | train | func NewError(source, title,path,description string) *Error {
return &Error {
SourceType:source,
Title:title,
Path:path,
Description:description,
}
} | go | {
"resource": ""
} |
q17985 | addImports | train | func addImports(imports map[string]string, decl ast.Decl, srcDir string) {
genDecl, ok := decl.(*ast.GenDecl)
if !ok {
return
}
if genDecl.Tok != token.IMPORT {
return
}
for _, spec := range genDecl.Specs {
importSpec := spec.(*ast.ImportSpec)
var pkgAlias string
if importSpec.Name != nil {
pkgAlia... | go | {
"resource": ""
} |
q17986 | importPathFromPath | train | func importPathFromPath(root, basePath string) string {
vendorTest := filepath.Join(basePath, "vendor")
if len(root) > len(vendorTest) && root[:len(vendorTest)] == vendorTest {
return filepath.ToSlash(root[len(vendorTest)+1:])
}
for _, gopath := range filepath.SplitList(build.Default.GOPATH) {
srcPath := filepa... | go | {
"resource": ""
} |
q17987 | ControllerSpecs | train | func (s *SourceInfo) ControllerSpecs() []*TypeInfo {
if s.controllerSpecs == nil {
s.controllerSpecs = s.TypesThatEmbed(RevelImportPath+".Controller", "controllers")
}
return s.controllerSpecs
} | go | {
"resource": ""
} |
q17988 | ParseArgs | train | func ParseArgs(c *model.CommandConfig, parser *flags.Parser, args []string) (err error) {
var extraArgs []string
if ini := flag.String("ini", "none", ""); *ini != "none" {
if err = flags.NewIniParser(parser).ParseFile(*ini); err != nil {
return
}
} else {
if extraArgs, err = parser.ParseArgs(args); err != n... | go | {
"resource": ""
} |
q17989 | CmdInit | train | func CmdInit(c *exec.Cmd, basePath string) {
c.Dir = basePath
// Dep does not like paths that are not real, convert all paths in go to real paths
realPath := &bytes.Buffer{}
for _, p := range filepath.SplitList(build.Default.GOPATH) {
rp,_ := filepath.EvalSymlinks(p)
if realPath.Len() > 0 {
realPath.WriteStr... | go | {
"resource": ""
} |
q17990 | packageApp | train | func packageApp(c *model.CommandConfig) (err error) {
// Determine the run mode.
mode := DefaultRunMode
if len(c.Package.Mode) >= 0 {
mode = c.Package.Mode
}
appImportPath := c.ImportPath
revel_paths, err := model.NewRevelPaths(mode, appImportPath, "", model.NewWrappedRevelCallback(nil, c.PackageResolver))
i... | go | {
"resource": ""
} |
q17991 | NewTypeExprFromData | train | func NewTypeExprFromData(expr, pkgName string, pkgIndex int, valid bool) TypeExpr {
return TypeExpr{expr, pkgName, pkgIndex, valid}
} | go | {
"resource": ""
} |
q17992 | NewTypeExprFromAst | train | func NewTypeExprFromAst(pkgName string, expr ast.Expr) TypeExpr {
error := ""
switch t := expr.(type) {
case *ast.Ident:
if IsBuiltinType(t.Name) {
pkgName = ""
}
return TypeExpr{t.Name, pkgName, 0, true}
case *ast.SelectorExpr:
e := NewTypeExprFromAst(pkgName, t.X)
return NewTypeExprFromData(t.Sel.Nam... | go | {
"resource": ""
} |
q17993 | TypeName | train | func (e TypeExpr) TypeName(pkgOverride string) string {
pkgName := FirstNonEmpty(pkgOverride, e.PkgName)
if pkgName == "" {
return e.Expr
}
return e.Expr[:e.pkgIndex] + pkgName + "." + e.Expr[e.pkgIndex:]
} | go | {
"resource": ""
} |
q17994 | InitGoPaths | train | func (c *CommandConfig) InitGoPaths() {
utils.Logger.Info("InitGoPaths")
// lookup go path
c.GoPath = build.Default.GOPATH
if c.GoPath == "" {
utils.Logger.Fatal("Abort: GOPATH environment variable is not set. " +
"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
}
// chec... | go | {
"resource": ""
} |
q17995 | SetVersions | train | func (c *CommandConfig) SetVersions() (err error) {
c.CommandVersion, _ = ParseVersion(cmd.Version)
_, revelPath, err := utils.FindSrcPaths(c.ImportPath, RevelImportPath, c.PackageResolver)
if err == nil {
utils.Logger.Info("Fullpath to revel", "dir", revelPath)
fset := token.NewFileSet() // positions are relati... | go | {
"resource": ""
} |
q17996 | runIsImportPath | train | func runIsImportPath(pathToCheck string) bool {
if _, err := build.Import(pathToCheck, "", build.FindOnly);err==nil {
return true
}
return filepath.IsAbs(pathToCheck)
} | go | {
"resource": ""
} |
q17997 | runApp | train | func runApp(c *model.CommandConfig) (err error) {
if c.Run.Mode == "" {
c.Run.Mode = "dev"
}
revel_path, err := model.NewRevelPaths(c.Run.Mode, c.ImportPath, "", model.NewWrappedRevelCallback(nil, c.PackageResolver))
if err != nil {
return utils.NewBuildIfError(err, "Revel paths")
}
if c.Run.Port > -1 {
re... | go | {
"resource": ""
} |
q17998 | CopyFile | train | func CopyFile(destFilename, srcFilename string) (err error) {
destFile, err := os.Create(destFilename)
if err != nil {
return NewBuildIfError(err, "Failed to create file", "file", destFilename)
}
srcFile, err := os.Open(srcFilename)
if err != nil {
return NewBuildIfError(err, "Failed to open file", "file", s... | go | {
"resource": ""
} |
q17999 | GenerateTemplate | train | func GenerateTemplate(filename, templateSource string, args map[string]interface{}) (err error) {
tmpl := template.Must(template.New("").Parse(templateSource))
var b bytes.Buffer
if err = tmpl.Execute(&b, args); err != nil {
return NewBuildIfError(err, "ExecuteTemplate: Execute failed")
}
sourceCode := b.String... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.