Exemplo n.º 1
1
// ExecuteTemplate executes a template on the source TeX files.
func (t *CompileTask) ExecuteTemplate(templ *template.Template, data interface{}, inputFilename string, outputFilename string) {
	sc := t.context()

	useTempFile := outputFilename == ""
	if useTempFile {
		outputFilename = sc.MustGetTempFile().Name()
	}
	inputFilename = sc.AbsPath(t.defaultCompileFilename(inputFilename))

	f, err := os.Create(sc.AbsPath(outputFilename))
	if err != nil {
		panic(err)
	}
	w := io.Writer(f)
	err = templ.ExecuteTemplate(w, filepath.Base(inputFilename), data)
	if err != nil {
		panic(err)
	}
	f.Close()

	if useTempFile {
		// copy back, remove temp
		err = os.Remove(inputFilename)
		if err != nil {
			panic(err)
		}
		err = sc.CopyFile(outputFilename, inputFilename)
		if err != nil {
			panic(err)
		}
	}
}
Exemplo n.º 2
0
// Accept starts a new SMTP session using io.ReadWriteCloser
func Accept(remoteAddress string, conn io.ReadWriteCloser, storage storage.Storage, messageChan chan *data.Message, hostname string, monkey monkey.ChaosMonkey) {
	defer conn.Close()

	proto := smtp.NewProtocol()
	proto.Hostname = hostname
	var link *linkio.Link
	reader := io.Reader(conn)
	writer := io.Writer(conn)
	if monkey != nil {
		linkSpeed := monkey.LinkSpeed()
		if linkSpeed != nil {
			link = linkio.NewLink(*linkSpeed * linkio.BytePerSecond)
			reader = link.NewLinkReader(io.Reader(conn))
			writer = link.NewLinkWriter(io.Writer(conn))
		}
	}

	session := &Session{conn, proto, storage, messageChan, remoteAddress, false, "", link, reader, writer, monkey}
	proto.LogHandler = session.logf
	proto.MessageReceivedHandler = session.acceptMessage
	proto.ValidateSenderHandler = session.validateSender
	proto.ValidateRecipientHandler = session.validateRecipient
	proto.ValidateAuthenticationHandler = session.validateAuthentication
	proto.GetAuthenticationMechanismsHandler = func() []string { return []string{"PLAIN"} }

	session.logf("Starting session")
	session.Write(proto.Start())
	for session.Read() == true {
		if monkey != nil && monkey.Disconnect != nil && monkey.Disconnect() {
			session.conn.Close()
			break
		}
	}
	session.logf("Session ended")
}
Exemplo n.º 3
0
func TestWriteReadReplication(t *testing.T) {
	SetupCluster()
	log.Info("Testing TestWriteReadReplication...")

	_, other := GetProcessForPath("/tests/replication/write/read")
	resolv := tc.nodes[0].Cluster.Rings.GetGlobalRing().Resolve("/tests/replication/write/read")

	buf := buffer.NewFromString("write1")
	err := other.Fss.Write(fs.NewPath("/tests/replication/write/read"), buf.Size, "application/mytest", buf, nil)
	if err != nil {
		t.Errorf("1) Got an error while write: %s", err)
	}

	// test force local on exists
	context := tc.nodes[0].Fss.NewContext()
	context.ForceLocal = true
	bufwriter := bytes.NewBuffer(make([]byte, 0))
	buffer := io.Writer(bufwriter)
	n, err := other.Fss.Read(fs.NewPath("/tests/replication/write/read"), 0, -1, 0, buffer, context)
	if err != fs.ErrorFileNotFound {
		t.Errorf("2) File shouldn't exists on another node: %s", err)
	}

	// force local replication on each secondary
	tc.nodes[resolv.GetOnline(1).Id].Fss.Flush()
	tc.nodes[resolv.GetOnline(2).Id].Fss.Flush()

	// check on first secondary
	secondaryid := resolv.GetOnline(1).Id
	context = tc.nodes[secondaryid].Fss.NewContext()
	context.ForceLocal = true
	bufwriter = bytes.NewBuffer(make([]byte, 0))
	buffer = io.Writer(bufwriter)
	n, err = tc.nodes[secondaryid].Fss.Read(fs.NewPath("/tests/replication/write/read"), 0, -1, 0, buffer, context)
	if err != nil {
		t.Errorf("3) Got an error from read: %s", err)
	}
	if n != buf.Size || bytes.Compare(bufwriter.Bytes(), buf.Bytes()) != 0 {
		t.Errorf("4) Didn't read what was written: %s!=%s", buf.Bytes(), bufwriter)
	}

	// check on second secondary
	secondaryid = resolv.GetOnline(2).Id
	context = tc.nodes[secondaryid].Fss.NewContext()
	context.ForceLocal = true
	bufwriter = bytes.NewBuffer(make([]byte, 0))
	buffer = io.Writer(bufwriter)
	n, err = tc.nodes[secondaryid].Fss.Read(fs.NewPath("/tests/replication/write/read"), 0, -1, 0, buffer, context)
	if err != nil {
		t.Errorf("3) Got an error from read: %s", err)
	}
	if n != buf.Size || bytes.Compare(bufwriter.Bytes(), buf.Bytes()) != 0 {
		t.Errorf("4) Didn't read what was written: %s!=%s", buf.Bytes(), bufwriter)
	}
}
Exemplo n.º 4
0
func SimpleWOFLogger(prefix string) *WOFLogger {

	logger := NewWOFLogger(prefix)

	stdout := io.Writer(os.Stdout)
	stderr := io.Writer(os.Stderr)

	logger.AddLogger(stdout, "status")
	logger.AddLogger(stderr, "error")

	return logger
}
Exemplo n.º 5
0
// EnvmanJSONPrint ...
func EnvmanJSONPrint(envstorePth string) (string, error) {
	logLevel := log.GetLevel().String()
	args := []string{"--loglevel", logLevel, "--path", envstorePth, "print", "--format", "json", "--expand"}

	var outBuffer bytes.Buffer
	var errBuffer bytes.Buffer

	if err := cmdex.RunCommandWithWriters(io.Writer(&outBuffer), io.Writer(&errBuffer), "envman", args...); err != nil {
		return outBuffer.String(), fmt.Errorf("Error: %s, details: %s", err, errBuffer.String())
	}

	return outBuffer.String(), nil
}
Exemplo n.º 6
0
// StepmanJSONLocalStepInfo ...
func StepmanJSONLocalStepInfo(pth string) (string, error) {
	logLevel := log.GetLevel().String()
	args := []string{"--debug", "--loglevel", logLevel, "step-info", "--step-yml", pth, "--format", "json"}

	var outBuffer bytes.Buffer
	var errBuffer bytes.Buffer

	if err := cmdex.RunCommandWithWriters(io.Writer(&outBuffer), io.Writer(&errBuffer), "stepman", args...); err != nil {
		return outBuffer.String(), fmt.Errorf("Error: %s, details: %s", err, errBuffer.String())
	}

	return outBuffer.String(), nil
}
Exemplo n.º 7
0
// StepmanJSONStepLibStepInfo ...
func StepmanJSONStepLibStepInfo(collection, stepID, stepVersion string) (string, error) {
	logLevel := log.GetLevel().String()
	args := []string{"--debug", "--loglevel", logLevel, "step-info", "--collection", collection,
		"--id", stepID, "--version", stepVersion, "--format", "json"}

	var outBuffer bytes.Buffer
	var errBuffer bytes.Buffer

	if err := cmdex.RunCommandWithWriters(io.Writer(&outBuffer), io.Writer(&errBuffer), "stepman", args...); err != nil {
		return outBuffer.String(), fmt.Errorf("Error: %s, details: %s", err, errBuffer.String())
	}

	return outBuffer.String(), nil
}
Exemplo n.º 8
0
func (e *Encrypter) InitWriter(fileWriter io.Writer) (io.Writer, error) {
	if e.streamWriter != nil {
		return io.Writer(e), fmt.Errorf("Encrypt writer already inited")
	}
	encStream, iv, err := getEncryptStream(e.passphrase)
	if err != nil {
		return io.Writer(e), err
	}
	if _, err := fileWriter.Write(iv); err != nil {
		return io.Writer(e), err
	}
	e.streamWriter = &cipher.StreamWriter{S: encStream, W: fileWriter}
	return io.Writer(e), nil
}
Exemplo n.º 9
0
//
// Read a CX file and generate SIF.
//
func TestCx2Sif(t *testing.T) {
	output := new(bytes.Buffer)
	w := io.Writer(output)

	file, err := os.Open("../test_data/galcxStyle2.json")
	if err != nil {
		t.Fatal("Error:", err)
		return
	}

	// Close input file at the end of this
	defer file.Close()

	c2s := converter.Cx2Sif{}
	c2s.Convert(bufio.NewReader(file), w)

	result := output.String()

	lines := strings.Split(result, "\n")
	for idx := range lines {
		if lines[idx] == "" {
			fmt.Println(idx, ": EMPTY")
		} else {
			fmt.Println(idx, ": ", lines[idx])
		}
	}
	if len(lines) != 363 {
		t.Errorf("Expected 363, got %d", len(lines))
	}
}
Exemplo n.º 10
0
// CreateBufferedWriter ...
func CreateBufferedWriter(buff *bytes.Buffer, writers ...io.Writer) io.Writer {
	if len(writers) > 0 {
		allWriters := append([]io.Writer{buff}, writers...)
		return io.MultiWriter(allWriters...)
	}
	return io.Writer(buff)
}
Exemplo n.º 11
0
func testSif2Cx(fName string, t *testing.T) {
	output := new(bytes.Buffer)
	w := io.Writer(output)

	f, err := os.Open(fName)

	if err != nil {
		t.Fatal("Error:", err)
		return
	}

	// Close input file at the end of this
	defer f.Close()

	s2c := Sif2Cx{Delimiter: rune(' ')}
	s2c.Convert(bufio.NewReader(f), w)
	result := output.String()

	t.Log(result)

	t.Log("Output length = ", len(result))

	dec := json.NewDecoder(strings.NewReader(result))
	var cx []interface{}
	dec.Decode(&cx)

	t.Log(cx)

}
Exemplo n.º 12
0
func StorePost(w http.ResponseWriter, req *http.Request) {

	filename := uuid.NewV4().String()
	now := time.Now().Format("20060102")
	path := repo + "/" + now
	err := os.MkdirAll(path, 0755)
	if err == nil {

		fullpath := path + "/" + filename

		f, err := os.Create(fullpath)
		if err == nil {

			defer f.Close()

			_, err := io.Copy(io.Writer(f), req.Body)

			if err == nil {

				log.Printf("%+v", req)
				requestUri := "http://" + req.Host + req.RequestURI + now + "/" + filename

				w.Write([]byte("Store OK : " + requestUri))
			} else {
				ServerError(w, req, err)
			}
		} else {
			ServerError(w, req, err)
		}
	} else {
		ServerError(w, req, err)
	}

}
Exemplo n.º 13
0
Arquivo: yaml.go Projeto: rudle/glide
// WriteLock writes the lock as YAML.
//
// Params:
//	- lockfile: A *cfg.Lockfile to render.
// 	- out (io.Writer): An output stream to write to. Default is os.Stdout.
func WriteLock(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
	skip := p.Get("skip", false).(bool)
	if skip {
		return false, nil
	}

	lockfile := p.Get("lockfile", nil).(*cfg.Lockfile)

	Info("Writing glide.lock file")

	data, err := lockfile.Marshal()
	if err != nil {
		return nil, err
	}

	var out io.Writer
	file, err := os.Create("glide.lock")
	if err != nil {
		return false, err
	}
	defer file.Close()
	out = io.Writer(file)
	out.Write(data)

	return true, nil
}
Exemplo n.º 14
0
func TestCx2CyjsAttributes(t *testing.T) {

	output := new(bytes.Buffer)
	resultWriter := io.Writer(output)

	file, err := os.Open("../test_data/Aurora_A_signaling.cx")
	if err != nil {
		t.Fatal("Error:", err)
		return
	}

	// Close input file at the end of this
	defer file.Close()

	c2c := converter.Cx2Cyjs{}
	c2c.Convert(bufio.NewReader(file), resultWriter)

	result := output.String()

	t.Log("Output length = ", len(result))

	pass := checkAttributes(result, t)

	if pass {
		t.Log("Pass")
	} else {
		t.Error("Failed to validate Cytoscape.js output.")
	}
}
Exemplo n.º 15
0
// ExampleLogClient creates a LogClient, injecting a logging object
// that will print each log entry in triplicate.
//
func ExampleLogClient() {

	// Create an object to Write() to Stdout.

	o := io.Writer(os.Stdout)

	// That's not fancy enough, so create an object to
	// triple-write to Stdout.

	tri := io.MultiWriter(o, o, o)

	// Create a LogClient, which will log messages to m.
	// Note that the c knows nothing about m except that it implements
	// the loginfo.Writer interface.  Also, m knows nothing about
	// the loginfo.Writer interface: it is sufficient that it
	// implements a Write([]byte)(int,err) method.

	c := New(tri)

	// Cause c to write "Something\n" to its log.
	c.LogSomething()

	// Output:
	// Something
	// Something
	// Something
}
Exemplo n.º 16
0
func (operation *InitGenerateOperation) Run(logger log.Log) bool {
	logger.Info("running init operation:" + operation.output)

	var writer io.Writer
	switch operation.output {
	case "logger":
		fallthrough
	case "":
		writer = logger
	default:
		if strings.HasSuffix(operation.output, ".") {
			operation.output = operation.output + operation.handler
		}
		if fileWriter, err := os.Create(operation.output); err == nil {
			operation.skip = append(operation.skip, operation.output)
			writer = io.Writer(fileWriter)
			defer fileWriter.Close()
			logger.Message("Opening file for init generation output: " + operation.output)
		} else {
			logger.Error("Could not open output file to write init to:" + operation.output)
		}
	}

	initialize.Init_Generate(logger.MakeChild("init-generate"), operation.handler, operation.root, operation.skip, operation.sizeLimit, writer)

	return true
}
Exemplo n.º 17
0
func Open(path string) (*Graph, error) {
	var log *io.ReadWriter
	if path != "" {
		l, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0666)
		if err != nil {
			return nil, err
		}

		var rw io.ReadWriter = l
		log = &rw
	}

	g := &Graph{}
	g.indexes = makeIndexSet()
	if log != nil {
		w := io.Writer(*log)
		g.log = &w

		r := api.NodeReader{}
		n := &Node{}
		for {
			node, err := r.Read(*log)
			if err == io.EOF {
				break
			} else if err != nil {
				panic(err)
			}

			n.FromApi(node)
			g.indexes.add(*n)
		}
	}

	return g, nil
}
Exemplo n.º 18
0
Arquivo: index.go Projeto: s1na/fetch
func writeIndex(outPath string) {
	outFile, err := os.Create(outPath)
	defer outFile.Close()
	if err != nil {
		panic(err)
	}
	writer := bufio.NewWriterSize(io.Writer(outFile), writerBufSize)

	var v *list.List
	dBuf := make([]byte, 4)
	tfBuf := make([]byte, 4)
	pBuf := make([]byte, 4)
	for _, k := range dictionary.keys {
		v = dictionary.m[k]
		writer.WriteString(k + ",")
		var posting *Posting
		for el := v.Front(); el != nil; el = el.Next() {
			posting = el.Value.(*Posting)
			binary.PutUvarint(dBuf, uint64(posting.doc))
			writer.Write(dBuf)
			dBuf = []byte{0, 0, 0, 0}
			binary.PutUvarint(tfBuf, uint64(posting.tf))
			writer.Write(tfBuf)
			tfBuf = []byte{0, 0, 0, 0}
			for posEl := posting.pos.Front(); posEl != nil; posEl = posEl.Next() {
				pos := posEl.Value.(uint32)
				binary.PutUvarint(pBuf, uint64(pos))
				writer.Write(pBuf)
				pBuf = []byte{0, 0, 0, 0}
			}
		}
		writer.Write([]byte{0, 0, 0, 0})
	}
	writer.Flush()
}
Exemplo n.º 19
0
func main() {
	var (
		buffer = flag.Bool("buffer", false, "buffer stdout")
	)
	flag.Parse()
	if len(flag.Args()) != 1 {
		log.Fatalf("Usage: %s file.bf\n", os.Args[0])
	}

	data, err := ioutil.ReadFile(flag.Arg(0))
	if err != nil {
		log.Fatalf("Reading %s: %s\n", flag.Arg(0), err.Error())
	}

	out := io.Writer(os.Stdout)
	if *buffer {
		out = bufio.NewWriter(out)
	}

	f, e := bf.Compile(data, os.Stdin, out)
	if e != nil {
		log.Fatalf("compiling: %s", e.Error())
	}
	var memory [4096]byte
	f(memory[:])
}
Exemplo n.º 20
0
// ContainerLogs hooks up a container's stdout and stderr streams
// configured with the given struct.
func (c *Container) ContainerLogs(name string, config *backend.ContainerLogsConfig, started chan struct{}) error {
	defer trace.End(trace.Begin(""))

	// Look up the container name in the metadata cache to get long ID
	vc := cache.ContainerCache().GetContainer(name)
	if vc == nil {
		return NotFoundError(name)
	}
	name = vc.ContainerID

	tailLines, since, err := c.validateContainerLogsConfig(vc, config)
	if err != nil {
		return err
	}

	// Outstream modification (from Docker's code) so the stream is streamed with the
	// necessary headers that the CLI expects.  This is Docker's scheme.
	wf := ioutils.NewWriteFlusher(config.OutStream)
	defer wf.Close()

	wf.Flush()

	outStream := io.Writer(wf)
	if !vc.Config.Tty {
		outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
	}

	// Make a call to our proxy to handle the remoting
	err = c.containerProxy.StreamContainerLogs(name, outStream, started, config.Timestamps, config.Follow, since, tailLines)

	return err
}
Exemplo n.º 21
0
Arquivo: yaml.go Projeto: rudle/glide
// WriteYaml writes the config as YAML.
//
// Params:
//	- conf: A *cfg.Config to render.
// 	- out (io.Writer): An output stream to write to. Default is os.Stdout.
// 	- filename (string): If set, the file will be opened and the content will be written to it.
func WriteYaml(c cookoo.Context, p *cookoo.Params) (interface{}, cookoo.Interrupt) {
	conf := p.Get("conf", nil).(*cfg.Config)
	toStdout := p.Get("toStdout", true).(bool)

	data, err := conf.Marshal()
	if err != nil {
		return nil, err
	}

	var out io.Writer
	if nn, ok := p.Has("filename"); ok && len(nn.(string)) > 0 {
		file, err := os.Create(nn.(string))
		if err != nil {
		}
		defer file.Close()
		out = io.Writer(file)
		//fmt.Fprint(out, yml)
		out.Write(data)
	} else if toStdout {
		out = p.Get("out", os.Stdout).(io.Writer)
		//fmt.Fprint(out, yml)
		out.Write(data)
	}

	// Otherwise we supress output.
	return true, nil
}
Exemplo n.º 22
0
func startUDP() (io.Writer, chan []byte, chan struct{}) {
	remote, err := net.ResolveUDPAddr("udp", *remoteAddr)
	if err != nil {
		log.Fatalln("Can not resolve remote address:", err)
	}
	c, err := net.DialUDP("udp", nil, remote)
	conn := io.Writer(c)
	if err != nil {
		log.Fatalln("Can not listen on UDP:", err)
	}
	sink := make(chan []byte)
	ready := make(chan struct{})
	go func() {
		buf := make([]byte, govpn.MTU)
		var n int
		var err error
		for {
			<-ready
			c.SetReadDeadline(time.Now().Add(time.Second))
			n, err = c.Read(buf)
			if err != nil {
				sink <- nil
				continue
			}
			sink <- buf[:n]
		}
	}()
	ready <- struct{}{}
	return conn, sink, ready
}
Exemplo n.º 23
0
// получение таблиц
func GetTablesProp(bd_name string) string {

	rows := doQuery("SELECT TABLE_NAME, TABLE_TYPE, ENGINE, IFNULL(TABLE_COMMENT, '') FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA=?", bd_name)

	if rows == nil {
		return ""
	}

	var result bytes.Buffer
	w := io.Writer(&result)
	Encode := json.NewEncoder(w)

	for rows.Next() {

		var row RecordTables
		//         var i interface {}

		//         i = &row
		rows.Scan(&row.TABLE_NAME, &row.TABLE_TYPE, &row.ENGINE, &row.TABLE_COMMENT)

		err := Encode.Encode(row)
		if err != nil {
			fmt.Println("error:", err)
		}

	}

	return result.String()

}
Exemplo n.º 24
0
func setCounter(name string, node int64, counter uint64) uint64 {
	var offset int64

	fd, err := os.Open(name, os.O_WRONLY, 0666)
	if err == nil {
		defer fd.Close()
		// node 1 is the first node
		offset = (node - 1) * 8
		_, seekerr := fd.Seek(offset, 0)
		if seekerr == nil {
			ior := io.Writer(fd)
			if err := binary.Write(ior, binary.LittleEndian, counter); err != nil {
				fmt.Printf("binary.Write failed: %s\n", err)
			} else {
				fd.Close()
				return counter
			}
		} else {
			fmt.Printf("Seek error for node %d to offset %d\n", node, offset)
			fd.Close()
		}
	} else {
		if cantOpenMessageCounterFile(name) == true {
			setCounter(name, node, counter)
		}
	}

	return 0
}
Exemplo n.º 25
0
func TestToTar(t *testing.T) {
	content := fmt.Sprintf("a b c\neasy as\n1 2 3")
	out, err := ToTar("test_tar", 0644, content)

	if err != nil {
		t.Errorf("Error %#v while writing tar archive, expected nil", err.Error())
	}

	var buffOut bytes.Buffer
	writer := io.Writer(&buffOut)

	for tr := tar.NewReader(out); err != io.EOF; _, err = tr.Next() {
		if err != nil {
			t.Errorf("Error %#v while reading tar archive, expected nil",
				err.Error())
		}

		_, err = io.Copy(writer, tr)
		if err != nil {
			t.Errorf("Error %#v while reading tar archive, expected nil",
				err.Error())
		}
	}

	actual := buffOut.String()
	if actual != content {
		t.Error("Generated incorrect tar archive.")
	}
}
Exemplo n.º 26
0
func Push(devices []Transporter, local io.Reader, mode os.FileMode, modtime uint32, remote string) error {
	d := make([]io.Writer, 0, len(devices))
	for _, t := range devices {
		conn, err := GetPushWriter(t, remote, uint32(mode))
		if err != nil {
			return err
		}
		d = append(d, io.Writer(conn))
		defer conn.VerifyOk()
	}

	reader := bufio.NewReader(local)
	sections := NewSectionedMultiWriter(d...)
	writer := bufio.NewWriter(sections)
	writer.ReadFrom(reader)
	writer.Flush()
	sections.Close()

	wr := bufio.NewWriter(io.MultiWriter(d...))
	wr.WriteString("DONE")
	binary.Write(wr, binary.LittleEndian, modtime)
	wr.Flush()

	return nil
}
Exemplo n.º 27
0
func (a *Archive) writer() (*tharWriter, error) {
	writer := io.Writer(a.Stream)

	flushers := []flushableWriter{}
	closers := []closeableWriter{}

	if a.Options.GZip {
		if a.Options.GZipLevel > 0 {
			gw, err := gzip.NewWriterLevel(writer, a.Options.GZipLevel)
			if err != nil {
				return nil, err
			}

			flushers = append([]flushableWriter{gw}, flushers...)
			closers = append([]closeableWriter{gw}, closers...)
			writer = gw
		} else {
			writer = gzip.NewWriter(writer)
		}
	}

	tw := tar.NewWriter(writer)
	flushers = append([]flushableWriter{tw}, flushers...)

	return &tharWriter{
		Writer:   tw,
		Flushers: flushers,
		Closers:  closers,
	}, nil
}
Exemplo n.º 28
0
// GetFromContainer returns a string containing the content of the file named
// SRC on the container with id ID.
func (dk Client) GetFromContainer(id string, src string) (string, error) {
	var buffIn bytes.Buffer
	var buffOut bytes.Buffer
	err := dk.DownloadFromContainer(id, dkc.DownloadFromContainerOptions{
		OutputStream: &buffIn,
		Path:         src,
	})
	if err != nil {
		return "", err
	}

	writer := io.Writer(&buffOut)

	for tr := tar.NewReader(&buffIn); err != io.EOF; _, err = tr.Next() {

		if err != nil {
			return "", err
		}

		_, err = io.Copy(writer, tr)
		if err != nil {
			return "", err
		}
	}

	return buffOut.String(), nil
}
Exemplo n.º 29
0
// Run runs go test benchmarks matching regex in the current directory and writes
// benchmark data to a PSQL database by calling WriteSet. It returns any error
// encountered.
func (benchdb *BenchPSQL) Run() error {
	// Exec a subprocess for go test bench and write
	// to both stdout and a byte buffer.
	cmd := exec.Command("go", "test", "-bench", benchdb.Config.Regex,
		"-test.run", "XXX", "-benchmem")
	var out bytes.Buffer
	cmd.Stdout = io.MultiWriter(os.Stdout, &out)
	cmd.Stderr = io.Writer(os.Stderr)
	err := cmd.Run()
	if err != nil {
		return fmt.Errorf("command failed: %v", err)
	}

	benchSet, err := parse.ParseSet(&out)
	if err != nil {
		return fmt.Errorf("failed to parse benchmark data: %v", err)
	}

	// Writes parse set to sql database.
	_, err = benchdb.WriteSet(benchSet)
	if err != nil {
		return fmt.Errorf("failed to write benchSet to db: %v", err)
	}
	return nil
}
Exemplo n.º 30
0
func main() {

	mode = flag.String("m", "tcp", "portguard work mode: tcp or udp")
	debug = flag.Bool("d", false, "debug mode, print log to stderr")
	portCacheDuration = flag.Int64("duration", 120, "port cache duration")

	flag.Usage = usage
	flag.Parse()

	if *debug {
		mainLogger = log.New(io.Writer(os.Stderr), "", log.Ldate|log.Lmicroseconds)
	} else {
		var err error
		if mainLogger, err = syslog.NewLogger(syslog.LOG_ERR|syslog.LOG_LOCAL7, log.Ldate|log.Lmicroseconds); err != nil {
			logMain(true, "open syslog failed:%s", err.Error())
		}
	}

	args := flag.Args()
	if len(args) > 0 {
		readConfigFile(args[0])
	}
	configGuard()
	configEcho()

	if *mode == "tcp" {
		tcpGuard()
	} else if *mode == "udp" {
		udpGuard()
	} else {
		fmt.Fprintf(os.Stderr, "don't support mode: %s\n", *mode)
	}
}