func compareToFixtures(region holidays.Region, file string) error {
fd, err := os.Open(file)
if err != nil {
return fmt.Errorf("Couldn't open fixtures '%s': %s", file, err)
}
csv := csv.NewReader(fd)
for {
day, err := csv.Read()
if err == io.EOF {
break
}
dt, err := time.Parse("2006-01-02", day[0])
if err != nil {
return fmt.Errorf("Couldn't parse fixtures: %s", err)
}
t := dt.Add(5 * time.Hour)
holiday, err := holidays.Holiday(t, region)
if err != nil {
return fmt.Errorf("%s is supposed to be a holiday but library disagrees", t)
}
if holiday.Name != day[1] {
return fmt.Errorf("Holiday/library: %s, fixture: %s", holiday.Name, day[1])
}
}
return nil
}
// Prepares the route to be used in matching.
func NewRoute(method, path, action, fixedArgs, routesPath string, line int) (r *Route) {
// Handle fixed arguments
argsReader := strings.NewReader(fixedArgs)
csv := csv.NewReader(argsReader)
fargs, err := csv.Read()
if err != nil && err != io.EOF {
ERROR.Printf("Invalid fixed parameters (%v): for string '%v'", err.Error(), fixedArgs)
}
r = &Route{
Method: strings.ToUpper(method),
Path: path,
Action: action,
FixedParams: fargs,
TreePath: treePath(strings.ToUpper(method), path),
routesPath: routesPath,
line: line,
}
// URL pattern
if !strings.HasPrefix(r.Path, "/") {
ERROR.Print("Absolute URL required.")
return
}
actionSplit := strings.Split(action, ".")
if len(actionSplit) == 2 {
r.ControllerName = actionSplit[0]
r.MethodName = actionSplit[1]
}
return
}
func produce(channel chan Prescription, filename string) {
//open file
fi, err := os.Open(filename)
if err != nil {
panic(err)
}
csv := csv.NewReader(fi)
skip := true
fmt.Println("producing")
for {
record, err := csv.Read()
if err != nil {
break
} else if err == io.EOF {
break
}
if skip != false {
skip = false
continue
}
pres := NewPrescription(record)
channel <- pres
}
close(channel)
}
func csv2db(filepath string, max_rows int) DB {
// Read CSV file
csvFile, err := os.Open(filepath)
if err != nil {
panic(err)
}
defer csvFile.Close()
// For each line convert to struct
csv := csv.NewReader(csvFile)
columns, err := csv.Read()
if err != nil {
panic(err)
}
rows := []Row{}
for {
line, err := csv.Read()
if err == io.EOF || (max_rows == len(rows) && max_rows != -1) {
break
}
rows = append(rows, line)
}
return DB{columns, rows}
}
func NewBinder(reader io.Reader, opts *Options) (*Binder, error) {
csv := csv.NewReader(reader)
csv.FieldsPerRecord = -1
if opts == nil {
opts = &Options{}
} else {
if opts.Separator == 0 {
opts.Separator = ','
}
csv.Comma = opts.Separator
}
if opts.TimeZone == nil {
opts.TimeZone = time.UTC
}
var meta map[int]string
if len(opts.Header) == 0 {
header, err := csv.Read()
if err != nil {
return nil, err
}
meta = make(map[int]string)
for i, col := range header {
if opts.StripBOM && i == 0 {
// Remove BOM
col = strings.Replace(col, "\ufeff", "", -1)
}
meta[i] = col
}
if len(meta) == 0 {
return nil, ErrNoHeader
}
} else {
meta = opts.Header
if len(meta) == 0 {
return nil, ErrNoCustomHeader
}
}
return &Binder{csv: csv, meta: meta, opts: opts}, nil
}
func readNanp(country string, data []byte) {
r := bytes.NewReader(data)
csv := csv.NewReader(r)
csv.FieldsPerRecord = -1
for {
row, err := csv.Read()
if err == io.EOF {
break
}
for i := 1; i < len(row); i++ {
area := areaCode{
name: row[0],
code: row[i],
countryName: country,
}
nanp[row[i]] = area
}
}
}
// processFile iterates over a csv file and adds the data
// to the main datastructure
func processFile(m Samples, rf io.Reader, a action) {
csv := csv.NewReader(rf)
header := true
var s_header []string
for {
s_line, err := csv.Read()
if err == io.EOF {
break
}
if err != nil {
log.Fatal("Error reading from csv file in ulrness.processFile() ", " err: ", err)
}
if header {
s_header = s_line
header = false
} else {
err = a(m, s_line, s_header)
if err != nil {
log.Fatal("Error processing line in urlness.processFile()", "error: ", err)
}
}
}
}
// Prepares the route to be used in matching.
func NewRoute(method, path, action, fixedArgs string) (r *Route) {
// Handle fixed arguments
argsReader := strings.NewReader(fixedArgs)
csv := csv.NewReader(argsReader)
fargs, err := csv.Read()
if err != nil && err != io.EOF {
glog.Errorf("Invalid fixed parameters (%v): for string '%v'", err.Error(), fixedArgs)
}
r = &Route{
Method: strings.ToUpper(method),
Path: path,
Action: action,
FixedParams: fargs,
}
// URL pattern
// TODO: Support non-absolute paths
if !strings.HasPrefix(r.Path, "/") {
glog.Error("Absolute URL required.")
return
}
// Handle embedded arguments
// Convert path arguments with unspecified regexes to standard form.
// e.g. "/customer/{id}" => "/customer/{<[^/]+>id}
normPath := nakedPathParamRegex.ReplaceAllStringFunc(r.Path, func(m string) string {
var argMatches []string = nakedPathParamRegex.FindStringSubmatch(m)
return "{<[^/]+>" + argMatches[1] + "}"
})
// Go through the arguments
r.args = make([]*arg, 0, 3)
for i, m := range argsPattern.FindAllStringSubmatch(normPath, -1) {
r.args = append(r.args, &arg{
name: string(m[2]),
index: i,
constraint: regexp.MustCompile(string(m[1])),
})
}
// Now assemble the entire path regex, including the embedded parameters.
// e.g. /app/{<[^/]+>id} => /app/(?P<id>[^/]+)
pathPatternStr := argsPattern.ReplaceAllStringFunc(normPath, func(m string) string {
var argMatches []string = argsPattern.FindStringSubmatch(m)
return "(?P<" + argMatches[2] + ">" + argMatches[1] + ")"
})
r.pathPattern = regexp.MustCompile(pathPatternStr + "$")
// Handle action
var actionPatternStr string = strings.Replace(r.Action, ".", `\.`, -1)
for _, arg := range r.args {
var argName string = "{" + arg.name + "}"
if argIndex := strings.Index(actionPatternStr, argName); argIndex != -1 {
actionPatternStr = strings.Replace(actionPatternStr, argName,
"(?P<"+arg.name+">"+arg.constraint.String()+")", -1)
}
}
r.actionPattern = regexp.MustCompile(actionPatternStr)
return
}
// parse runs Sadf on the previously saved tmpFile:
// Sadf -p -- -p <option> tmpFile
// and parses the output to add it to the telegraf.Accumulator acc.
func (s *Sysstat) parse(acc telegraf.Accumulator, option string, ts time.Time) error {
cmd := execCommand(s.Sadf, s.sadfOptions(option)...)
stdout, err := cmd.StdoutPipe()
if err != nil {
return err
}
if err := cmd.Start(); err != nil {
return fmt.Errorf("running command '%s' failed: %s", strings.Join(cmd.Args, " "), err)
}
r := bufio.NewReader(stdout)
csv := csv.NewReader(r)
csv.Comma = '\t'
csv.FieldsPerRecord = 6
var measurement string
// groupData to accumulate data when Group=true
type groupData struct {
tags map[string]string
fields map[string]interface{}
}
m := make(map[string]groupData)
for {
record, err := csv.Read()
if err == io.EOF {
break
}
if err != nil {
return err
}
device := record[3]
value, err := strconv.ParseFloat(record[5], 64)
if err != nil {
return err
}
tags := map[string]string{}
if device != "-" {
tags["device"] = device
if addTags, ok := s.DeviceTags[device]; ok {
for _, tag := range addTags {
for k, v := range tag {
tags[k] = v
}
}
}
}
if s.Group {
measurement = s.Options[option]
if _, ok := m[device]; !ok {
m[device] = groupData{
fields: make(map[string]interface{}),
tags: make(map[string]string),
}
}
g, _ := m[device]
if len(g.tags) == 0 {
for k, v := range tags {
g.tags[k] = v
}
}
g.fields[escape(record[4])] = value
} else {
measurement = s.Options[option] + "_" + escape(record[4])
fields := map[string]interface{}{
"value": value,
}
acc.AddFields(measurement, fields, tags, ts)
}
}
if s.Group {
for _, v := range m {
acc.AddFields(measurement, v.fields, v.tags, ts)
}
}
if err := internal.WaitTimeout(cmd, time.Second*5); err != nil {
return fmt.Errorf("command %s failed with %s",
strings.Join(cmd.Args, " "), err)
}
return nil
}
