func (cmd *cmdBreakfast) Run(title, from, text string) error { var err error if strings.HasPrefix(text, "!b-") { bfText := strings.TrimSpace(strings.TrimPrefix(text, "!b-")) if bfText == "" { // !b-: Reset list err = cmd.listReset(title) } else { // !b- n: Remove item n err = cmd.removeItem(title, bfText) } } else { bfText := strings.TrimSpace(strings.TrimPrefix(text, "!b")) if bfText == "" { // !b: List err = cmd.listItems(title) } else { // !b item: Add item to the list err = cmd.addItem(title, from, bfText) } } if err != nil { fmt.Fprintf(cmd.w, "msg %v error: cannot get or add items\n", title) return err } return nil }
// walk every arg looking for "file:" and calling iomHelper on the suffix. // Replace the arg with the local file if found. func iomPreprocessor(c *minicli.Command) (*minicli.Command, error) { for k, v := range c.StringArgs { if strings.HasPrefix(v, IOM_HELPER_MATCH) { file := strings.TrimPrefix(v, IOM_HELPER_MATCH) local, err := iomHelper(file) if err != nil { return nil, err } log.Debug("iomPreProcessor: %v -> %v", v, local) c.StringArgs[k] = local } } for k, v := range c.ListArgs { for x, y := range v { if strings.HasPrefix(y, IOM_HELPER_MATCH) { file := strings.TrimPrefix(y, IOM_HELPER_MATCH) local, err := iomHelper(file) if err != nil { return nil, err } log.Debug("iomPreProcessor: %v -> %v", y, local) c.ListArgs[k][x] = local } } } return c, nil }
// aliasExpand expands aliased (name:/path) to full URL, used by url-parser func aliasExpand(aliasedURL string, aliases map[string]string) (newURL string, err error) { u, err := client.Parse(aliasedURL) if err != nil { return aliasedURL, iodine.New(errInvalidURL{URL: aliasedURL}, nil) } // proper URL if u.Host != "" { return aliasedURL, nil } for aliasName, expandedURL := range aliases { if strings.HasPrefix(aliasedURL, aliasName+":") { // Match found. Expand it. splits := strings.Split(aliasedURL, ":") // if expandedURL is missing, return aliasedURL treat it like fs if expandedURL == "" { return aliasedURL, nil } // if more splits found return if len(splits) == 2 { // remove any prefixed slashes trimmedURL := expandedURL + "/" + strings.TrimPrefix(strings.TrimPrefix(splits[1], "/"), "\\") u, err := client.Parse(trimmedURL) if err != nil { return aliasedURL, iodine.New(errInvalidURL{URL: aliasedURL}, nil) } return u.String(), nil } return aliasedURL, nil } } return aliasedURL, nil }
// pathToKey translates etcd key paths into something more suitable for use // in Golang templates. Turn /prefix/key/subkey into key_subkey. func pathToKey(key, prefix string) string { prefix = strings.TrimPrefix(prefix, "/") key = strings.TrimPrefix(key, "/") key = strings.TrimPrefix(key, prefix) key = strings.TrimPrefix(key, "/") return replacer.Replace(key) }
func lookUpNamespace(type_, currentNs string) string { //Embeddeds or extends are often times empty if type_ == "" { return type_ } var prefix string if type_[0:1] == "*" { prefix = "*" type_ = type_[1:] } else if type_[0:3] == "[]*" { prefix = "[]*" type_ = type_[3:] } else if type_[0:2] == "[]" { prefix = "[]" type_ = type_[2:] } //strips out package name if it has it type_ = strings.TrimPrefix(type_, "mo.") type_ = strings.TrimPrefix(type_, "do.") type_ = strings.TrimPrefix(type_, "fault.") type_ = strings.TrimPrefix(type_, "enum.") targetNs := objnsmap[type_] if targetNs == "" || targetNs != "enum" || targetNs == currentNs { return prefix + type_ } return prefix + targetNs + "." + type_ }
// NewRequest creates a new raw request object to query the Vault server // configured for this client. This is an advanced method and generally // doesn't need to be called externally. func (c *Client) NewRequest(method, path string) *Request { req := &Request{ Method: method, URL: &url.URL{ Scheme: c.addr.Scheme, Host: c.addr.Host, Path: path, }, ClientToken: c.token, Params: make(map[string][]string), } var lookupPath string switch { case strings.HasPrefix(path, "/v1/"): lookupPath = strings.TrimPrefix(path, "/v1/") case strings.HasPrefix(path, "v1/"): lookupPath = strings.TrimPrefix(path, "v1/") default: lookupPath = path } if c.wrappingLookupFunc != nil { req.WrapTTL = c.wrappingLookupFunc(method, lookupPath) } else { req.WrapTTL = DefaultWrappingLookupFunc(method, lookupPath) } return req }
// based off of https://github.com/dotcloud/docker/blob/2a711d16e05b69328f2636f88f8eac035477f7e4/utils/utils.go func parseHost(addr string) (string, string, error) { var ( proto string host string port int ) addr = strings.TrimSpace(addr) switch { case addr == "tcp://": return "", "", fmt.Errorf("Invalid bind address format: %s", addr) case strings.HasPrefix(addr, "unix://"): proto = "unix" addr = strings.TrimPrefix(addr, "unix://") if addr == "" { addr = "/var/run/docker.sock" } case strings.HasPrefix(addr, "tcp://"): proto = "tcp" addr = strings.TrimPrefix(addr, "tcp://") case strings.HasPrefix(addr, "fd://"): return "fd", addr, nil case addr == "": proto = "unix" addr = "/var/run/docker.sock" default: if strings.Contains(addr, "://") { return "", "", fmt.Errorf("Invalid bind address protocol: %s", addr) } proto = "tcp" } if proto != "unix" && strings.Contains(addr, ":") { hostParts := strings.Split(addr, ":") if len(hostParts) != 2 { return "", "", fmt.Errorf("Invalid bind address format: %s", addr) } if hostParts[0] != "" { host = hostParts[0] } else { host = "127.0.0.1" } if p, err := strconv.Atoi(hostParts[1]); err == nil && p != 0 { port = p } else { return "", "", fmt.Errorf("Invalid bind address format: %s", addr) } } else if proto == "tcp" && !strings.Contains(addr, ":") { return "", "", fmt.Errorf("Invalid bind address format: %s", addr) } else { host = addr } if proto == "unix" { return proto, host, nil } return proto, fmt.Sprintf("%s:%d", host, port), nil }
// Add adds a pattern and associated value to the matcher. func (m *Matcher) Add(pattern string, v interface{}) error { if strings.HasPrefix(pattern, ExactPrefix) { s := strings.TrimPrefix(pattern, ExactPrefix) m.exact[s] = v return nil } if strings.HasPrefix(pattern, RegexPrefix) { s := strings.TrimPrefix(pattern, RegexPrefix) re, err := regexp.Compile(s) if err != nil { return err } m.regex = append(m.regex, struct { re *regexp.Regexp v interface{} }{ re: re, v: v, }) return nil } if strings.HasPrefix(pattern, SkipPrefix) { s := strings.TrimPrefix(pattern, SkipPrefix) m.trie.Add(s, &skipMatcher{ pattern: pattern, v: v, }) return nil } m.trie.Add(pattern, v) return nil }
// Strip ... func Strip(str string) string { dirty := true strippedStr := str for dirty { hasWhiteSpacePrefix := false if strings.HasPrefix(strippedStr, " ") { hasWhiteSpacePrefix = true strippedStr = strings.TrimPrefix(strippedStr, " ") } hasWhiteSpaceSuffix := false if strings.HasSuffix(strippedStr, " ") { hasWhiteSpaceSuffix = true strippedStr = strings.TrimSuffix(strippedStr, " ") } hasNewlinePrefix := false if strings.HasPrefix(strippedStr, "\n") { hasNewlinePrefix = true strippedStr = strings.TrimPrefix(strippedStr, "\n") } hasNewlineSuffix := false if strings.HasSuffix(strippedStr, "\n") { hasNewlinePrefix = true strippedStr = strings.TrimSuffix(strippedStr, "\n") } if !hasWhiteSpacePrefix && !hasWhiteSpaceSuffix && !hasNewlinePrefix && !hasNewlineSuffix { dirty = false } } return strippedStr }
func usrParse(usrStr string) (err error) { switch { default: err = client.Call("Receiver.SendMsg", Args{Token, usrStr}, nil) case strings.HasPrefix(usrStr, COMM_CREATEROOM): cName := strings.TrimSuffix(strings.TrimPrefix(usrStr, COMM_CREATEROOM+" "), "\n") err = client.Call("Receiver.CreateCRoom", Args{Token, cName}, nil) case strings.HasPrefix(usrStr, COMM_ENTERROOM): cName := strings.TrimSuffix(strings.TrimPrefix(usrStr, COMM_ENTERROOM+" "), "\n") err = client.Call("Receiver.JoinCRoom", Args{Token, cName}, nil) case strings.HasPrefix(usrStr, COMM_LEAVEROOM): err = client.Call("Receiver.LeaveCRoom", &Token, nil) case strings.HasPrefix(usrStr, COMM_LISTROOMS): err = client.Call("Receiver.ListCRooms", &Token, nil) case strings.HasPrefix(usrStr, COMM_HELPCHAT): fmt.Print(MESS_HELP) case strings.HasPrefix(usrStr, COMM_CHANGENAME): cName := strings.TrimSuffix(strings.TrimPrefix(usrStr, COMM_CHANGENAME+" "), "\n") err = client.Call("Receiver.ChangeName", Args{Token, cName}, nil) case strings.HasPrefix(usrStr, COMM_QUITCHAT): err = client.Call("Receiver.Quit", &Token, nil) waitG.Done() } //fmt.Print(err) return err }
func TestCacheKeyFields(t *testing.T) { keyJSON, err := cacheKey(kapi.NewContext(), &authorizer.DefaultAuthorizationAttributes{}) if err != nil { t.Fatalf("unexpected error: %v", err) } keyMap := map[string]interface{}{} if err := json.Unmarshal([]byte(keyJSON), &keyMap); err != nil { t.Fatalf("unexpected error: %v", err) } keys := sets.NewString() for k := range keyMap { keys.Insert(strings.ToLower(k)) } // These are results we don't expect to be in the cache key expectedMissingKeys := sets.NewString("requestattributes") attrType := reflect.TypeOf((*authorizer.AuthorizationAttributes)(nil)).Elem() for i := 0; i < attrType.NumMethod(); i++ { name := attrType.Method(i).Name name = strings.TrimPrefix(name, "Get") name = strings.TrimPrefix(name, "Is") name = strings.ToLower(name) if !keys.Has(name) && !expectedMissingKeys.Has(name) { t.Errorf("computed cache is missing an entry for %s", attrType.Method(i).Name) } } }
// GetHostFromUrl extracts the host from an URL. // Local file urls starting with 'file://' are skipped. func GetHostFromUrl(url string) string { url = strings.TrimSpace(url) // Skip if this is a local file url. if strings.HasPrefix(url, "file://") { return url } if strings.HasPrefix(url, "http://") { url = strings.TrimPrefix(url, "http://") } else if strings.HasPrefix(url, "https://") { url = strings.TrimPrefix(url, "https://") } else if strings.HasPrefix(url, "git@") { url = strings.TrimPrefix(url, "git@") } // Remove everything after the first slash. pos := strings.Index(url, "/") if pos >= 0 { url = url[:pos] } // Remove everything after the ':'. // This is important for git urls. pos = strings.Index(url, ":") if pos >= 0 { url = url[:pos] } return url }
func getFileSummary(filename, dir, cmd, out string) (FileSummary, error) { filename = strings.TrimPrefix(filename, "repos/src") githubLink := strings.TrimPrefix(dir, "repos/src") fileURL := "https://" + strings.TrimPrefix(dir, "repos/src/") + "/blob/master" + strings.TrimPrefix(filename, githubLink) fs := FileSummary{ Filename: filename, FileURL: fileURL, } split := strings.Split(string(out), "\n") for _, sp := range split[0 : len(split)-1] { parts := strings.Split(sp, ":") msg := sp if cmd != "gocyclo" { msg = parts[len(parts)-1] } e := Error{ErrorString: msg} switch cmd { case "golint", "gocyclo", "vet": ln, err := strconv.Atoi(strings.Split(sp, ":")[1]) if err != nil { return fs, err } e.LineNumber = ln } fs.Errors = append(fs.Errors, e) } return fs, nil }
func uri(workdir, fn string) string { u := fn u = strings.TrimPrefix(u, path.Join(workdir, "markdowns")) u = strings.TrimPrefix(u, path.Join(workdir, "templates")) u = strings.TrimPrefix(u, path.Join(workdir, "statics")) return u }
func simpleImporter(imports map[string]*ast.Object, path string) (*ast.Object, error) { pkg := imports[path] if pkg == nil { // Guess the package name without importing it. Start with the last // element of the path. name := path[strings.LastIndex(path, "/")+1:] // Trim commonly used prefixes and suffixes containing illegal name // runes. name = strings.TrimSuffix(name, ".go") name = strings.TrimSuffix(name, "-go") name = strings.TrimPrefix(name, "go.") name = strings.TrimPrefix(name, "go-") name = strings.TrimPrefix(name, "biogo.") // It's also common for the last element of the path to contain an // extra "go" prefix, but not always. TODO: examine unresolved ids to // detect when trimming the "go" prefix is appropriate. pkg = ast.NewObj(ast.Pkg, name) pkg.Data = ast.NewScope(nil) imports[path] = pkg } return pkg, nil }
// Read an input configuration file, parsing it (as YAML or JSON) // into the input 'interface{}', v func Read(path string, v interface{}, schema string) []serror.SnapError { // read bytes from file b, err := cfgReader.ReadFile(path) if err != nil { return []serror.SnapError{serror.New(err)} } // convert from YAML to JSON (remember, JSON is actually valid YAML) jb, err := yaml.YAMLToJSON(b) if err != nil { return []serror.SnapError{serror.New(fmt.Errorf("error converting YAML to JSON: %v", err))} } // validate the resulting JSON against the input the schema if errors := cfgValidator.validateSchema(schema, string(jb)); errors != nil { // if invalid, construct (and return?) a SnapError from the errors identified // during schema validation return errors } // if valid, parse the JSON byte-stream (above) if parseErr := json.Unmarshal(jb, v); parseErr != nil { // remove any YAML-specific prefix that might have been added by then // yaml.Unmarshal() method or JSON-specific prefix that might have been // added if the resulting JSON string could not be marshalled into our // input interface correctly (note, if there is no match to either of // these prefixes then the error message will be passed through unchanged) tmpErr := strings.TrimPrefix(parseErr.Error(), "error converting YAML to JSON: yaml: ") errRet := strings.TrimPrefix(tmpErr, "error unmarshaling JSON: json: ") return []serror.SnapError{serror.New(fmt.Errorf("Error while parsing configuration file: %v", errRet))} } return nil }
func (t *LibCTarget) GetOutputFile() *actions.File { if file_list == nil { file_list = make(map[string]*actions.File) } outfile_name := strings.TrimPrefix(t.Name, "//") + ".a" f, ok := file_list[outfile_name] if ok { return f } inputs := actions.MakeCObjects(t.Name, t.Sources, t.Resources, file_list) ar_action := actions.Action{ Name: strings.TrimPrefix(t.Name, "//"), Infiles: inputs, Method: "Task.ArLink", } outfile := actions.File{ Filename: outfile_name, Action: &ar_action, Sem: make(chan int, 1), } file_list[outfile_name] = &outfile return &outfile }
// cleanWindowsName will clean invalid Windows characters func cleanWindowsName(f *Fs, name string) string { original := name var name2 string if strings.HasPrefix(name, `\\?\`) { name2 = `\\?\` name = strings.TrimPrefix(name, `\\?\`) } if strings.HasPrefix(name, `//?/`) { name2 = `//?/` name = strings.TrimPrefix(name, `//?/`) } // Colon is allowed as part of a drive name X:\ colonAt := strings.Index(name, ":") if colonAt > 0 && colonAt < 3 && len(name) > colonAt+1 { // Copy to name2, which is unfiltered name2 += name[0 : colonAt+1] name = name[colonAt+1:] } name2 += strings.Map(func(r rune) rune { switch r { case '<', '>', '"', '|', '?', '*', ':': return '_' } return r }, name) if name2 != original && f != nil { if _, ok := f.warned[name]; !ok { fs.Debug(f, "Replacing invalid characters in %q to %q", name, name2) f.warned[name] = struct{}{} } } return name2 }
// ParseTCPAddr parses and validates that the specified address is a valid TCP // address. It returns a formatted TCP address, either using the address parsed // from tryAddr, or the contents of defaultAddr if tryAddr is a blank string. // tryAddr is expected to have already been Trim()'d // defaultAddr must be in the full `tcp://host:port` form func ParseTCPAddr(tryAddr string, defaultAddr string) (string, error) { if tryAddr == "" || tryAddr == "tcp://" { return defaultAddr, nil } addr := strings.TrimPrefix(tryAddr, "tcp://") if strings.Contains(addr, "://") || addr == "" { return "", fmt.Errorf("Invalid proto, expected tcp: %s", tryAddr) } u, err := url.Parse("tcp://" + addr) if err != nil { return "", err } hostParts := strings.Split(u.Host, ":") if len(hostParts) != 2 { return "", fmt.Errorf("Invalid bind address format: %s", tryAddr) } defaults := strings.Split(defaultAddr, ":") if len(defaults) != 3 { return "", fmt.Errorf("Invalid defaults address format: %s", defaultAddr) } host := hostParts[0] if host == "" { host = strings.TrimPrefix(defaults[1], "//") } if hostParts[1] == "" { hostParts[1] = defaults[2] } p, err := strconv.Atoi(hostParts[1]) if err != nil && p == 0 { return "", fmt.Errorf("Invalid bind address format: %s", tryAddr) } return fmt.Sprintf("tcp://%s:%d%s", host, p, u.Path), nil }
// input makes a dataset available for computations in the container. func (p *pipeline) input(name string) error { var trimmed string switch { case strings.HasPrefix(name, "s3://"): trimmed = strings.TrimPrefix(name, "s3://") if err := WaitPipeline(p.pipelineDir, trimmed, p.commit); err != nil { return err } if err := p.bind(path.Join(p.pipelineDir, trimmed), "", path.Join("/in", trimmed)); err != nil { return err } case strings.HasPrefix(name, "pps://"): trimmed = strings.TrimPrefix(name, "pps://") if err := WaitPipeline(p.pipelineDir, trimmed, p.commit); err != nil { return err } if err := p.bind(path.Join(p.pipelineDir, trimmed), "", path.Join("/in", trimmed)); err != nil { return err } case strings.HasPrefix(name, "pfs://"): fallthrough default: if err := p.bind(p.inRepo, name, path.Join("/in", name)); err != nil { return err } } return nil }
// ListKeys returns a map of unique PublicKeys present on the KeyFileStore and // their corresponding aliases. func listKeys(s LimitedFileStore) map[string]string { keyIDMap := make(map[string]string) for _, f := range s.ListFiles() { // Remove the prefix of the directory from the filename if f[:len(rootKeysSubdir)] == rootKeysSubdir { f = strings.TrimPrefix(f, rootKeysSubdir+"/") } else { f = strings.TrimPrefix(f, nonRootKeysSubdir+"/") } // Remove the extension from the full filename // abcde_root.key becomes abcde_root keyIDFull := strings.TrimSpace(strings.TrimSuffix(f, filepath.Ext(f))) // If the key does not have a _, it is malformed underscoreIndex := strings.LastIndex(keyIDFull, "_") if underscoreIndex == -1 { continue } // The keyID is the first part of the keyname // The KeyAlias is the second part of the keyname // in a key named abcde_root, abcde is the keyID and root is the KeyAlias keyID := keyIDFull[:underscoreIndex] keyAlias := keyIDFull[underscoreIndex+1:] keyIDMap[keyID] = keyAlias } return keyIDMap }
func c_hbase_replication() (opentsdb.MultiDataPoint, error) { var j jmx if err := getBeans(hbRepURL, &j); err != nil { return nil, err } excludeReg, err := regexp.Compile("source.\\d") if err != nil { return nil, err } var md opentsdb.MultiDataPoint for _, section := range j.Beans { for k, v := range section { // source.[0-9] entries are for other hosts in the cluster if excludeReg.MatchString(k) { continue } // Strip "source." and "sink." from the metric names. shortName := strings.TrimPrefix(k, "source.") shortName = strings.TrimPrefix(shortName, "sink.") metric := "hbase.region." + shortName if _, ok := v.(float64); ok { Add(&md, metric, v, nil, metadata.Unknown, metadata.None, "") } } } return md, nil }
func TestSnmpServer(t *testing.T) { srv, e := NewUdpServerFromString("a", "127.0.0.1:0", mib_string, false) if nil != e { t.Error(e) return } defer srv.Close() for idx, test := range oid_and_value { oid := strings.TrimPrefix(test.oid, "[oid]") v, e := ReadSnmpValue("127.0.0.1:"+srv.GetPort(), oid, SNMP_PDU_GET) if nil != e { t.Error("test[", idx, "]", test.oid, e) continue } if v.String() != test.value { t.Error("test[", idx, "]", v.String(), "of", test.oid, "is not equals", test.value) } } for idx, test := range next_oid_and_value { oid := strings.TrimPrefix(test.oid, "[oid]") v, e := ReadSnmpValue("127.0.0.1:"+srv.GetPort(), oid, SNMP_PDU_GETNEXT) if nil != e { t.Error("testNext[", idx, "]", test.oid, e) continue } if v.String() != test.value { t.Error("testNext[", idx, "]", v.String(), "of", test.oid, "is not equals", test.value) } } }
func (ta *Table) AddColumn(name string, columnType string, extra string) { index := len(ta.Columns) ta.Columns = append(ta.Columns, TableColumn{Name: name}) if strings.Contains(columnType, "int") || strings.HasPrefix(columnType, "year") { ta.Columns[index].Type = TYPE_NUMBER } else if columnType == "float" || columnType == "double" { ta.Columns[index].Type = TYPE_FLOAT } else if strings.HasPrefix(columnType, "enum") { ta.Columns[index].Type = TYPE_ENUM ta.Columns[index].EnumValues = strings.Split(strings.Replace( strings.TrimSuffix( strings.TrimPrefix( columnType, "enum("), ")"), "'", "", -1), ",") } else if strings.HasPrefix(columnType, "set") { ta.Columns[index].Type = TYPE_SET ta.Columns[index].SetValues = strings.Split(strings.Replace( strings.TrimSuffix( strings.TrimPrefix( columnType, "set("), ")"), "'", "", -1), ",") } else { ta.Columns[index].Type = TYPE_STRING } if extra == "auto_increment" { ta.Columns[index].IsAuto = true } }
func (config TaskConfig) validateDotPath() []string { messages := []string{} pathCount := 0 dotPath := false for _, input := range config.Inputs { path := strings.TrimPrefix(input.resolvePath(), "./") if path == "." { dotPath = true } pathCount++ } for _, output := range config.Outputs { path := strings.TrimPrefix(output.resolvePath(), "./") if path == "." { dotPath = true } pathCount++ } if pathCount > 1 && dotPath { messages = append(messages, " you may not have more than one input or output when one of them has a path of '.'") } return messages }
func (s *ServiceRuntime) stopContainer(container *docker.Container) error { if _, ok := blacklistedContainerId[container.ID]; ok { log.Printf("Container %s blacklisted. Won't try to stop.\n", container.ID) return nil } log.Printf("Stopping %s container %s\n", strings.TrimPrefix(container.Name, "/"), container.ID[0:12]) c := make(chan error, 1) go func() { c <- s.dockerClient.StopContainer(container.ID, 10) }() select { case err := <-c: if err != nil { log.Printf("ERROR: Unable to stop container: %s\n", container.ID) return err } case <-time.After(20 * time.Second): blacklistedContainerId[container.ID] = true log.Printf("ERROR: Timed out trying to stop container. Zombie?. Blacklisting: %s\n", container.ID) return nil } log.Printf("Stopped %s container %s\n", strings.TrimPrefix(container.Name, "/"), container.ID[0:12]) return nil // TODO: why is this commented out? // Should we verify that containers are actually removed somehow? /* return s.dockerClient.RemoveContainer(docker.RemoveContainerOptions{ ID: container.ID, RemoveVolumes: true, })*/ }
// Return the text of the comment with // or /* and */ stripped func (c Comment) Text() string { l := 0 for _, comment := range c.Comment { l += len(comment) + 1 } buf := make([]byte, 0, l) blockComment := false if strings.HasPrefix(c.Comment[0], "/*") { blockComment = true } for i, comment := range c.Comment { if blockComment { if i == 0 { comment = strings.TrimPrefix(comment, "/*") } if i == len(c.Comment)-1 { comment = strings.TrimSuffix(comment, "*/") } } else { comment = strings.TrimPrefix(comment, "//") } buf = append(buf, comment...) buf = append(buf, '\n') } return string(buf) }
func (me *LoadTestProvider) ChannelsCommand(c *Context, channelId string, message string) *model.CommandResponse { cmd := strings.TrimSpace(strings.TrimPrefix(message, "channels")) doFuzz := false if strings.Index(cmd, "fuzz") == 0 { doFuzz = true cmd = strings.TrimSpace(strings.TrimPrefix(cmd, "fuzz")) } channelsr, err := parseRange(cmd, "") if err == false { channelsr = utils.Range{2, 5} } var team *model.Team if tr := <-Srv.Store.Team().Get(c.TeamId); tr.Err != nil { return &model.CommandResponse{Text: "Failed to create testing environment", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL} } else { team = tr.Data.(*model.Team) } client := model.NewClient(c.GetSiteURL()) client.SetTeamId(team.Id) client.MockSession(c.Session.Token) channelCreator := NewAutoChannelCreator(client, team) channelCreator.Fuzzy = doFuzz channelCreator.CreateTestChannels(channelsr) return &model.CommandResponse{Text: "Added channels", ResponseType: model.COMMAND_RESPONSE_TYPE_EPHEMERAL} }
// Lexes a string in single quotes, whitespaces in the string are permitted. // Example: 'foo bar is great' func lexQuotedString(l *lexer) stateFn { // the string only consists of the current fild if strings.HasPrefix(l.input[l.start], "'") && strings.HasSuffix(l.input[l.start], "'") { out := strings.TrimPrefix(l.input[l.start], "'") out = strings.TrimRight(out, "'") l.emit(STRING, out) return lexAttributes } // the string consists of multiple fields out := make([]string, 0) out = append(out, strings.TrimPrefix(l.input[l.start], "'")) l.pos++ for { if l.pos == len(l.input) { l.eof("QuotedString") } if strings.HasSuffix(l.input[l.pos], "'") { out = append(out, strings.TrimRight(l.input[l.pos], "'")) l.emit(STRING, strings.Join(out, " ")) return lexAttributes } out = append(out, l.input[l.pos]) l.pos++ } }
// NewStorageError - return new Error type. func traceError(e error, errs ...error) error { if e == nil { return nil } err := &Error{} err.e = e err.errs = errs stack := make([]uintptr, 40) length := runtime.Callers(2, stack) if length > len(stack) { length = len(stack) } stack = stack[:length] for _, pc := range stack { pc = pc - 1 fn := runtime.FuncForPC(pc) file, line := fn.FileLine(pc) name := fn.Name() if strings.HasSuffix(name, "ServeHTTP") { break } if strings.HasSuffix(name, "runtime.") { break } file = strings.TrimPrefix(file, rootPath+string(os.PathSeparator)) name = strings.TrimPrefix(name, "github.com/minio/minio/cmd.") err.trace = append(err.trace, traceInfo{file, line, name}) } return err }