add conf path

liuxiaolong

2019-12-11 d671ea8ec8658da21990d5418c981d74f6015045

 server.go

@@ -7,55 +7,115 @@
   "strconv"
   "time"

   "github.com/long/test/esutil"
   log "github.com/long/test/log"
   "andriodServer/esutil"
   "andriodServer/extend/config"
   "andriodServer/log"
   "github.com/streadway/amqp"
)

var addr = flag.String("addr", "0.0.0.0", "The address to listen to;")
var Eurl = flag.String("eurl", "http://192.168.1.182:9200/", "The port to listen on; ")
var Picurl = flag.String("picurl", "http://58.118.225.79:41242/", "picture url ")
var addr = flag.String("addr", "0.0.0.0", "The address to listen to")
var Eurl = flag.String("eurl", "http://192.168.1.182:9200/", "The port to listen on")
var Picurl = flag.String("picurl", "http://58.118.225.79:41242/", "picture url")

var port = flag.Int("port", 6000, "The port to listen on; ")
var sec = flag.Int("sec", 10, "the second for query data. ")
var port = flag.Int("port", 6000, "The port to listen on")
var sec = flag.Int("sec", 10, "the second for query data")

var Level = flag.String("level","ErrorLevel","log level")
//var ipMap map[string]net.Conn
var IsHub = flag.String("hub", "hub", "hub is personIsHub=1")
var Size = flag.Int("size", 100, "size default is 100")
var env = flag.String("env", "config", "env set")
var mqIp = flag.String("mqIp", "172.17.50.245", "default mq ip")
var mqPort = flag.Int("mqPort", 5672, "default mq port")
var mqUser = flag.String("mqUser", "basic", "default rabbitmq user")
var mqPass = flag.String("mqPass", "basic", "default rabbitmq pass")
var confPath = flag.String("confPath", "/home/basic/Apps/go/AndroidAlarmServer/config/","default config path")

func main() {
   flag.Parse()

   log.SetLogLevel(*Level)

   config.Init(*env, *confPath)
   fmt.Println(*port)
   src := *addr + ":" + strconv.Itoa(*port)
   listener, err := net.Listen("tcp", src)
   //src := *addr + ":" + strconv.Itoa(*port)
   //listener, err := net.Listen("tcp", src)
   //if err != nil {
   //   log.Log.Errorln(err)
   //   return
   //}
   //log.Log.Infof("Listening on %s.\n", src)

   //fmt.Println("starting server success.")
   //defer listener.Close()

   //connArr:=make([]net.Conn,0)

   //for {
   //   conn, err := listener.Accept()//
   //
   //   connArr = append(connArr,conn)
   //   if err != nil {
   //      log.Log.Infoln("some connecion error: ", err)
   //   }
   //   go handleConnection(conn,connArr)
   //}

   mqAddr := "amqp://" + *mqUser + ":" + *mqPass + "@" + *mqIp + ":" + strconv.Itoa(*mqPort)+"/"

   conn, err := amqp.Dial(mqAddr)
   if err != nil {
      log.Log.Errorln(err)
      log.Log.Infof("Failed to connect to RabbitMQ,err:",err)
      return
   }
   log.Log.Infof("Listening on %s.\n", src)
   defer conn.Close()

   fmt.Println("starting server success.")
   defer listener.Close()
   ch, err := conn.Channel()
   if err !=nil {
      log.Log.Infof("Failed to open a channel,err:",err)
      return
   }
   defer ch.Close()

   connArr:=make([]net.Conn,0)
   q, err := ch.QueueDeclare(
      "alarm2Android", // name
      false,   // durable
      false,   // delete when unused
      false,   // exclusive
      false,   // no-wait
      nil,     // arguments
   )
   if err !=nil {
      log.Log.Infof("Failed to declare a queue,err:",err)
      return
   }
   handleAlarmData2MQ(q, ch)
}

   //ipMap = make(map[string]net.Conn,0)
func handleAlarmData2MQ(queue amqp.Queue,ch *amqp.Channel) {
   tick := time.NewTicker(3 * time.Second)
   lastTime := time.Now()
   for {
      conn, err := listener.Accept()//

      //clientIpPort := conn.RemoteAddr().String()
      //index := strings.Index(clientIpPort, ":")
      //ipStr := clientIpPort[:index-1]
      //if oldConn,ok := ipMap[ipStr];ok {
      //   oldConn.Close()
      //}
      //ipMap[ipStr] = conn

      connArr = append(connArr,conn)
      if err != nil {
         log.Log.Infoln("some connecion error: ", err)
      select {
      case <-tick.C:
         curTime := time.Now()
         alarmData := esutil.PostAction(*sec, *Eurl, *Picurl, *IsHub, *Size, lastTime, curTime)
         if alarmData != nil {
            err := ch.Publish(
               "",
               queue.Name,
               false,
               false,
               amqp.Publishing{
                  ContentType: "text/plain",
                  Body: alarmData,
               })
            if err !=nil {
               log.Log.Infof("send to mq err:"+err.Error())
            } else {
               log.Log.Infof("send to mq success,msg:   "+string(alarmData))
            }
         }
         lastTime = curTime
      }
      go handleConnection(conn,connArr)
   }
}

@@ -71,43 +131,38 @@
      ech <- err

   }(conn, ech)
   go func(conArray []net.Conn) {
      for {
         if len(conArray)>50 {
            for _,connEach :=range conArray{
               connEach.Close()
            }
            return
         }
         time.Sleep(200*time.Second)
      }
   }(connArr)
   tick := time.NewTicker(10 * time.Second)

   tick := time.NewTicker(3 * time.Second)
   lastTime := time.Now()
   for {
      select {
      case <-tick.C:
         if !handleMessage(conn, connArr){
         curTime := time.Now()
         if !handleMessage(conn, connArr, lastTime, curTime){
            conn.Close()
            return
         }
         lastTime = curTime
      case err := <-ech:
         log.Log.Infoln(err, "remoteAddr ", remoteAddr, " close")
         conn.Close()
         return
      }

   }

   log.Log.Infoln("Client at " + remoteAddr + " disconnected.")
}

func handleMessage(conn net.Conn, connArr []net.Conn) bool {
   jsonstring := esutil.PostAction(*sec, *Eurl, *Picurl)
func handleMessage(conn net.Conn, connArr []net.Conn,lastT time.Time, curTime time.Time) bool {
   jsonstring := esutil.PostAction(*sec, *Eurl, *Picurl, *IsHub, *Size, lastT, curTime)
   if jsonstring == nil {
      log.Log.Infoln("the data is nil,remoteArr:",conn.RemoteAddr())
      conn.Write([]byte("\000"))
      return true
      if _, err := conn.Write([]byte("\000"));err !=nil {
         log.Log.Infoln("conn.WriteErr:",err)
         return false
      } else {
         return true
      }
   }
   jsonstring = append(jsonstring, []byte("\000")...)
   log.Log.Infoln("jsonstring len: ", len(jsonstring), "\000 data: ", len("\000"))