Golang TrimSuffix示例

说明

golang trimsuffix示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: strings

示例#1
文件: slow.go 项目: charity/mysql-log-parser

func (p *SlowLogParser) sendEvent(inHeader bool, inQuery bool) {
	if p.opt.Debug {
		l.Println("send event")
	}

	// Make a new event and reset our metadata.
	defer func() {
		p.event = log.NewEvent()
		p.headerLines = 0
		p.queryLines = 0
		p.inHeader = inHeader
		p.inQuery = inQuery
	}()

	if _, ok := p.event.TimeMetrics["Query_time"]; !ok {
		if p.headerLines == 0 {
			l.Panicf("No Query_time in event at %d: %#v", p.lineOffset, p.event)
		}
		// Started parsing in header after Query_time.  Throw away event.
		return
	}

	// Clean up the event.
	p.event.Db = strings.TrimSuffix(p.event.Db, ";\n")
	p.event.Query = strings.TrimSuffix(p.event.Query, ";")

	// Send the event.  This will block.
	select {
	case p.EventChan <- p.event:
	case <-p.stopChan:
		p.stopped = true
	}
}

示例#2
文件: glog.go 项目: miffa/glog-1

/**
 * parse split chars and return value
 */
func parse_split(split string) (id byte, value int, err error) {
	split = strings.ToLower(split)
	switch split {
	case "day":
		id, value = SPLIT_DAY, 1
	default:
		if strings.HasSuffix(split, "hour") {
			id = SPLIT_HOUR
			value, err = strconv.Atoi(strings.TrimSuffix(split, "hour"))
			//fix illegal hour
			if err == nil && (value < 1 || value > 23) {
				value = 1
			}
		} else if strings.HasSuffix(split, "min") {
			id = SPLIT_MIN
			value, err = strconv.Atoi(strings.TrimSuffix(split, "min"))
			//fix illegal minute
			if err == nil && (value > 60 || value < 5) {
				value = 5
			}
		} else if strings.HasSuffix(split, "m") {
			id = SPLIT_SIZE
			value, err = strconv.Atoi(strings.TrimSuffix(split, "m"))
			//fix illegal size
			if err == nil && value < 1 {
				value = 1
			}
		} else {
			err = errors.New("unknow split")
		}
	}
	return
}

示例#3
文件: deploy.go 项目: tanlanxing/champloo

// 回滚部署
func ExecuteRollback(username string, params martini.Params, r render.Render) {
	deployId, _ := strconv.Atoi(params["id"])

	var deploy Deploy
	db.First(&deploy, deployId)

	if deploy.Id <= 0 {
		sendFailMsg(r, "该版本不存在.", nil)
		return
	}

	id := deploy.SystemId
	stage := deploy.Stage
	if isDeploying(id) {
		sendFailMsg(r, "另一部署进程正在进行中,请稍候.", nil)
		return
	}

	var conf SystemConfig
	db.First(&conf, id)
	workdir := conf.Path
	switch deploy.Stage {
	case "dev":
		workdir = strings.TrimSuffix(conf.Path, "/") + "/development"
	case "prod":
		workdir = strings.TrimSuffix(conf.Path, "/") + "/production"
	default:
	}
	releaseDir := fmt.Sprintf("%s/releases", workdir)
	versionDir := fmt.Sprintf("%s/%s", releaseDir, deploy.Version)
	currentDir := fmt.Sprintf("%s/current", workdir)
	tags := conf.Tags

	cmds := NewShellCommand()
	// 判断该版本目录是否存在,存在直接回滚
	cmds.ExistDir(versionDir).Rollback(versionDir, currentDir)

	// 取对应该tag的所有服务器
	servers := getTagServers(tags)

	session := NewShellSession(servers, *cmds, deployId)
	mutex.Lock()
	sessions[id] = session
	mutex.Unlock()

	session.ParallelRun()
	if !session.Success {
		sendFailMsg(r, "回滚失败.", session.Output())
		return
	}

	// 去掉旧的部署的启用状态
	db.Model(Deploy{}).Where(Deploy{SystemId: id, Stage: stage, Enable: true}).Update(map[string]interface{}{"enable": false})

	deploy.Enable = true
	db.Save(&deploy)
	sendSuccessMsg(r, session.Output())
	return

}

示例#4
文件: ls.go 项目: akiradeveloper/mc

// parseContent parse client Content container into printer struct.
func parseContent(c *client.Content) ContentMessage {
	content := ContentMessage{}
	content.Time = c.Time.Local()

	// guess file type
	content.Filetype = func() string {
		if c.Type.IsDir() {
			return "folder"
		}
		return "file"
	}()

	content.Size = c.Size
	// Convert OS Type to match console file printing style.
	content.Name = func() string {
		switch {
		case runtime.GOOS == "windows":
			c.Name = strings.Replace(c.Name, "/", "\\", -1)
			c.Name = strings.TrimSuffix(c.Name, "\\")
		default:
			c.Name = strings.TrimSuffix(c.Name, "/")
		}
		if c.Type.IsDir() {
			switch {
			case runtime.GOOS == "windows":
				return fmt.Sprintf("%s\\", c.Name)
			default:
				return fmt.Sprintf("%s/", c.Name)
			}
		}
		return c.Name
	}()
	return content
}

示例#5
文件: elasticsearch.go 项目: eswdd/bosun

// structProcessor.add() takes in a metric name prefix, an arbitrary struct, and a tagset.
// The processor recurses through the struct and builds metrics. The field tags direct how
// the field should be processed, as well as the metadata for the resulting metric.
//
// The field tags used are described as follows:
//
// version: typically set to '1' or '2'.
//	This is compared against the elastic cluster version. If the version from the tag
//      does not match the version in production, the metric will not be sent for this field.
//
// exclude:
//      If this tag is set to 'true', a metric will not be sent for this field.
//
// rate: one of 'gauge', 'counter', 'rate'
//	This tag dictates the metadata.RateType we send.
//
// unit: 'bytes', 'pages', etc
//	This tag dictates the metadata.Unit we send.
//
// metric:
//      This is the metric name which will be sent. If not present, the 'json'
//      tag is sent as the metric name.
//
// Special handling:
//
// Metrics having the json tag suffix of 'in_milliseconds' are automagically
// divided by 1000 and sent as seconds. The suffix is stripped from the name.
//
// Metrics having the json tag suffix of 'in_bytes' are automatically sent as
// gauge bytes. The suffix is stripped from the metric name.
func (s *structProcessor) add(prefix string, st interface{}, ts opentsdb.TagSet) {
	t := reflect.TypeOf(st)
	valueOf := reflect.ValueOf(st)
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		value := valueOf.Field(i).Interface()
		if field.Tag.Get("exclude") == "true" {
			continue
		}
		var (
			jsonTag    = field.Tag.Get("json")
			metricTag  = field.Tag.Get("metric")
			versionTag = field.Tag.Get("version")
			rateTag    = field.Tag.Get("rate")
			unitTag    = field.Tag.Get("unit")
		)
		metricName := jsonTag
		if metricTag != "" {
			metricName = metricTag
		}
		if metricName == "" {
			slog.Errorf("Unable to determine metric name for field %s. Skipping.", field.Name)
			continue
		}
		if versionTag == "" || strings.HasPrefix(s.elasticVersion, versionTag) {
			switch value := value.(type) {
			case int, float64: // Number types in our structs are only ints and float64s.
				// Turn all millisecond metrics into seconds
				if strings.HasSuffix(metricName, "_in_millis") {
					switch value.(type) {
					case int:
						value = float64(value.(int)) / 1000
					case float64:
						value = value.(float64) / 1000
					}
					unitTag = "seconds"
					metricName = strings.TrimSuffix(metricName, "_in_millis")
				}
				// Set rate and unit for all "_in_bytes" metrics, and strip the "_in_bytes"
				if strings.HasSuffix(metricName, "_in_bytes") {
					if rateTag == "" {
						rateTag = "gauge"
					}
					unitTag = "bytes"
					metricName = strings.TrimSuffix(metricName, "_in_bytes")
				}
				Add(s.md, prefix+"."+metricName, value, ts, metadata.RateType(rateTag), metadata.Unit(unitTag), field.Tag.Get("desc"))
			case string:
				// The json data has a lot of strings, and we don't care about em.
			default:
				// If we hit another struct, recurse
				if reflect.ValueOf(value).Kind() == reflect.Struct {
					s.add(prefix+"."+metricName, value, ts)
				} else {
					slog.Errorf("Field %s for metric %s is non-numeric type. Cannot record as a metric.\n", field.Name, prefix+"."+metricName)
				}
			}
		}
	}
}

示例#6
文件: autorouter.go 项目: Linvas/ant

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
}

示例#7
文件: docker_cli_exec_test.go 项目: jbbarth/docker

func TestInspectExecID(t *testing.T) {
	defer deleteAllContainers()

	out, exitCode, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-d", "busybox", "top"))
	if exitCode != 0 || err != nil {
		t.Fatalf("failed to run container: %s, %v", out, err)
	}
	id := strings.TrimSuffix(out, "\n")

	out, err = inspectField(id, "ExecIDs")
	if err != nil {
		t.Fatalf("failed to inspect container: %s, %v", out, err)
	}
	if out != "<no value>" {
		t.Fatalf("ExecIDs should be empty, got: %s", out)
	}

	exitCode, err = runCommand(exec.Command(dockerBinary, "exec", "-d", id, "ls", "/"))
	if exitCode != 0 || err != nil {
		t.Fatalf("failed to exec in container: %s, %v", out, err)
	}

	out, err = inspectField(id, "ExecIDs")
	if err != nil {
		t.Fatalf("failed to inspect container: %s, %v", out, err)
	}

	out = strings.TrimSuffix(out, "\n")
	if out == "[]" || out == "<no value>" {
		t.Fatalf("ExecIDs should not be empty, got: %s", out)
	}

	logDone("inspect - inspect a container with ExecIDs")
}

示例#8
文件: viewdocs.go 项目: sbusso/viewdocs

func handleRedirects(w http.ResponseWriter, r *http.Request, user string, repo string, ref string, doc string) bool {
	redirectTo := ""
	if r.RequestURI == "/" {
		redirectTo = "http://progrium.viewdocs.io/viewdocs/"
	}
	if strings.Contains(r.Host, "progrium") && strings.HasPrefix(r.RequestURI, "/dokku") {
		redirectTo = "http://dokku.viewdocs.io" + r.RequestURI
	}
	if isAsset(doc) {
		redirectTo = "https://cdn.rawgit.com/" + user + "/" + repo + "/" + ref + "/docs/" + doc
	}
	if !strings.HasSuffix(r.RequestURI, "/") {
		for ext := range markdownExtensions() {
			if strings.HasSuffix(r.RequestURI, ext) {
				redirectTo = strings.TrimSuffix(r.RequestURI, ext) + "/"
				break
			}
		}
		if redirectTo == "" {
			redirectTo = r.RequestURI + "/"
		}
	}
	for ext := range markdownExtensions() {
		if strings.HasSuffix(r.RequestURI, ext+"/") {
			redirectTo = strings.TrimSuffix(r.RequestURI, ext+"/") + "/"
			break
		}
	}
	if redirectTo != "" {
		log.Println("REDIRECT: ", redirectTo)
		http.Redirect(w, r, redirectTo, 301)
		return true
	}
	return false
}

示例#9
文件: kubeproxy.go 项目: chiefy/kubernetes

func (config *KubeProxyTestConfig) hitNodePort(epCount int) {
	node1_IP := strings.TrimSuffix(config.nodes[0], ":22")
	tries := epCount*epCount + 5 // + 10 if epCount == 0
	By("dialing(udp) node1 --> node1:nodeUdpPort")
	config.dialFromNode("udp", node1_IP, nodeUdpPort, tries, epCount)
	By("dialing(http) node1  --> node1:nodeHttpPort")
	config.dialFromNode("http", node1_IP, nodeHttpPort, tries, epCount)

	By("dialing(udp) test container --> node1:nodeUdpPort")
	config.dialFromTestContainer("udp", node1_IP, nodeUdpPort, tries, epCount)
	By("dialing(http) container --> node1:nodeHttpPort")
	config.dialFromTestContainer("http", node1_IP, nodeHttpPort, tries, epCount)

	By("dialing(udp) endpoint container --> node1:nodeUdpPort")
	config.dialFromEndpointContainer("udp", node1_IP, nodeUdpPort, tries, epCount)
	By("dialing(http) endpoint container --> node1:nodeHttpPort")
	config.dialFromEndpointContainer("http", node1_IP, nodeHttpPort, tries, epCount)

	// TODO: doesnt work because masquerading is not done
	By("TODO: Test disabled. dialing(udp) node --> 127.0.0.1:nodeUdpPort")
	//config.dialFromNode("udp", "127.0.0.1", nodeUdpPort, tries, epCount)
	// TODO: doesnt work because masquerading is not done
	By("Test disabled. dialing(http) node --> 127.0.0.1:nodeHttpPort")
	//config.dialFromNode("http", "127.0.0.1", nodeHttpPort, tries, epCount)

	node2_IP := strings.TrimSuffix(config.nodes[1], ":22")
	By("dialing(udp) node1 --> node2:nodeUdpPort")
	config.dialFromNode("udp", node2_IP, nodeUdpPort, tries, epCount)
	By("dialing(http) node1 --> node2:nodeHttpPort")
	config.dialFromNode("http", node2_IP, nodeHttpPort, tries, epCount)
}

示例#10
文件: main.go 项目: knames/cmpt436chatCLIENT

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
}

示例#11
文件: discovery.go 项目: RAMESHBABUK/docker

// Scan scans all the plugin paths and returns all the names it found
func Scan() ([]string, error) {
	var names []string
	if err := filepath.Walk(socketsPath, func(path string, fi os.FileInfo, err error) error {
		if err != nil {
			return nil
		}

		if fi.Mode()&os.ModeSocket != 0 {
			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
			names = append(names, name)
		}
		return nil
	}); err != nil {
		return nil, err
	}

	for _, path := range specsPaths {
		if err := filepath.Walk(path, func(p string, fi os.FileInfo, err error) error {
			if err != nil || fi.IsDir() {
				return nil
			}
			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
			names = append(names, name)
			return nil
		}); err != nil {
			return nil, err
		}
	}
	return names, nil
}

示例#12
文件: git.go 项目: Lanzafame/todo-tracks

func (repository *gitRepository) GetBrowseUrl(revision Revision, path string, lineNumber int) string {
	rawUrl := fmt.Sprintf("/raw?repo=%s&revision=%s&fileName=%s&lineNumber=%d",
		repository.GetRepoId(), string(revision), url.QueryEscape(path), lineNumber)
	out, err := repository.runGitCommand(exec.Command("git", "remote", "-v"))
	if err != nil {
		return rawUrl
	}
	remotes := strings.Split(strings.Trim(string(out), "\n"), "\n")
	for _, remote := range remotes {
		remoteParts := strings.SplitN(remote, "\t", 2)
		if len(remoteParts) == 2 {
			remoteUrl := strings.Split(remoteParts[1], " ")[0]
			if isGitHubHttpsUrl(remoteUrl) {
				browseSuffix := gitHubBrowseSuffix(revision, path, lineNumber)
				return strings.TrimSuffix(remoteUrl, ".git") + browseSuffix
			}
			if isGitHubSshUrl(remoteUrl) {
				browseSuffix := gitHubBrowseSuffix(revision, path, lineNumber)
				repoName := strings.SplitN(
					strings.TrimSuffix(remoteUrl, ".git"),
					":", 2)[1]
				return "https://github.com/" + repoName + browseSuffix
			}
		}
	}
	return rawUrl
}

示例#13
文件: root.go 项目: romana/core

// preConfig sanitizes URLs and sets up config with URLs.
func preConfig(cmd *cli.Command, args []string) {
	var baseURL string

	// Add port details to rootURL else try localhost
	// if nothing is given on command line or config.
	if rootURL == "" {
		rootURL = config.GetString("RootURL")
	}
	if rootPort == "" {
		rootPort = config.GetString("RootPort")
	}
	if rootPort == "" {
		re, _ := regexp.Compile(`:\d+/?`)
		port := re.FindString(rootURL)
		port = strings.TrimPrefix(port, ":")
		port = strings.TrimSuffix(port, "/")
		if port != "" {
			rootPort = port
		} else {
			rootPort = "9600"
		}
	}
	config.Set("RootPort", rootPort)
	if rootURL != "" {
		baseURL = strings.TrimSuffix(rootURL, "/")
		baseURL = strings.TrimSuffix(baseURL, ":9600")
		baseURL = strings.TrimSuffix(baseURL, ":"+rootPort)
	} else {
		baseURL = "http://localhost"
	}
	config.Set("BaseURL", baseURL)
	rootURL = baseURL + ":" + rootPort + "/"
	config.Set("RootURL", rootURL)

	// Give command line options higher priority then
	// the corresponding config options.
	if format == "" {
		format = config.GetString("Format")
	}
	// if format is still not found just default to tabular format.
	if format == "" {
		format = "table"
	}
	config.Set("Format", format)

	if platform == "" {
		platform = config.GetString("Platform")
	}
	if platform == "" {
		platform = "openstack"
	}
	config.Set("Platform", platform)

	fmt.Println(config.GetString("username"))
	err := credential.Initialize()
	if err != nil {
		log.Printf("Error: %s", err)
		os.Exit(1)
	}
}

示例#14
文件: parse.go 项目: 40a/bootkube

// AddDirRecursive is just like AddDir, but it also recursively adds
// subdirectories; it returns an error only if the path couldn't be resolved;
// any directories recursed into without go source are ignored.
func (b *Builder) AddDirRecursive(dir string) error {
	// This is a bit of a hack.  The srcDir argument to Import() should
	// properly be the dir of the file which depends on the package to be
	// imported, so that vendoring can work properly.  We assume that there is
	// only one level of vendoring, and that the CWD is inside the GOPATH, so
	// this should be safe.
	cwd, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("unable to get current directory: %v", err)
	}

	// First, find it, so we know what path to use.
	pkg, err := b.context.Import(dir, cwd, build.FindOnly)
	if err != nil {
		return fmt.Errorf("unable to *find* %q: %v", dir, err)
	}

	if err := b.addDir(dir, true); err != nil {
		glog.Warningf("Ignoring directory %v: %v", dir, err)
	}

	prefix := strings.TrimSuffix(pkg.Dir, strings.TrimSuffix(dir, "/"))
	filepath.Walk(pkg.Dir, func(path string, info os.FileInfo, err error) error {
		if info != nil && info.IsDir() {
			trimmed := strings.TrimPrefix(path, prefix)
			if trimmed != "" {
				if err := b.addDir(trimmed, true); err != nil {
					glog.Warningf("Ignoring child directory %v: %v", trimmed, err)
				}
			}
		}
		return nil
	})
	return nil
}

示例#15
文件: body_input.go 项目: mouse225/qt

func CppBodyInput(f *parser.Function) (o string) {

	if f.Meta == "slot" {
		for _, p := range f.Parameters {
			o += fmt.Sprintf(", Q_ARG(%v, %v)", CppBodyInputSlotValue(f, p), cppInput(p.Name, p.Value, f))
		}
		return
	}

	if f.Meta == "signal" {
		for _, p := range f.Parameters {

			if isEnum(f.Class(), cleanValue(p.Value)) {
				o += fmt.Sprintf("%v, ", cppEnum(f, cleanValue(p.Value), true))
			} else {
				o += fmt.Sprintf("%v, ", p.Value)
			}
		}
		return strings.TrimSuffix(o, ", ")
	}

	for _, p := range f.Parameters {
		o += fmt.Sprintf("%v, ", cppInput(p.Name, p.Value, f))
	}

	return strings.TrimSuffix(o, ", ")
}

示例#16
文件: server.go 项目: jcdny/hugo

func server(cmd *cobra.Command, args []string) {
	InitializeConfig()

	if BaseUrl == "" {
		BaseUrl = "http://localhost"
	}

	if !strings.HasPrefix(BaseUrl, "http://") {
		BaseUrl = "http://" + BaseUrl
	}

	if serverAppend {
		Config.BaseUrl = strings.TrimSuffix(BaseUrl, "/") + ":" + strconv.Itoa(serverPort)
	} else {
		Config.BaseUrl = strings.TrimSuffix(BaseUrl, "/")
	}

	build(serverWatch)

	// Watch runs its own server as part of the routine
	if serverWatch {
		fmt.Println("Watching for changes in", Config.GetAbsPath(Config.ContentDir))
		err := NewWatcher(serverPort)
		if err != nil {
			fmt.Println(err)
		}
	}

	serve(serverPort)
}

示例#17
文件: dns.go 项目: Q-Lee/kubernetes

// getDnsZones returns the DNS zones matching dnsZoneName and dnsZoneID (if specified)
func getDnsZones(dnsZoneName string, dnsZoneID string, dnsZonesInterface dnsprovider.Zones) ([]dnsprovider.Zone, error) {
	// TODO: We need query-by-name and query-by-id functions
	dnsZones, err := dnsZonesInterface.List()
	if err != nil {
		return nil, err
	}

	var matches []dnsprovider.Zone
	findName := strings.TrimSuffix(dnsZoneName, ".")
	for _, dnsZone := range dnsZones {
		if dnsZoneID != "" {
			if dnsZoneID != dnsZone.ID() {
				continue
			}
		}
		if findName != "" {
			if strings.TrimSuffix(dnsZone.Name(), ".") != findName {
				continue
			}
		}
		matches = append(matches, dnsZone)
	}

	return matches, nil
}

示例#18
文件: command.go 项目: bitrise-tools/releaseman

// 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
}

示例#19
文件: offer.go 项目: paulczar/fleet

func (es *EventStream) filterEventJobOffered(resp *etcd.Response) *event.Event {
	if resp.Action != "set" {
		return nil
	}

	dir, base := path.Split(resp.Node.Key)

	if base != "object" {
		return nil
	}

	dir = path.Dir(strings.TrimSuffix(dir, "/"))
	prefix := path.Base(strings.TrimSuffix(dir, "/"))

	if prefix != offerPrefix {
		return nil
	}

	jo := es.registry.getJobOfferFromJSON(resp.Node.Value)
	if jo == nil {
		return nil
	}

	return &event.Event{"EventJobOffered", *jo, nil}
}

示例#20
文件: main.go 项目: godeep/goth

func mkFile(path string, fi os.FileInfo) (err error) {
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, path, nil, parser.ParseComments)
	if err != nil {
		log.Fatalf("Could not parse file: %s", err)
	}

	res := &ThriftCli{
		Package: f.Name.Name,
		//		Def: fmt.Sprintf("%s", suitecase.Camelize(f.Name.Name)),
		Fname: strings.TrimSuffix(fi.Name(), ".go") + "_gen_client.go",
	}

	for _, decl := range f.Decls {
		funcDecl, ok := decl.(*ast.FuncDecl)
		if !ok {
			continue
		}
		if strings.HasSuffix(funcDecl.Name.Name, "ClientFactory") {
			n := strings.TrimPrefix(strings.TrimSuffix(
				funcDecl.Name.Name, "ClientFactory"), "New")
			res.Svc = n
			break
		}
	}
	res.Def = res.Svc == suitecase.Camelize(res.Package)
	renderFile(res)
	return
}

示例#21
文件: verify.go 项目: sreis/go

func matchHostnames(pattern, host string) bool {
	host = strings.TrimSuffix(host, ".")
	pattern = strings.TrimSuffix(pattern, ".")

	if len(pattern) == 0 || len(host) == 0 {
		return false
	}

	patternParts := strings.Split(pattern, ".")
	hostParts := strings.Split(host, ".")

	if len(patternParts) != len(hostParts) {
		return false
	}

	for i, patternPart := range patternParts {
		if i == 0 && patternPart == "*" {
			continue
		}
		if patternPart != hostParts[i] {
			return false
		}
	}

	return true
}

示例#22
文件: parse.go 项目: Clarifai/kubernetes

// AddDirRecursive is just like AddDir, but it also recursively adds
// subdirectories; it returns an error only if the path couldn't be resolved;
// any directories recursed into without go source are ignored.
func (b *Builder) AddDirRecursive(dir string) error {
	// First, find it, so we know what path to use.
	pkg, err := b.context.Import(dir, ".", build.FindOnly)
	if err != nil {
		return fmt.Errorf("unable to *find* %q: %v", dir, err)
	}

	if err := b.addDir(dir, true); err != nil {
		glog.Warningf("Ignoring directory %v: %v", dir, err)
	}

	prefix := strings.TrimSuffix(pkg.Dir, strings.TrimSuffix(dir, "/"))
	filepath.Walk(pkg.Dir, func(path string, info os.FileInfo, err error) error {
		if info != nil && info.IsDir() {
			trimmed := strings.TrimPrefix(path, prefix)
			if trimmed != "" {
				if err := b.addDir(trimmed, true); err != nil {
					glog.Warningf("Ignoring child directory %v: %v", trimmed, err)
				}
			}
		}
		return nil
	})
	return nil
}

示例#23
文件: repo.go 项目: ildarisaev/srclib

// TryMakeURI converts a repository clone URL, such as
// "git://github.com/user/repo.git", to a normalized URI string, such
// as "github.com/user/repo" lexically. TryMakeURI returns an error if
// cloneURL is empty or malformed.
func TryMakeURI(cloneURL string) (string, error) {
	if cloneURL == "" {
		return "", errors.New("MakeURI: empty clone URL")
	}

	// Handle "[email protected]:path" and "host:path" (assumed SSH).
	if strings.Contains(cloneURL, ":") && !strings.Contains(cloneURL, "://") {
		cloneURL = "ssh://" + strings.Replace(cloneURL, ":", "/", -1)
	}

	url, err := url.Parse(cloneURL)
	if err != nil {
		return "", err
	} else if url.Path == "" || url.Path == "/" {
		return "", fmt.Errorf("determining URI from repo clone URL failed: missing path from URL (%q)", cloneURL)
	} else if url.Host == "" && (url.Path[0] == '/' || !strings.Contains(strings.Trim(url.Path, "/"), "/")) {
		// We ensure our Path doesn't look like the output of TryMakeURI
		// so that the output of this function is a fixed point.
		// ie TryMakeURI("github.com/user/repo") == ("github.com/user/repo", nil),
		// not an error.
		return "", fmt.Errorf("determining URI from repo clone URL failed: missing host from URL (%q)", cloneURL)
	}

	uri := strings.TrimSuffix(url.Path, ".git")
	uri = path.Clean(uri)
	uri = strings.TrimSuffix(uri, "/")
	return strings.ToLower(url.Host) + uri, nil
}

示例#24
文件: router.go 项目: FredFool/route

// Determines if the path matches the pattern of the route.
// Fill the params map with variables found in the path.
func (r *route) match(path string) bool {
	splitPattern := strings.Split(strings.TrimSuffix(r.pattern, "/"), "/")
	splitPath := strings.Split(strings.TrimSuffix(path, "/"), "/")

	if len(splitPattern) != len(splitPath) {
		return false
	}

	for idx, val := range splitPattern {
		if val != splitPath[idx] {
			if !strings.HasPrefix(val, ":") {
				return false
			}

			variable := strings.TrimPrefix(val, ":")
			if matched, _ := regexp.MatchString("^[a-zA-Z0-9_-]+$", variable); !matched {
				return false
			}

			r.params[variable] = splitPath[idx]
		}
	}

	return true
}

示例#25
文件: main.go 项目: romana/core

// setRomanaRootURL sanitizes rootURL and rootPort and also
// sets baseURL which is needed to connect to other romana
// services.
func setRomanaRootURL() {
	// Variables used for configuration and flags.
	var baseURL string
	var rootURL string
	var rootPort string

	// Add port details to rootURL else try localhost
	// if nothing is given on command line or config.
	rootURL = config.GetString("RootURL")
	rootPort = config.GetString("RootPort")
	if rootPort == "" {
		re, _ := regexp.Compile(`:\d+/?`)
		port := re.FindString(rootURL)
		port = strings.TrimPrefix(port, ":")
		port = strings.TrimSuffix(port, "/")
		if port != "" {
			rootPort = port
		} else {
			rootPort = "9600"
		}
	}
	config.Set("RootPort", rootPort)
	if rootURL != "" {
		baseURL = strings.TrimSuffix(rootURL, "/")
		baseURL = strings.TrimSuffix(baseURL, ":9600")
		baseURL = strings.TrimSuffix(baseURL, ":"+rootPort)
	} else {
		baseURL = "http://localhost"
	}
	config.Set("BaseURL", baseURL)
	rootURL = baseURL + ":" + rootPort + "/"
	config.Set("RootURL", rootURL)
}

示例#26
文件: service_youtube.go 项目: mpacella88/mumbledj

// parseTime converts from the string youtube returns to a time.Duration
func (yt YouTube) parseTime(duration, regex string) time.Duration {
	var days, hours, minutes, seconds, totalSeconds int64
	if duration != "" {
		timestampExp := regexp.MustCompile(regex)
		timestampMatch := timestampExp.FindStringSubmatch(strings.ToUpper(duration))
		timestampResult := make(map[string]string)
		for i, name := range timestampExp.SubexpNames() {
			if i < len(timestampMatch) {
				timestampResult[name] = timestampMatch[i]
			}
		}

		if timestampResult["days"] != "" {
			days, _ = strconv.ParseInt(strings.TrimSuffix(timestampResult["days"], "D"), 10, 32)
		}
		if timestampResult["hours"] != "" {
			hours, _ = strconv.ParseInt(strings.TrimSuffix(timestampResult["hours"], "H"), 10, 32)
		}
		if timestampResult["minutes"] != "" {
			minutes, _ = strconv.ParseInt(strings.TrimSuffix(timestampResult["minutes"], "M"), 10, 32)
		}
		if timestampResult["seconds"] != "" {
			seconds, _ = strconv.ParseInt(strings.TrimSuffix(timestampResult["seconds"], "S"), 10, 32)
		}

		totalSeconds = int64((days * 86400) + (hours * 3600) + (minutes * 60) + seconds)
	} else {
		totalSeconds = 0
	}
	output, _ := time.ParseDuration(strconv.Itoa(int(totalSeconds)) + "s")
	return output
}

示例#27
文件: persister.go 项目: mattxia/docker-broker

func (persister *Persister) InsertTable(tablename string, colmap map[string]interface{}) error {
	var insertCols string = "("
	var insertParams string = "("
	var insertVals []interface{}
	for colname := range colmap {
		if colmap[colname] == nil {
			log.Println("colname ", colname, " has nil value")
			continue
		}
		insertCols = insertCols + colname + ","
		insertParams = insertParams + "?,"
		value := new(interface{})
		*value = colmap[colname]
		insertVals = append(insertVals, value)
	}
	insertCols = strings.TrimSuffix(insertCols, ",") + ")"
	insertParams = persister.parameterize(strings.TrimSuffix(insertParams, ",") + ")")
	stmt, err := persister.Db.Prepare("insert into " + tablename + insertCols + " values " + insertParams)
	if err != nil {
		return err
	}
	defer stmt.Close()

	_, err = stmt.Exec(insertVals...)
	return err
}

示例#28
文件: schema.go 项目: unknownzerx/go-mysql

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
	}
}

示例#29
文件: models.go 项目: kesyn/kanban

// NewEngine creates new services for data from config settings
func NewEngine() error {
	gh := strings.TrimSuffix(viper.GetString("gitlab.url"), "/")
	d := strings.TrimSuffix(viper.GetString("server.hostname"), "/")

	gitlab.NewEngine(&gitlab.Config{
		BasePath: gh + "/api/v3",
		Domain:   d,
		Oauth2: &oauth2.Config{
			ClientID:     viper.GetString("gitlab.client"),
			ClientSecret: viper.GetString("gitlab.secret"),
			Endpoint: oauth2.Endpoint{
				AuthURL:  gh + "/oauth/authorize",
				TokenURL: gh + "/oauth/token",
			},
			RedirectURL: d + "/assets/html/user/views/oauth.html",
		},
	})

	c = redis.NewClient(&redis.Options{
		Addr:     viper.GetString("redis.addr"),
		Password: viper.GetString("redis.password"),
		DB:       int64(viper.GetInt("redis.db")),
	})

	_, err := c.Ping().Result()

	if err != nil {
		log.Fatalf("Error connection to redis %s", err.Error())
	}

	return nil
}

示例#30
文件: server.go 项目: vinchu/hugo

func server(cmd *cobra.Command, args []string) {
	InitializeConfig()

	if BaseUrl == "" {
		BaseUrl = "http://localhost"
	}

	if !strings.HasPrefix(BaseUrl, "http://") {
		BaseUrl = "http://" + BaseUrl
	}

	if serverAppend {
		viper.Set("BaseUrl", strings.TrimSuffix(BaseUrl, "/")+":"+strconv.Itoa(serverPort))
	} else {
		viper.Set("BaseUrl", strings.TrimSuffix(BaseUrl, "/"))
	}

	build(serverWatch)

	// Watch runs its own server as part of the routine
	if serverWatch {
		jww.FEEDBACK.Println("Watching for changes in", helpers.AbsPathify(viper.GetString("ContentDir")))
		err := NewWatcher(serverPort)
		if err != nil {
			fmt.Println(err)
		}
	}

	serve(serverPort)
}

展开阅读全文