main.go 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  1. package main
  2. import (
  3. "fmt"
  4. "log"
  5. "math/rand"
  6. "runtime"
  7. "sort"
  8. "strconv"
  9. "database/sql"
  10. "github.com/gin-gonic/gin"
  11. _ "github.com/go-sql-driver/mysql"
  12. )
  13. const (
  14. // Database
  15. worldSelect = "SELECT id, randomNumber FROM World WHERE id = ?"
  16. worldUpdate = "UPDATE World SET randomNumber = ? WHERE id = ?"
  17. fortuneSelect = "SELECT id, message FROM Fortune;"
  18. worldRowCount = 10000
  19. maxConnectionCount = 256
  20. )
  21. type World struct {
  22. Id uint16 `json:"id"`
  23. RandomNumber uint16 `json:"randomNumber"`
  24. }
  25. type Fortune struct {
  26. Id uint16 `json:"id"`
  27. Message string `json:"message"`
  28. }
  29. type Fortunes []*Fortune
  30. func (s Fortunes) Len() int { return len(s) }
  31. func (s Fortunes) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
  32. type ByMessage struct{ Fortunes }
  33. func (s ByMessage) Less(i, j int) bool { return s.Fortunes[i].Message < s.Fortunes[j].Message }
  34. var (
  35. // Database
  36. worldStatement *sql.Stmt
  37. fortuneStatement *sql.Stmt
  38. updateStatement *sql.Stmt
  39. )
  40. func parseQueries(c *gin.Context) int {
  41. n, err := strconv.Atoi(c.Request.URL.Query().Get("queries"))
  42. if err != nil {
  43. n = 1
  44. } else if n < 1 {
  45. n = 1
  46. } else if n > 500 {
  47. n = 500
  48. }
  49. return n
  50. }
  51. // / Test 1: JSON serialization
  52. func json(c *gin.Context) {
  53. c.JSON(200, gin.H{"message": "Hello, World!"})
  54. }
  55. // / Test 2: Single database query
  56. func db(c *gin.Context) {
  57. var world World
  58. err := worldStatement.QueryRow(rand.Intn(worldRowCount)+1).Scan(&world.Id, &world.RandomNumber)
  59. if err != nil {
  60. c.AbortWithError(500, err)
  61. return
  62. }
  63. c.JSON(200, &world)
  64. }
  65. // / Test 3: Multiple database queries
  66. func dbs(c *gin.Context) {
  67. numQueries := parseQueries(c)
  68. worlds := make([]World, numQueries)
  69. for i := 0; i < numQueries; i++ {
  70. err := worldStatement.QueryRow(rand.Intn(worldRowCount)+1).Scan(&worlds[i].Id, &worlds[i].RandomNumber)
  71. if err != nil {
  72. c.AbortWithError(500, err)
  73. return
  74. }
  75. }
  76. c.JSON(200, &worlds)
  77. }
  78. // / Test 4: Fortunes
  79. func fortunes(c *gin.Context) {
  80. rows, err := fortuneStatement.Query()
  81. if err != nil {
  82. c.AbortWithError(500, err)
  83. return
  84. }
  85. fortunes := make(Fortunes, 0)
  86. for rows.Next() { //Fetch rows
  87. fortune := Fortune{}
  88. if err := rows.Scan(&fortune.Id, &fortune.Message); err != nil {
  89. c.AbortWithError(500, err)
  90. return
  91. }
  92. fortunes = append(fortunes, &fortune)
  93. }
  94. fortunes = append(fortunes, &Fortune{Message: "Additional fortune added at request time."})
  95. sort.Sort(ByMessage{fortunes})
  96. c.HTML(200, "fortune.html", fortunes)
  97. }
  98. // / Test 5: Database updates
  99. func update(c *gin.Context) {
  100. numQueries := parseQueries(c)
  101. world := make([]World, numQueries)
  102. for i := 0; i < numQueries; i++ {
  103. if err := worldStatement.QueryRow(rand.Intn(worldRowCount)+1).Scan(&world[i].Id, &world[i].RandomNumber); err != nil {
  104. c.AbortWithError(500, err)
  105. return
  106. }
  107. world[i].RandomNumber = uint16(rand.Intn(worldRowCount) + 1)
  108. if _, err := updateStatement.Exec(world[i].RandomNumber, world[i].Id); err != nil {
  109. c.AbortWithError(500, err)
  110. return
  111. }
  112. }
  113. c.JSON(200, world)
  114. }
  115. // / Test 6: plaintext
  116. func plaintext(c *gin.Context) {
  117. c.String(200, "Hello, World!")
  118. }
  119. func main() {
  120. gin.SetMode(gin.ReleaseMode)
  121. r := gin.New()
  122. serverHeader := []string{"Gin"}
  123. r.Use(func(c *gin.Context) {
  124. c.Writer.Header()["Server"] = serverHeader
  125. })
  126. r.LoadHTMLGlob("templates/fortune.html")
  127. r.GET("/json", json)
  128. r.GET("/db", db)
  129. r.GET("/dbs", dbs)
  130. r.GET("/fortunes", fortunes)
  131. r.GET("/update", update)
  132. r.GET("/plaintext", plaintext)
  133. fmt.Println("Listening and serving HTTP")
  134. r.Run(":8080")
  135. }
  136. func init() {
  137. runtime.GOMAXPROCS(runtime.NumCPU())
  138. dsn := "benchmarkdbuser:benchmarkdbpass@tcp(%s:3306)/hello_world"
  139. dbhost := "tfb-database"
  140. db, err := sql.Open("mysql", fmt.Sprintf(dsn, dbhost))
  141. if err != nil {
  142. log.Fatalf("Error opening database: %v", err)
  143. }
  144. db.SetMaxIdleConns(maxConnectionCount)
  145. worldStatement, err = db.Prepare(worldSelect)
  146. if err != nil {
  147. log.Fatal(err)
  148. }
  149. fortuneStatement, err = db.Prepare(fortuneSelect)
  150. if err != nil {
  151. log.Fatal(err)
  152. }
  153. updateStatement, err = db.Prepare(worldUpdate)
  154. if err != nil {
  155. log.Fatal(err)
  156. }
  157. }