func setupLogger(logDir string) *log.Logger {
var logger *log.Logger
log.SetFlags(log.Ldate | log.Lmicroseconds)
if logDir != "" {
logFile := filepath.Join(logDir, "host.log")
if err := os.MkdirAll(filepath.Dir(logFile), 0755); err != nil {
log.Fatalf("could not not mkdir for logs: %s", err)
}
hostlog, err := os.OpenFile(logFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatal(err)
}
defer hostlog.Close()
log.Printf("Logging to %s\n", logFile)
log.SetOutput(io.MultiWriter(hostlog, os.Stdout))
logger = log.New(io.MultiWriter(hostlog, os.Stderr), "", log.Flags())
} else {
logger = log.New(os.Stderr, "", log.Flags())
}
return logger
}
func log_debug(msg string, a ...interface{}) {
if !debugging {
return
}
defer log.SetFlags(log.Flags())
log.SetFlags(log.Flags() | log.Lshortfile)
msg = fmt.Sprintf(msg, a...)
log.Output(2, msg)
}
// Init initializes flags and run all functions in initFunc.
func Init() {
log.SetFlags(log.Lshortfile | log.Flags())
flag.Parse()
if !flag.Parsed() {
log.Fatal("Unable to parse flags")
}
logger = log.New(os.Stderr, "", log.Lshortfile|log.Flags())
AssertTrue(logger != nil)
printVersionOnly()
// Next, run all the init functions that have been added.
for _, f := range initFunc {
f()
}
}
func SetAttribPointers(locations interface{}, vertexData interface{}, instanced bool) {
attribs, _ := LocationMap(locations)
Type := reflect.TypeOf(vertexData).Elem()
stride := int(Type.Size())
for i := 0; i < Type.NumField(); i++ {
structElement := Type.Field(i)
elementType := structElement.Type
var size uint
var typ gl.GLenum
var kind reflect.Kind
switch elementType.Kind() {
case reflect.Array:
size = uint(elementType.Len())
kind = elementType.Elem().Kind()
default:
size = 1
kind = elementType.Kind()
}
switch kind {
case reflect.Float32:
typ = gl.FLOAT
case reflect.Float64:
typ = gl.DOUBLE
default:
panic("not implemented yet")
}
offset := structElement.Offset
Loc := attribs[structElement.Name]
if Loc >= 0 {
Loc.EnableArray()
Loc.AttribPointer(size, typ, false, stride, offset)
if instanced {
Loc.AttribDivisor(1)
}
if log.Flags()&VERTEX_INFO_FLAG != 0 {
log.Printf("%s: Loc: %d, size: %d, type: %d, stride: %d, offset: %d\n", structElement.Name, Loc, size, typ, stride, offset)
}
} else if log.Flags()&VERTEX_INFO_FLAG != 0 {
log.Printf("%s: Loc: %d, !!!\n", structElement.Name, Loc)
}
}
}
func TestTripleDuplicates(t *testing.T) {
t.Parallel()
file, err := ioutil.TempFile(os.TempDir(), "triplestore.db")
if err != nil {
t.Fatal(err)
}
defer os.Remove(file.Name())
db, err := NewTripleStore(file.Name(), log.New(os.Stdout, "", log.Flags()))
if err != nil {
t.Fatal(err)
}
db.Insert(testTriples)
// Insert twice to ensure no duplicates.
db.Insert(testTriples)
info, err := db.Size()
if err != nil {
t.Fatal(err)
}
if info.Triples != uint64(len(testTriples)) {
t.Errorf("Size() = %#v; not %d", info, len(testTriples))
}
}
func main() {
flag.DurationVar(&gBenchDur, "d", time.Millisecond, "duration for bench")
var (
localAddr = flag.String("l", "", "local udp address, eg: ip:port")
serverAddr = flag.String("h", "", "server udp address, eg: ip:port")
concurent = flag.Int("c", 1, "concurent client number")
)
flag.Parse()
log.SetFlags(log.Flags() | log.Lshortfile)
if len(*localAddr) == 0 || len(*serverAddr) == 0 {
flag.Usage()
return
}
server, err := net.ResolveUDPAddr("udp", *serverAddr)
if err != nil {
fmt.Printf("Resolve server addr %s failed: %v\n", *serverAddr, err)
return
}
local, err := net.ResolveUDPAddr("udp", *localAddr)
if err != nil {
fmt.Printf("Resolve local addr %s failed: %v\n", *localAddr, err)
return
}
firstPort := local.Port
// 跳过监听失败的端口
for p, n := 0, 0; n < *concurent; p++ {
local.Port = firstPort + p
socket, err := net.ListenUDP("udp", local)
if err != nil {
fmt.Printf("Listen on local addr %v failed: %v\n", local, err)
continue
}
n++
c := Client{
Name: "deviceName",
ProduceTime: time.Now(),
DeviceType: 0xFFFE,
Sid: make([]byte, 16),
Socket: socket,
ServerAddr: server,
rch: make(chan []byte, 128),
}
binary.LittleEndian.PutUint32(c.SN[11:15], uint32(n))
binary.LittleEndian.PutUint32(c.MAC[3:7], uint32(n))
log.Printf("Client started, mac: %v, sn: %v", hex.EncodeToString(c.MAC[:]), hex.EncodeToString(c.SN[:]))
go c.Run()
}
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
for sig := range c {
switch sig {
case syscall.SIGINT, syscall.SIGTERM:
return
}
}
}
func main() {
var err error
db, err = sql.Open("mysql", "root:123456@tcp(182.92.69.21:3305)/game_server?charset=utf8")
db.SetMaxOpenConns(50)
db.SetMaxIdleConns(50)
defer db.Close()
err = db.Ping()
if err != nil {
log.Fatal(err)
}
log.SetFlags(log.Flags() | log.Lshortfile)
a.HandleConnect(handleConnect)
a.HandleMessage(handleMessage)
a.HandleDisconnect(handleDisconnect)
ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
go a.Start()
go Handle()
go pingHandle()
<-ch
hql.Truncate_server(db)
hql.Truncate_platform(db)
a.Stop(shutdown)
wg.Wait()
}
func main() {
log.SetFlags(log.Flags() | log.Lshortfile)
parsed, err := docopt.Parse(whitespace.CleanWS(`
Usage:
docker_labels [options] <image-name>
Options:
--insecure makes the connection to e.g. a self-signed registry
`), nil, true, "", false)
if err != nil {
log.Fatal(err)
}
imageName := parsed["<image-name>"].(string)
client := docker_registry.NewClient()
if _, ok := parsed["--insecure"]; ok {
client.BecomeFoolishlyTrusting()
}
labels, err := client.LabelsForImageName(imageName)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found %d labels:\n", len(labels))
for key, value := range labels {
fmt.Printf("%s: %s\n", key, value)
}
}
func main() {
log.SetFlags(log.Flags() | log.Llongfile)
//recv := &chromebus.ChromebusRecordStdinReceiver{}
//str, _ := recv.GetRecord()
//log.Printf("%s", str)
//str, _ = recv.GetRecord()
//log.Printf("%s", str)
flag.Parse()
flag.VisitAll(defFlags)
if !serverMode {
chromebus.EnvSetup()
}
var e *chromebus.Engine
if pluginsDefined {
e = chromebus.CreateEngine(plugins, port)
} else {
e = chromebus.CreateEngine(nil, port)
}
go func() {
e.Start()
}()
signalChannel := make(chan os.Signal, 1)
signal.Notify(signalChannel, os.Interrupt, os.Kill)
<-signalChannel
e.CleanUp()
//rcv := ChromebusRecordStdinReceiver{}
//exec.Command("date")
}
func main() {
log.SetFlags(log.Flags() | log.Lshortfile)
parsed, err := docopt.Parse(`Usage: cert_san <cert-path>`, nil, true, "", false)
if err != nil {
log.Fatal(err)
}
certPath := parsed["<cert-path>"].(string)
certFile, err := os.Open(certPath)
if err != nil {
log.Fatal(err)
}
certBuf := bytes.Buffer{}
_, err = certBuf.ReadFrom(certFile)
if err != nil {
log.Fatal(err)
}
log.Print("\n", certBuf.String())
block, _ := pem.Decode(certBuf.Bytes())
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
log.Fatal(err)
}
log.Printf("Cert good for addresses: %+v", cert.IPAddresses)
}
func main() {
r := Rectangle{length: 5, width: 3}
fmt.Println("Rectangle r details are: ", r)
fmt.Println("Rectangle r's area is: ", r.Area())
s := Shaper(r)
fmt.Println("Area of the Shape r is: ", s.Area())
fmt.Println("Area of the Shape r is: ", s.Shit())
return
cfgFile := "file.txt"
f, err := os.OpenFile(cfgFile, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666) // For read access.
if err != nil {
checkError(err)
}
// var l int
myLog := log.New(f, "PREFIXIO ", log.Lshortfile|log.Ldate|log.Ltime)
// l, err = f.WriteString("HELLO THERE n");
// fmt.Printf("length is :%d\n", l);
if err != nil {
checkError2(err)
}
myLog.Println("from logger")
//myFileAppendLine(cfgFile, "HELLO THERE \n");
fmt.Printf("Flags:%q Prefix:%q\n", log.Flags(), log.Prefix())
os.Exit(0)
}
func init() {
log.SetFlags(log.Flags() | log.Lshortfile)
bytes, err := ioutil.ReadFile("config.conf")
e(err, true)
str := string(bytes)
lines := strings.Split(str, "\n")
reg, err := regexp.Compile(`\s+`)
e(err, true)
for num, line := range lines {
if line == "" {
continue
}
if strings.HasPrefix(line, "#") {
continue
}
fields := reg.Split(line, -1)
if len(fields) != 2 {
log.Printf("Line %d is not match the config format.", num+1)
continue
}
dbname := fields[0]
dburi := fields[1]
DBS[dbname] = dburi
dbs[dbname] = init_db(dburi)
}
}
// Setup registers all server handlers.
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
log.SetFlags(log.Flags() | log.Lshortfile)
flag.Parse()
s, err := newServer()
if err != nil {
log.Fatal(err)
}
defer s.graph.Close()
fs := http.FileServer(http.Dir("."))
http.Handle("/static/", fs)
http.HandleFunc("/", handleIndex)
http.HandleFunc("/api/v1/recommendation", s.handleRecommendation)
log.Printf("Serving on :%s...", *port)
err = http.ListenAndServe("0.0.0.0:"+*port, nil)
if err != nil {
log.Println(err)
}
log.Println("Server on 6060 stopped")
os.Exit(0)
}
// NewServer creates a new server with routing information. If log is nil, stdout is used.
func NewServer(logger *log.Logger, port int) (*Server, error) {
if logger == nil {
logger = log.New(os.Stdout, "", log.Flags())
}
s := &Server{
Logger: logger,
Port: port,
Peers: make(map[string]*Conn),
handlers: make(map[string]protocolHandler),
}
s.listeningWG.Add(1)
s.IP = getHost()
s.listener = &httpListener{
accept: make(chan *httpConn, 10),
}
s.initHTTPRouting()
// Handlers
s.Handle("Handshake", s.handleHandshake)
s.Handle("PeerRequest", s.handlePeerRequest)
s.Handle("PeerNotify", s.handlePeerNotify)
return s, nil
}
func TestModifyScale(t *testing.T) {
log.SetFlags(log.Flags() | log.Lshortfile)
assert := assert.New(t)
mods := make(chan *sous.DeployablePair, 1)
errs := make(chan error, 10)
pair := baseDeployablePair()
pair.Prior.Deployment.DeployConfig.NumInstances = 12
pair.Post.Deployment.DeployConfig.NumInstances = 24
client := sous.NewDummyRectificationClient()
deployer := NewDeployer(client)
mods <- pair
close(mods)
deployer.RectifyModifies(mods, errs)
close(errs)
for e := range errs {
t.Error(e)
}
assert.Len(client.Deployed, 0)
if assert.Len(client.Created, 1) {
assert.Equal(24, client.Created[0].Count)
}
}
func main() {
var dumpConf bool
var confFile string
flag.BoolVar(&dumpConf, "dumpconf", false, "dump the default configuration file")
flag.StringVar(&confFile, "conf", "", "use this alternative configuration file")
flag.Parse()
stdoutLogger = log.New(os.Stderr, "", log.Flags())
if dumpConf {
dumpDefaultConf()
return
}
rand.Seed(time.Now().Unix())
if confFile != "" {
setConf(confFile)
}
if conf.RealIP {
goji.Insert(middleware.RealIP, middleware.Logger)
}
goji.Get("/", root)
goji.Get("/:id", getPaste)
goji.Post("/", createPaste)
goji.Serve()
}
func TestStkErr(t *testing.T) {
//Log automatically writes to Stderr
//If not using official log, simply pass in os.Stderr as an io.Writer
//to make it work
fmt.Println("Const os.Stderr", os.Stderr)
fmt.Println("Hey", log.Flags())
}
// Capture creates a new *Logger instance with an internal buffer. The prefix
// and flags default to the values of log.Prefix() and log.Flags(), respectively.
// This function is meant to be called from test code. See the godoc for the
// Logger struct for details.
func Capture() *Logger {
out := new(bytes.Buffer)
return &Logger{
Log: out,
Logger: log.New(out, log.Prefix(), log.Flags()),
}
}
func init() {
// Set up builtin middlewarez
OnBeforeNotify(httpRequestMiddleware)
// Default configuration
Config.update(&Configuration{
APIKey: "",
Endpoint: "https://notify.bugsnag.com/",
Hostname: "",
AppVersion: "",
ReleaseStage: "",
ParamsFilters: []string{"password", "secret"},
// * for app-engine
ProjectPackages: []string{"main*"},
NotifyReleaseStages: nil,
Logger: log.New(os.Stdout, log.Prefix(), log.Flags()),
PanicHandler: defaultPanicHandler,
Transport: http.DefaultTransport,
})
hostname, err := os.Hostname()
if err == nil {
Config.Hostname = hostname
}
}
func main() {
log.Flags()
log.SetFlags(0)
// parse csv
records := parse.Parse("../../../resources/table.csv")
// parse template
tpl, err := template.ParseFiles("hw.gohtml")
if err != nil {
log.Fatalln(err)
}
// function
http.HandleFunc("/", func(res http.ResponseWriter, req *http.Request) {
// execute template
err = tpl.Execute(res, records)
if err != nil {
log.Fatalln(err)
}
})
// create server
http.ListenAndServe(":9000", nil)
}
func init() {
log.SetFlags(log.Flags() | log.Lmicroseconds)
http.Handle("/css/", http.StripPrefix("/css/", http.FileServer(http.Dir(configs.ServerRoot.Join("css").S()))))
http.Handle("/js/", http.StripPrefix("/js/", http.FileServer(http.Dir(configs.ServerRoot.Join("js").S()))))
http.Handle("/images/", http.StripPrefix("/images/", http.FileServer(http.Dir(configs.ServerRoot.Join("images").S()))))
http.Handle("/img/", http.StripPrefix("/img/", http.FileServer(http.Dir(configs.ServerRoot.Join("images").S()))))
http.Handle("/robots.txt", http.FileServer(http.Dir(configs.ServerRoot.Join("static").S())))
http.Handle("/clippy.swf", http.FileServer(http.Dir(configs.ServerRoot.Join("static").S())))
http.HandleFunc("/add", pageAdd)
http.HandleFunc("/search", pageSearch)
http.HandleFunc("/view", pageView)
http.HandleFunc("/tops", pageTops)
http.HandleFunc("/about", staticPage("about.html"))
http.HandleFunc("/infoapi", staticPage("infoapi.html"))
http.HandleFunc("/api", pageApi)
http.HandleFunc("/loadtemplates", pageLoadTemplate)
http.HandleFunc("/badge", pageBadge)
http.HandleFunc("/badgepage", pageBadgePage)
http.HandleFunc("/crawlhistory", pageCrawlHistory)
bi.HandleRequest(configs.BiWebPath)
http.HandleFunc("/", pageRoot)
}
func main() {
log.SetFlags(log.Flags() | log.Lshortfile)
flag.Parse()
metaInfo, err := metainfo.LoadFromFile(*torrentPath)
if err != nil {
log.Fatal(err)
}
mMapSpan := &mmap_span.MMapSpan{}
if len(metaInfo.Info.Files) > 0 {
for _, file := range metaInfo.Info.Files {
filename := filepath.Join(append([]string{*dataPath, metaInfo.Info.Name}, file.Path...)...)
goMMap := fileToMmap(filename, file.Length)
mMapSpan.Append(goMMap)
}
log.Println(len(metaInfo.Info.Files))
} else {
goMMap := fileToMmap(*dataPath, metaInfo.Info.Length)
mMapSpan.Append(goMMap)
}
log.Println(mMapSpan.Size())
log.Println(len(metaInfo.Info.Pieces))
info := metaInfo.Info
for i := range iter.N(metaInfo.Info.NumPieces()) {
p := info.Piece(i)
hash := sha1.New()
_, err := io.Copy(hash, io.NewSectionReader(mMapSpan, p.Offset(), p.Length()))
if err != nil {
log.Fatal(err)
}
fmt.Printf("%d: %x: %v\n", i, p.Hash(), bytes.Equal(hash.Sum(nil), p.Hash().Bytes()))
}
}
func init() {
bind.WithFlag()
if fl := log.Flags(); fl&log.Ltime != 0 {
log.SetFlags(fl | log.Lmicroseconds)
}
graceful.DoubleKickWindow(2 * time.Second)
}
func main() {
log.SetFlags(log.Flags() | log.Lshortfile)
c := &gorpc.Client{
// TCP address of the server.
// Addr: "127.0.0.1:12345",
Addr: "10.10.18.97:12345",
}
c.Start()
// All client methods issuing RPCs are thread-safe and goroutine-safe,
// i.e. it is safe to call them from multiple concurrently running goroutines.
resp, err := c.Call("foobar")
if err != nil {
log.Fatalf("Error when sending request to server: %s", err)
}
log.Println(resp)
for i := 0; true; i++ {
time.Sleep(2 * time.Second)
person := comm.Person{
No: i,
Name: "张三",
Age: 14,
}
resp, err = c.Call(person)
if err != nil {
log.Fatalf("Error when sending request to server: %s", err)
}
log.Println(resp)
}
}
func LogNoTime() {
logLock.RLock()
defer logLock.RUnlock()
//Disable timestamp for default logger, this may be used by other packages
log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime | log.Lmicroseconds))
logNoTime = true
}
func (s *MainSuite) Test_initLog_SetsLogFlagsIfDebugging(c *C) {
log.SetFlags(0)
*config.DebugFlag = true
initLog()
c.Assert(log.Flags(), Equals, log.Ldate|log.Ltime|log.Llongfile)
c.Assert(log.Prefix(), Equals, "[CoyIM] ")
}
func main() {
log.SetFlags(log.Flags() | log.Lshortfile)
s := gorpc.Server{
// Accept clients on this TCP address.
Addr: ":12345",
// Echo handler - just return back the message we received from the client
Handler: func(clientAddr string, request interface{}) interface{} {
log.Printf("Obtained request %+v from the client %s\n", request, clientAddr)
switch request.(type) {
case string:
return request
case comm.Person:
person, _ := request.(comm.Person)
return comm.Student{
Person: person,
Grade: "高三",
Class: "3班",
School: "临湘二中",
}
}
return "ERROR"
},
}
if err := s.Serve(); err != nil {
log.Fatalf("Cannot start rpc server: %s", err)
}
}
// Serve starts Goji using reasonable defaults.
func Serve() {
if !flag.Parsed() {
flag.Parse()
}
log.SetFlags(log.Flags() | log.Lmicroseconds)
// Install our handler at the root of the standard net/http default mux.
// This allows packages like expvar to continue working as expected.
http.Handle("/", DefaultMux)
listener := bind.Default()
log.Println("Starting Goji on", listener.Addr())
graceful.HandleSignals()
bind.Ready()
err := graceful.Serve(listener, http.DefaultServeMux)
if err != nil {
log.Fatal(err)
}
graceful.Wait()
}
// Mount the file system based on the supplied arguments, returning a
// fuse.MountedFileSystem that can be joined to wait for unmounting.
func mount(
ctx context.Context,
bucketName string,
mountPoint string,
flags *FlagStorage) (mfs *fuse.MountedFileSystem, err error) {
// Choose UID and GID.
uid, gid, err := MyUserAndGroup()
if err != nil {
err = fmt.Errorf("MyUserAndGroup: %v", err)
return
}
if int32(flags.Uid) == -1 {
flags.Uid = uid
}
if int32(flags.Gid) == -1 {
flags.Gid = gid
}
awsConfig := &aws.Config{
Region: aws.String("us-west-2"),
//LogLevel: aws.LogLevel(aws.LogDebug),
}
if len(flags.Endpoint) > 0 {
awsConfig.Endpoint = &flags.Endpoint
}
if flags.UsePathRequest {
awsConfig.S3ForcePathStyle = aws.Bool(true)
}
goofys := NewGoofys(bucketName, awsConfig, flags)
if goofys == nil {
err = fmt.Errorf("Mount: initialization failed")
return
}
server := fuseutil.NewFileSystemServer(goofys)
// Mount the file system.
mountCfg := &fuse.MountConfig{
FSName: bucketName,
Options: flags.MountOptions,
ErrorLogger: log.New(os.Stderr, "fuse: ", log.Flags()),
DisableWritebackCaching: true,
}
if flags.DebugFuse {
mountCfg.DebugLogger = log.New(os.Stderr, "fuse_debug: ", 0)
}
mfs, err = fuse.Mount(mountPoint, server, mountCfg)
if err != nil {
err = fmt.Errorf("Mount: %v", err)
return
}
return
}
func init() {
// Set log format.
f := log.Flags()
log.SetFlags(f | log.Llongfile)
// Initialisations.
nameRegexp = regexp.MustCompile("^[a-z][a-z0-9_]*[a-z0-9]$")
}