func Launch(option *options.SysOption) {
signalChannel := make(chan os.Signal, 1)
signal.Notify(signalChannel, os.Interrupt)
signal.Notify(signalChannel, syscall.SIGTERM)
coremethods.Setup()
mustExit := false
stat := statistic.NewStatistic(*option)
manager := coresupport.NewCoreWorkerManager(*option, stat)
server := connectionserver.NewServer(*option, stat)
server.Start(manager)
manager.Start(server)
// wait
for !mustExit {
select {
case newSig := <-signalChannel:
{
if newSig != nil {
rllogger.Output(rllogger.LogInfo, "Stoping service, now wait..")
server.Stop()
manager.Stop()
}
}
case <-manager.OutSignalChannel:
{
rllogger.Output(rllogger.LogInfo, "Close manager.")
mustExit = true
}
}
}
manager.Close()
stat.Close()
close(signalChannel)
}
func statProcessing(stat *Statistic) {
timer := time.NewTicker(time.Duration((*stat).iterTime) * time.Second)
out := func() {
rllogger.Output(rllogger.LogInfo, "Statistic closing...")
timer.Stop()
close((*stat).closeChan)
close((*stat).messages)
}
defer out()
for (*stat).active {
select {
case msg := <-(*stat).messages:
{
stat.add(&msg)
}
case <-(*stat).closeChan:
{
stat.stop()
}
case now := <-timer.C:
{
(*stat).lastSendTime = now
stat.calc()
stat.SendResult()
}
}
}
}
func (server RlServer) Run() {
server.SetActive(true)
msgToCoreBuffer := make(chan protocol.CoreMsg, server.option.BufferSize)
statistic := NewRlStatistic()
statistic.Run(&server)
answerDispatcher := NewAnswerDispatcher()
serverBusyAccounting := helpers.NewServerBusyAccounting()
serverMethods := helpers.NewServerMethods()
go upConnection(&server, &msgToCoreBuffer, answerDispatcher, statistic)
//connectionSupport := connectionsupport.NewConnectionAccounting()
// TODO: use it
//connectionSupport.Dec()
for index := 1; index < server.option.Workers+1; index++ {
go coreWorker(
index,
&server,
&msgToCoreBuffer,
answerDispatcher,
serverBusyAccounting,
serverMethods,
statistic)
}
// status service
go serviceBroadcasting(&server, answerDispatcher)
// wait sigterm
signalChannel := make(chan os.Signal, 1)
signal.Notify(signalChannel, os.Interrupt)
signal.Notify(signalChannel, syscall.SIGTERM)
for server.IsActive() {
newSig := <-signalChannel
if newSig != nil {
server.SetActive(false)
}
}
rllogger.Output(rllogger.LogInfo, "stoping server, wait...")
answerDispatcher.CloseAll()
close(signalChannel)
for server.HasConnection() {
rllogger.Output(rllogger.LogInfo, "wait closing client connection.")
time.Sleep(1 * time.Second)
}
close(msgToCoreBuffer)
statistic.Finish()
}
func NewServerCreate(optionSrc options.OptionLoder) *RlServer {
option, err := optionSrc.Load(true)
if err != nil {
rllogger.Outputf(rllogger.LogTerminate, "Option load failed: %s", err)
}
server := RlServer{
option: *option,
changeCountLock: new(sync.RWMutex),
CoroutineActiveResource: *(helpers.NewCoroutineActiveResource())}
rllogger.Output(rllogger.LogInfo, server.info())
return &server
}
func (mng *CoreWorkerManager) Stop() {
manager := *mng
count := manager.options.Workers
for index := 0; index < count; index++ {
manager.workerStopSignalChannel <- true
}
rllogger.Output(rllogger.LogInfo, "Stoping workers..")
close(manager.instructionsChannel)
close(manager.workerStopSignalChannel)
for _, groupPtr := range manager.outChannels {
if groupPtr != nil {
groupPtr.SendExit()
}
}
manager.OutSignalChannel <- true
}
func (dict *MethodInstructionDict) check() {
if len((*dict).content) <= 0 {
// use once instance only!
rllogger.Output(rllogger.LogTerminate, "Use NewMethodInstructionDict()")
}
}
func (server *ConnectionServer) Stop() {
server.SetStatus(ServerStatusOff)
rllogger.Output(rllogger.LogInfo, "Connection server stopping..")
}