Golang Engine.Run方法代碼示例

func (m *Armor) RunWithRPC(g *gin.Engine, rpcInit func(*grpc.Server)) {
	runOn := fmt.Sprintf("%s:%s", m.Config.GetString("interface"), m.Config.GetString("port"))
	banner := `

      A R M O R
    .---.___.---.
    |     |     |   Running .....: PRODUCT_NAME
    |_____|_____|   Host/Iface ..: HOST/INTERFACE
      |___|___|
      |___|___|
     `
	// XXX replace with tmpl
	banner = strings.Replace(
		strings.Replace(
			strings.Replace(banner, "HOST", m.Config.Hostname, -1), "PRODUCT_NAME", m.Config.Product, -1),
		"INTERFACE", runOn, -1)

	log.Print(banner)
	log.Printf("-> Environment: %v", m.Config.Environment)
	log.Printf("-> Product: %v", m.Config.Product)
	log.Printf("-> Host/Interface: %v/%v", m.Config.Hostname, runOn)
	log.Printf("-> Config: %v", m.Config.All())

	if rpcInit != nil {
		rpc := newRPC(m.Config)
		rpc.Run(rpcInit)
	}
	g.Run(runOn)
}

func main() {
	flag.Parse()
	if *logToFile {
		logWriteTo, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
		if err != nil {
			log.Printf("error opening to log file: %v", err)
		}
		if logWriteTo != nil {
			log.SetOutput(logWriteTo)
		}
	}
	gin.SetMode(*ginMode)
	var route *gin.Engine
	if *useGinLogger {
		route = gin.Default()
	} else {
		route = gin.New()
		route.Use(logger)
	}

	route.GET("/", func(ctx *gin.Context) {
		ctx.JSON(200, gin.H{"message": "Its an entry point :)"})
	})

	route.GET("/token", func(ctx *gin.Context) {
		tokenString := auth.GetToken(secretpassword)
		ctx.JSON(200, gin.H{"token": tokenString})
	})
	route.GET("/dbaccessor", func(ctx *gin.Context) {
		ctx.JSON(200, getFakeDbData())
	})
	route.Use(auth.Auth(secretpassword))
	route.POST("/auth", func(ctx *gin.Context) {
		ak := ctx.Request.FormValue("authkey")
		if ak == "" {
			ctx.JSON(401, "No auth key")
		} else if !auth.VerifyAuthKey(ak) {
			ctx.JSON(401, "Wrong key")
		} else {
			ctx.Redirect(http.StatusFound, "/user")
		}
	})
	route.GET("/user", func(ctx *gin.Context) {
		key := ctx.MustGet("authKey")
		udetails := dbAccessor(key.(string))
		ctx.JSON(200, gin.H{"user": udetails})
	})
	route.GET("/user/:id", func(ctx *gin.Context) {
		id := ctx.Params.ByName("id")
		ctx.JSON(200, find(id))
	})

	if err := route.Run(fmt.Sprintf(":%d", *port)); err != nil {
		logFatal("Http not running: ", err)
	} else {
		logPrintln("shutting down")
	}
}

func main() {
	var engine *gin.Engine = gin.New()
	engine.Use(gin.Logger())
	engine.Use(gin.Recovery())
	engine.GET("/:name", func(c *gin.Context) {
		c.String(http.StatusOK, "Hello %s\n", c.Param("name"))
	})
	engine.GET("/", func(c *gin.Context) {
		c.String(http.StatusOK, "Index\n")
	})
	engine.Run(":8080")
}

func main() {
	var err error
	var cp string
	var initial bool
	var r *gin.Engine

	tbox, _ := rice.FindBox("templates")
	abox, _ := rice.FindBox("assets")

	flag.StringVarP(&cp, "conf", "c", "conf.yml", "Local path to configuration file.")
	flag.BoolVarP(&initial, "initial", "i", false, "Run the initial setup of the server.")
	flag.Parse()

	if err = conf.Load(cp, !initial); err != nil || initial {
		setup.Run()
	}
	if err = database.Initialize(); err != nil {
		log.Fatal(err)
	}
	defer database.DB.Close()
	if err = models.Initialize(); err != nil {
		log.Fatal(err)
	}
	go monitoring.Monit()
	if r, err = router.Setup(tbox, abox); err != nil {
		log.Fatal(err)
	}

	logger.Info("server", "Started goploader server on port", conf.C.Port)
	if conf.C.ServeHTTPS {
		if err = http.ListenAndServeTLS(fmt.Sprintf(":%d", conf.C.Port), conf.C.SSLCert, conf.C.SSLPrivKey, r); err != nil {
			logger.Err("server", "Fatal error", err)
		}
	} else {
		if err = r.Run(fmt.Sprintf(":%d", conf.C.Port)); err != nil {
			logger.Err("server", "Fatal error", err)
		}
	}
}

// Application entry point
func main() {

	fmt.Printf("\n%s (%s) %s\n\n", APP_TITLE, APP_NAME, APP_VERSION)

	// Setup the logging infrastructure
	initialiseLogging()

	// Setup some default values
	opt = new(Options)
	opt.ConfigFile = "./" + APP_NAME + ".config"
	opt.CsvField = -1
	opt.CsvDelimiter = ","
	opt.RemoveQuotes = false
	opt.Format = FORMAT_ALL // Default to all output

	goptions.ParseAndFail(opt)

	// Increment the CSV field to make it easier for the user, since our arrays are 0 based
	if opt.CsvField > -1 {
		opt.CsvField -= 1
	}

	// Validate the mode value
	switch opt.Mode {
	case MODE_SERVER:
		// Load the applications configuration such as ports and IP
		config = loadConfig(opt.ConfigFile, true)
	case MODE_FILE:
		if len(opt.InputFile) == 0 {
			logger.Fatal("Input file path must be supplied when in file mode")
		}

		if len(opt.OutputFile) == 0 {
			logger.Fatal("Output file path must be supplied when in file mode")
		}

		// Load the applications configuration such as ports and IP
		config = loadConfig(opt.ConfigFile, false)
	default:
		logger.Fatal("Invalid mode value (m): %v", opt.Mode)
	}

	// Validate the format value
	switch opt.Format {
	case FORMAT_UNIDENTIFIED:
	case FORMAT_IDENTIFIED:
	case FORMAT_ALL:
	default:
		logger.Fatal("Invalid format value (f): %v", opt.Format)
	}

	// Lets make sure that the users input file actually exists
	if _, err := os.Stat(opt.DataFile); os.IsNotExist(err) {
		logger.Fatal("Data file does not exist")
	}

	processDataFile(opt.DataFile)

	// Start the web API interface if the user wants it running
	if opt.Mode == "s" {
		logger.Info("HTTP API server running: " + config.ApiIp + ":" + fmt.Sprintf("%d", config.ApiPort))
		go func() {
			var r *gin.Engine
			if config.ShowRequests == true {
				r = gin.Default()
			} else {
				gin.SetMode(gin.ReleaseMode)
				r = gin.New()

				r.Use(gin.Recovery())
			}

			r.GET("/single/:hash/", lookupSingleHash)
			r.POST("/bulk", lookupMultipleHashes)
			r.Run(config.ApiIp + ":" + fmt.Sprintf("%d", config.ApiPort))
		}()

		var wg sync.WaitGroup
		wg.Add(1)
		wg.Wait()
	} else {
		processInputFile()
	}
}

func startServer(r *gin.Engine, wg *sync.WaitGroup) {
	defer wg.Done()

	listen := httpListenString()
	r.Run(listen)
}