Example #1
0
func find(r *regexp.Regexp, code string, tokenType string) Token {
	if m := r.FindString(code); m != "" {
		return Token{tokenType, m, len(m), true}
	}

	return Token{"", "", 0, false}
}
func NewDirector(ctx context.Context, target string, user string, password string) (*Director, error) {

	var re *regexp.Regexp

	re = regexp.MustCompile("^http(s)?://")
	if re.FindString(target) == "" {
		target = "https://" + target
	}
	re = regexp.MustCompile(":\\d+$")
	if re.FindString(target) == "" {
		target = target + ":25555"
	}

	d := gogobosh.NewDirector(target, user, password)
	c := &Director{
		director: api.NewBoshDirectorRepository(&d, net.NewDirectorGateway()),
	}

	err := c.Connect()
	if err != nil {
		if !strings.Contains(err.Error(), "connection refused") {
			return nil, err
		}
		log.Printf("[DEBUG] Connection to director not successful. Could be because " +
			"the Director does no exist yet. So connection has been deferred.")
	} else {
		log.Printf("[DEBUG] Connection to director successful.")
	}

	return c, nil
}
Example #3
0
// authority data extraction worker
func AuthorityDataExtractor(in chan *Page,
	out chan *string,
	ack chan bool,
	filter *regexp.Regexp,
	authorityDataPattern *regexp.Regexp) {
	var pp *Page
	for {
		// get the page pointer
		pp = <-in
		if pp == nil {
			break
		}
		// get the page
		p := *pp

		// do some stuff with the page
		p.CanonicalTitle = CanonicalizeTitle(p.Title)
		m := filter.MatchString(p.CanonicalTitle)
		if !m && p.Redir.Title == "" {

			// specific to category extraction
			result := authorityDataPattern.FindString(p.Text)
			if result != "" {
				// https://cdn.mediacru.sh/JsdjtGoLZBcR.png
				result = strings.Replace(result, "\t", "", -1)
				// fmt.Printf("%s\t%s\n", p.Title, result)
				line := fmt.Sprintf("%s\t%s", p.Title, result)
				out <- &line
			}
		}
	}
	ack <- true
}
// Should set an 'Served-By' header giving information on the edge node and location served from.
func TestRespHeaderServedBy(t *testing.T) {
	ResetBackends(backendsByPriority)

	var expectedServedByRegexp *regexp.Regexp
	var headerName string

	switch {
	case vendorCloudflare:
		headerName = "CF-RAY"
		expectedServedByRegexp = regexp.MustCompile("^[a-z0-9]{16}-[A-Z]{3}$")
	case vendorFastly:
		headerName = "X-Served-By"
		expectedServedByRegexp = regexp.MustCompile("^cache-[a-z0-9]+-[A-Z]{3}$")
	default:
		t.Fatal(notImplementedForVendor)
	}

	req := NewUniqueEdgeGET(t)
	resp := RoundTripCheckError(t, req)
	defer resp.Body.Close()

	actualHeader := resp.Header.Get(headerName)

	if actualHeader == "" {
		t.Error(headerName + " header has not been set by Edge")
	}

	if expectedServedByRegexp.FindString(actualHeader) != actualHeader {
		t.Errorf("%s is not as expected: got %q", headerName, actualHeader)
	}

}
Example #5
0
func reFind(re *regexp.Regexp) lua.Function {
	return func(l *lua.State) int {
		s := lua.CheckString(l, 1)
		all := re.FindString(s)
		return util.DeepPush(l, all)
	}
}
Example #6
0
func doTest(t *testing.T, name string, re *regexp.Regexp, cases []testCase) {
	for _, c := range cases {
		got := re.FindString(c.in)
		want := wantStr(c.in, c.want)
		if got != want {
			t.Errorf(`%s.FindString("%s") got "%s", want "%s"`, name, c.in, got, want)
		}
	}
}
Example #7
0
func grepFile(path string, pattern *regexp.Regexp) *SearchResultPerFile {
	result := &SearchResultPerFile{
		Appearances: make([][]string, 0),
	}

	f, err := os.Open(path)
	defer f.Close()
	if err != nil {
		log.Errorf("Open file %s error: %s", path, err)
		return result
	}

	lines := make(map[int]string)
	lineno := 0
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		lines[lineno] = scanner.Text()
		lineno++
	}

	if err := scanner.Err(); err != nil {
		log.Errorf("reading file %s error: %s", path, err)
	}

	linesToShow := make([]int, 0)
	for i := 0; i < lineno; i++ {
		if pattern.FindString(lines[i]) != "" {
			linesToShow = addToSlice(i, linesToShow)
			for j := 1; j <= CONTEXTS && (i-j) >= 0; j++ {
				linesToShow = addToSlice(i-j, linesToShow)
			}
			for j := 1; j <= CONTEXTS && (i+j) < lineno; j++ {
				linesToShow = addToSlice(i+j, linesToShow)
			}
		}
	}

	sort.Ints(linesToShow)

	last := -1
	for i, number := range linesToShow {
		if i == 0 || (last+1) != number {
			result.Appearances = append(result.Appearances, []string{lines[number]})
		} else {
			numAppearences := len(result.Appearances)
			result.Appearances[numAppearences-1] = append(result.Appearances[numAppearences-1], lines[number])
		}

		last = number
	}

	if len(result.Appearances) > 0 {
		return result
	} else {
		return nil
	}
}
Example #8
0
// ExtractPageAuthorityControl extract raw authority control data from a page.
func ExtractAuthorityControl(page *Page, filter, pattern *regexp.Regexp) []string {
	m := filter.MatchString(CanonicalizeTitle(page.Title))
	var result []string
	if !m && page.Redir.Title == "" {
		match := pattern.FindString(page.Text)
		if match != "" {
			// https://cdn.mediacru.sh/JsdjtGoLZBcR.png
			result = append(result, page.Title, strings.Replace(match, "\t", "", -1))
		}
	}
	return result
}
Example #9
0
// get a list of all services, limit to those matching the search criteria
func getList(serviceString string, tag string) []*api.ServiceEntry {
	client, err := getClient("")
	if err != nil {
		log.Fatalf("Unable to get a consul client connection: %s\n", err)
	}
	catalog := client.Catalog()

	// services is a map[string] to slice of tags
	services, _, err := catalog.Services(nil)
	if err != nil {
		log.Fatalf("Error getting serives from catalog: %s\n", err)
	}

	// get a handle to the health endpoint and pre-calculate the regexp
	health := client.Health()
	var re *regexp.Regexp
	if serviceString != "" {
		re, err = regexp.Compile(serviceString)
		if err != nil {
			log.Fatalf("Error compiling <%s> as regexp: %s\n", serviceString, err)
		}
	}

	// prepare a slice to hold the result list
	seOut := make([]*api.ServiceEntry, 0)

	for service, _ := range services {
		match := true
		if re != nil {
			str := re.FindString(service)
			match = (str != "")
		}
		if match {
			seList, _, err := health.Service(service, tag, false, nil)
			if err != nil {
				log.Fatalf("Unable to query health status of: %s\n", err)
			}
			for _, se := range seList {
				seOut = append(seOut, se)
			}
		}
	}

	return seOut
}
Example #10
0
// ifConfig returns the IP Address for this node according to ifConfig, for the
// specified device.
func (f *NetworkFingerprint) ifConfig(device string) string {
	ifConfigPath, _ := exec.LookPath("ifconfig")
	if ifConfigPath == "" {
		f.logger.Println("[WARN] fingerprint.network: ifconfig not found")
		return ""
	}

	outBytes, err := exec.Command(ifConfigPath, device).Output()
	if err != nil {
		f.logger.Printf("[WARN] fingerprint.network: Error calling ifconfig (%s %s): %v", ifConfigPath, device, err)
		return ""
	}

	// Parse out the IP address returned from ifconfig for this device
	// Tested on Ubuntu, the matching part of ifconfig output for eth0 is like
	// so:
	//   inet addr:10.0.2.15  Bcast:10.0.2.255  Mask:255.255.255.0
	// For OS X and en0, we have:
	//  inet 192.168.0.7 netmask 0xffffff00 broadcast 192.168.0.255
	output := strings.TrimSpace(string(outBytes))

	// re is a regular expression, which can vary based on the OS
	var re *regexp.Regexp

	if "darwin" == runtime.GOOS {
		re = regexp.MustCompile("inet [0-9].+")
	} else {
		re = regexp.MustCompile("inet addr:[0-9].+")
	}
	args := strings.Split(re.FindString(output), " ")

	var ip string
	if len(args) > 1 {
		ip = strings.TrimPrefix(args[1], "addr:")
	}

	// validate what we've sliced out is a valid IP
	if net.ParseIP(ip) == nil {
		f.logger.Printf("[WARN] fingerprint.network: Unable to parse IP in output of '%s %s'", ifConfigPath, device)
		return ""
	}

	return ip
}
Example #11
0
func evaluateSQLError(err error) (error, int) {

	var r *regexp.Regexp

	matched, _ := regexp.MatchString("violates foreign key constraint", err.Error())

	if matched == true {
		r = regexp.MustCompile("user_id|category_id|question_id")
		return errors.New("The provided " + r.FindString(err.Error()) + " does not exist"), http.StatusBadRequest
	}

	matched, _ = regexp.MatchString("duplicate key value violates unique constraint", err.Error())

	if matched == true {
		r = regexp.MustCompile("username|title")
		return errors.New("The provided " + r.FindString(err.Error()) + " is not unique"), http.StatusConflict
	}

	return InternalErr, http.StatusInternalServerError
}
Example #12
0
File: parser.go Project: mosson/lex
// RegExp 正規表現を使用するパーサーを返す
func RegExp(pattern *regexp.Regexp) Parser {
	return func(target string, position int) *Result {
		if position > len(target) {
			return incompatible(position)
		}

		sample := target[position:]
		if pattern.MatchString(sample) {
			index := pattern.FindStringIndex(sample)
			return &Result{
				Success:    true,
				Target:     pattern.FindString(sample),
				Position:   position + index[1],
				Attributes: map[string]string{},
			}
		}

		return incompatible(position)
	}
}
Example #13
0
func addresses_by_frequency(msgs *notmuch.Messages, name string, pass uint, addr_to_realname *map[string]*frequencies) *frequencies {

	freqs := make(frequencies)

	pattern := `\s*(("(\.|[^"])*"|[^,])*<?(?mail\b\w+([-+.]\w+)*\@\w+[-\.\w]*\.([-\.\w]+)*\w\b)>?)`
	// pattern := "\\s*((\\\"(\\\\.|[^\\\\\"])*\\\"|[^,])*" +
	// 	"<?(?P<mail>\\b\\w+([-+.]\\w+)*\\@\\w+[-\\.\\w]*\\.([-\\.\\w]+)*\\w\\b)>?)"
	pattern = `.*` + strings.ToLower(name) + `.*`
	var re *regexp.Regexp = nil
	var err os.Error = nil
	if re, err = regexp.Compile(pattern); err != nil {
		log.Printf("error: %v\n", err)
		return &freqs
	}

	headers := []string{"from"}
	if pass == 1 {
		headers = append(headers, "to", "cc", "bcc")
	}

	for ; msgs.Valid(); msgs.MoveToNext() {
		msg := msgs.Get()
		//println("==> msg [", msg.GetMessageId(), "]")
		for _, header := range headers {
			froms := strings.ToLower(msg.GetHeader(header))
			//println("  froms: ["+froms+"]")
			for _, from := range strings.Split(froms, ",", -1) {
				from = strings.Trim(from, " ")
				match := re.FindString(from)
				//println("  -> match: ["+match+"]")
				occ, ok := freqs[match]
				if !ok {
					freqs[match] = 0
					occ = 0
				}
				freqs[match] = occ + 1
			}
		}
	}
	return &freqs
}
Example #14
0
func loopTokens(
	spMap count.TokensMap,
	compiledTokenRE *regexp.Regexp,
	allTokens AllTokens, tokenType int,
) []string {
	tokens := []string{}
	filter, total := chopUpChannelFilterFlag()
	for token := range spMap {
		token = compiledTokenRE.FindString(token)
		if total == 0 {
			tokens = append(tokens, token)
			// add to deduped list
			allTokens[token] = tokenType
		} else {
			if filter[token] == true {
				tokens = append(tokens, token)
				// add to deduped list
				allTokens[token] = tokenType
			}
		}
	}
	return tokens
}
Example #15
0
func RegexpFind(env *Glisp, name string,
	args []Sexp) (Sexp, error) {
	if len(args) != 2 {
		return SexpNull, WrongNargs
	}
	var haystack string
	switch t := args[1].(type) {
	case SexpStr:
		haystack = string(t)
	default:
		return SexpNull,
			errors.New(fmt.Sprintf("2nd argument of %v should be a string", name))
	}

	var needle regexp.Regexp
	switch t := args[0].(type) {
	case SexpRegexp:
		needle = regexp.Regexp(t)
	default:
		return SexpNull,
			errors.New(fmt.Sprintf("1st argument of %v should be a compiled regular expression", name))
	}

	switch name {
	case "regexp-find":
		str := needle.FindString(haystack)
		return SexpStr(str), nil
	case "regexp-find-index":
		return regexpFindIndex(needle, haystack)
	case "regexp-match":
		matches := needle.MatchString(haystack)
		return SexpBool(matches), nil
	}

	return SexpNull, errors.New("unknown function")
}
Example #16
0
// findRegexp returns the first string from current scanning position that matches given regular expression
func (l *Lexer) findRegexp(r *regexp.Regexp) string {
	return r.FindString(l.input[l.pos:])
}
Example #17
0
func (p NumericParser) parse(s string) (*Numeric, error) {
	var (
		n        *Numeric
		err      error
		sign     string
		reStr    string
		re       *regexp.Regexp
		parseErr = errors.New(ParseNumericError)
	)

	// Record whether the input string has a currency symbol.
	// If so, it can only be a monetary value.
	hasCurrency := p.currencyRegex.MatchString(s)
	if hasCurrency {
		s = p.removeCurrencySymbol(s)
	}

	// Now determine whether the string's initial character is a + or -.
	// If so, strip it away and record the sign.
	sign = ""
	re = regexp.MustCompile("^[\\+-]")
	if re.MatchString(s) {
		if re.FindString(s) == "-" {
			sign = "-"
		}
		s = s[1:]
	}

	// Since currency and sign symbols have been stripped, we now check that the
	// expression begins with a decimal separator (possibly) and digit.
	// Valid strings thus look like either: .x* or x*.
	reStr = "^" + p.decimalReStr + "?" + "[0-9]"
	re = regexp.MustCompile(reStr)
	if !re.MatchString(s) {
		return nil, parseErr
	}

	// Prepend a 0 if the string begins with a decimal separator.
	reStr = "^" + p.decimalReStr
	re = regexp.MustCompile(reStr)
	if re.MatchString(s) {
		s = "0" + s
	}

	// If the input ends with the decimal separator, remove it.
	re = regexp.MustCompile(p.decimalReStr + "$")
	if re.MatchString(s) {
		s = re.ReplaceAllString(s, "")
	}

	// Create the main validating regex.
	reStr = "^\\d+" + "(" + p.digitReStr + "\\d{3})*" + p.decimalReStr + "?\\d*$"
	re = regexp.MustCompile(reStr)
	if !re.MatchString(s) {
		return nil, parseErr
	}

	// We can now assume that the string is valid except for
	// intermediate delimiters.
	// Before attempting to parse the string further, we (possibly) perform
	// some basic sanitization.
	var parsed string
	tmp, err := p.sanitize(s)
	if err == nil {
		parsed = tmp
	} else {
		// Probably the parser cannot distinguish between decimal and digit
		// separators.  So we handle this case separately.
		re = regexp.MustCompile(p.digitReStr + "|" + p.decimalReStr)
		locs := re.FindAllStringSubmatchIndex(s, -1)
		switch len(locs) {
		case 0: // The number is an integer.  No additional parsing needed.
			parsed = s
			err = nil
		case 1: // Need to deal with 1,234 vs 123,456 vs 12.345, etc.
			parsed, err = p.parseOneUnknownSeparator(s, locs[0][0])
		default: // Try to find the last separator and determine its type.
			parsed, err = p.parseManyUnknownSeparators(s, locs)
		}

	}

	parsed = sign + parsed
	f, ferr := strconv.ParseFloat(parsed, 64)
	if err != nil || ferr != nil {
		return nil, err
	}

	// We now know that the parsed string correctly parses as a float.
	n = &Numeric{
		isFloat: true,
		f:       f,
	}
	if hasCurrency {
		n.isMoney = true
	}
	_, err = strconv.Atoi(parsed)
	if err == nil {
		n.isInt = true
	}

	return n, nil
}
Example #18
0
func downloadcmd(opt Options) error {
	user := nvls(opt.Download.User, EnvUser)
	repo := nvls(opt.Download.Repo, EnvRepo)
	token := nvls(opt.Download.Token, EnvToken)
	tag := opt.Download.Tag
	name := opt.Download.Name
	latest := opt.Download.Latest
	regexed := opt.Download.Regexed

	vprintln("downloading...")

	if err := ValidateTarget(user, repo, tag, latest); err != nil {
		return err
	}

	// Find the release corresponding to the entered tag, if any.
	var rel *Release
	var err error
	if latest {
		rel, err = LatestRelease(user, repo, token)
	} else {
		rel, err = ReleaseOfTag(user, repo, tag, token)
	}
	if err != nil {
		return err
	}

	assetId := 0
	var rx *regexp.Regexp
	var theName string

	if regexed {

		rx = regexp.MustCompile(name)
	}

	for _, asset := range rel.Assets {
		if regexed {
			theName = rx.FindString(asset.Name)
		} else {
			theName = name
		}
		if asset.Name == theName {
			assetId = asset.Id
		}
	}

	if assetId == 0 {
		return fmt.Errorf("coud not find asset named %s", theName)
	}

	var resp *http.Response
	var url string
	if token == "" {
		url = GH_URL + fmt.Sprintf("/%s/%s/releases/download/%s/%s", user, repo, tag, theName)
		resp, err = http.Get(url)
	} else {
		url = ApiURL() + fmt.Sprintf(ASSET_DOWNLOAD_URI, user, repo, assetId)
		resp, err = DoAuthRequest("GET", url, "", token, map[string]string{
			"Accept": "application/octet-stream",
		}, nil)
	}
	if resp != nil {
		defer resp.Body.Close()
	}
	if err != nil {
		return fmt.Errorf("could not fetch releases, %v", err)
	}

	vprintln("GET", url, "->", resp)

	contentLength, err := strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64)
	if err != nil {
		return err
	}

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("github did not respond with 200 OK but with %v", resp.Status)
	}

	out, err := os.Create(theName)
	if err != nil {
		return fmt.Errorf("could not create file %s", theName)
	}
	defer out.Close()

	n, err := io.Copy(out, resp.Body)
	if n != contentLength {
		return fmt.Errorf("downloaded data did not match content length %d != %d", contentLength, n)
	}
	return err
}
Example #19
0
File: macro.go Project: sevlyar/bld
// Делает подстановки определений на места макровызовов.
// input должен содержать одинаковые макровызовы!
// FIXME: сделать input string
func (def defines) substitute(input []string, re *regexp.Regexp) []string {
	cached := input[0]
	level := 0

	for {
		// выходные значения на каждой итерации
		result := make([]string, 0, 16)

		f := false
		for _, str := range input {
			// поиск макровызова
			macroCall := re.FindString(str)

			if len(macroCall) != 0 {
				f = true
			} else {
				continue
			}

			// извлечение имени
			name := macroCall[2 : len(macroCall)-1]

			// проверка префикса
			basePath := false
			if name[0] == '/' {
				basePath = true
				name = name[1:]
			}

			// поиск значения
			values, exists := def[name]
			if !exists {
				throw("Macro definition with name %s not found", name)
			}

			// применение модификатора
			if basePath {
				values = basePathModif(values)
			}

			// подстановка каждым значением макроопределения
			for _, val := range values {
				subs := strings.Replace(str, macroCall, val, 1)
				result = append(result, subs)
			}
		}

		if !f {
			// expand enveronment
			for i, _ := range input {
				input[i] = expandEnvVars(input[i])
			}

			if len(input) == 0 || cached != input[0] {
				log.Printf("macro L%d: [%s] -> %v", level, cached, input)
			}

			return input
		}

		input = result
		level++

		if level > macroLevel {
			throw("cyclic reference in macro-call %s or depends", cached)
		}
	}

	return input
}
Example #20
0
func getOriginalName(text string, regexPattern *regexp.Regexp) string {
	reversed := Reverse(text)
	result := regexPattern.FindString(reversed)
	return Reverse(result)[1 : len(result)-4]
}