func (s *ServerApp) Run(exit chan interface{}) {
go manners.ListenAndServe(fmt.Sprintf(":%s", s.Port), s.Mux)
<-exit
manners.Close()
}
// main is the entry point for the application.
func main() {
log.Println("main : Started")
// Check the environment for a configured port value.
port := os.Getenv("PORT")
if port == "" {
port = "3000"
}
// Create this goroutine to run the web server.
go func() {
log.Println("listener : Started : Listening on: http://localhost:" + port)
manners.ListenAndServe(":"+port, routes.API())
}()
// Listen for an interrupt signal from the OS.
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, os.Interrupt)
<-sigChan
log.Println("main : Shutting down...")
manners.Close()
log.Println("main : Completed")
}
func StopServer() {
l4g.Info("Stopping Server...")
manners.Close()
Srv.Store.Close()
hub.Stop()
l4g.Info("Server stopped")
}
func StopServer() {
l4g.Info(utils.T("api.server.stop_server.stopping.info"))
manners.Close()
Srv.Store.Close()
hub.Stop()
l4g.Info(utils.T("api.server.stop_server.stopped.info"))
}
func runServerWithGui(chain *nigella.Nigella) {
var wg sync.WaitGroup
listener, err := net.Listen("tcp", `127.0.0.1:0`)
if err != nil {
log.Fatalf("ERROR: %s", err.Error())
return
}
port := listener.Addr().(*net.TCPAddr).Port
portAsString := strconv.Itoa(port)
log.Infof("Server Listing on http://localhost:%s ", portAsString)
ServerFunc := func() {
defer wg.Done()
log.Info("Running Server")
manners.Serve(listener, chain)
}
//===== start the GUI ===========
GuiFunc := func() {
defer wg.Done()
time.Sleep(1 * time.Second)
var exeRoot string
var err error
exeRoot, err = osext.ExecutableFolder()
if err != nil {
log.Fatalf("ERROR: %s", err.Error())
} else {
log.Info("EXE Root: " + exeRoot)
}
ClientFilePath := filepath.Join(exeRoot, `client`, `Malkovich Client.exe`)
ClientCmd := exec.Command(ClientFilePath, portAsString)
err = ClientCmd.Run()
if err != nil {
log.Fatal(err)
}
manners.Close()
}
wg.Add(1)
wg.Add(1)
go ServerFunc()
go GuiFunc()
wg.Wait()
log.Info("Everything has finished.")
}
//Stop stops GohanAPIServer
func (server *Server) Stop() {
server.running = false
if server.sync != nil {
stopSyncProcess(server)
stopStateUpdatingProcess(server)
stopSyncWatchProcess(server)
}
stopAMQPProcess(server)
stopSNMPProcess(server)
stopCRONProcess(server)
manners.Close()
server.queue.Stop()
}
func cant_take_it_anymore(max int) {
pingTicker := time.NewTicker(1 * time.Second)
defer func() {
pingTicker.Stop()
}()
for {
select {
case <-pingTicker.C:
if atomic.LoadUint64(&ops) >= uint64(max) {
manners.Close()
}
}
}
}
func (srv *server) ListenAndServe() error {
l, err := srv.newListener()
if err != nil {
return err
}
go func() {
sigchan := make(chan os.Signal, 1)
signal.Notify(sigchan, srv.sigs...)
<-sigchan
log.Println("Shutting down...")
manners.Close()
}()
log.Println("listen and server on " + srv.m.Addr)
return srv.m.Serve(l)
}
func main() {
var err error
// Connect to the local nats server.
rawConn, err = nats.Connect(nats.DefaultURL)
if err != nil {
log.Println("ERROR: Unable to connect to NATS")
return
}
// Create an encoded connection
conn, err = nats.NewEncodedConn(rawConn, nats.JSON_ENCODER)
if err != nil {
log.Println("ERROR: Unable to create an encoded connection")
return
}
// Support for shutting down cleanly.
go func() {
// Listen for an interrupt signal from the OS.
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, os.Interrupt)
<-sigChan
log.Println("Starting shutdown...")
log.Println("Waiting on requests to complete...")
// We have been asked to shutdown the server.
manners.Close()
}()
// Bind routes.
http.HandleFunc("/users", GetUsers)
// Start the web service.
const host = "localhost:8080"
log.Printf("Listening on: %s\n", host)
manners.ListenAndServe(host, http.DefaultServeMux)
// Close the connection to the NATS server.
log.Println("Waiting on NATS to close...")
conn.Close()
}
func waitShutdown(app application.Application) {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
fmt.Println()
log.Info.Pf("gracefully shutting down")
log.Info.Pf("stopping http listener")
manners.Close()
log.Info.Pf("http listener stopped")
app.Cleanup()
log.Info.Pf("shutdown finished")
os.Exit(1)
}()
}
// Stop stops the registered service matching the given prefix key.
//
func (s *Srv) Stop(key string) error {
app, ok := s.list[key]
if !ok {
return errors.New("stop webservice: key not found")
}
if !app.started {
return nil
}
app.started = false
started := false
for _, v := range s.list {
started = started || v.started
}
if !started {
manners.Close()
}
return nil
}
func (m *MxpSink) Start(sigs <-chan bool, done chan<- bool) {
log.Printf("* Starting MxpSink on port %d", m.Port)
r := mux.NewRouter().StrictSlash(false)
r.HandleFunc("/", m.rootHandler).Methods("GET")
r.HandleFunc("/track", m.trackGetHandler).Methods("GET")
r.HandleFunc("/track", m.trackPostHandler).Methods("POST")
r.HandleFunc("/import", m.importGetHandler).Methods("GET")
r.HandleFunc("/import", m.importPostHandler).Methods("POST")
incomingBeaconKiller := make(chan bool)
incomingBeaconStopped := make(chan bool)
incomingAliasKiller := make(chan bool)
incomingAliasStopped := make(chan bool)
go m.incomingBeaconConsumer(incomingBeaconKiller, incomingBeaconStopped)
go m.incomingAliasConsumer(incomingAliasKiller, incomingAliasStopped)
go func() {
sig := <-sigs
log.Println("Stopping MxpSink", sig)
incomingBeaconKiller <- true
incomingAliasKiller <- true
manners.Close()
}()
if err := manners.ListenAndServe(fmt.Sprintf(":%d", m.Port), r); err != nil {
log.Fatal(err)
}
<-incomingAliasStopped
<-incomingBeaconStopped
done <- true
}
func run() error {
signalChan := make(chan os.Signal)
signal.Notify(signalChan, syscall.SIGTERM)
go func() {
for {
s := <-signalChan
if s == syscall.SIGTERM {
manners.Close()
}
}
}()
listeners, err := listener.ListenAll()
if err != nil {
return err
}
var l net.Listener
if len(listeners) > 0 {
l = listeners[0]
} else {
l, err = net.Listen("tcp", ":13000")
if err != nil {
return err
}
}
mux := http.NewServeMux()
entries := []struct {
Path string
Source scraper.Source
}{
{"/character-show", scraper.NewCharacterShowSource()},
{"/fukoku-life", scraper.NewFukokuLifeEventSource()},
{"/harmonyland-info", scraper.NewHarmonylandInfoSource()},
{"/kittychan-info", scraper.NewKittychanInfoSource()},
{"/memoirs-of-shibasaki-saki", scraper.NewMemoirsOfShibasakiSakiSource()},
{"/prtimes-sanrio", scraper.NewPRTimesSource()},
{"/puroland-info", scraper.NewPurolandInfoSource()},
{"/sanrio-news-release", scraper.NewSanrioNewsReleaseSource()},
{"/seibuen-event", scraper.NewSeibuenEventSource()},
{"/value-press-sanrio", scraper.NewValuePressSource()},
}
for _, entry := range entries {
mux.HandleFunc(entry.Path, sourceRenderer(entry.Source))
}
mux.HandleFunc("/facebook", func(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
id := query.Get("id")
if id == "" {
w.WriteHeader(http.StatusNotFound)
return
}
source := scraper.NewFacebookSource(id)
feed, err := source.Scrape()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
renderFeed(w, feed)
})
mux.HandleFunc("/google-calendar", func(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
id := query.Get("id")
if id == "" {
w.WriteHeader(http.StatusNotFound)
return
}
source := scraper.NewGoogleCalendarSource(id)
feed, err := source.Scrape()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
renderFeed(w, feed)
})
mux.HandleFunc("/instagram", func(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
id := query.Get("id")
if id == "" {
w.WriteHeader(http.StatusNotFound)
return
}
source := scraper.NewInstagramSource(id)
feed, err := source.Scrape()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
renderFeed(w, feed)
})
mux.HandleFunc("/twitter", func(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
idStr := query.Get("id")
if idStr == "" {
w.WriteHeader(http.StatusNotFound)
return
}
id, err := strconv.ParseInt(idStr, 10, 64)
if err != nil {
w.WriteHeader(http.StatusNotFound)
return
}
source := scraper.NewTwitterSource(id)
feed, err := source.Scrape()
if err != nil {
log.Println(err)
w.WriteHeader(http.StatusServiceUnavailable)
return
}
renderFeed(w, feed)
})
manners.Serve(l, mux)
return nil
}
//Stop gracefully stops the API and the callback listener
func (c2b *C2B) Stop() {
server.Close()
c2b.callback <- nil
fmt.Println("C2B stopped")
}
// Stop stops the http server api
func (cli *HTTPAPIServer) Stop() {
logrus.Infof("Plugin: httpapi: requesting shutdown")
manners.Close()
}
func listenForShutdown(shutdown <-chan struct{}) {
log.Println("http.graceful.await")
<-shutdown
log.Println("http.graceful.shutdown")
manners.Close()
}
func listenForShutdown(ch <-chan os.Signal) {
<-ch
manners.Close()
}
// Intended to be run as a goroutine.
func StopSoon(t time.Duration, done chan bool) {
time.Sleep(t * time.Second)
manners.Close()
done <- true
}
func Stop() {
LogInfo("Stopping Server...")
manners.Close()
}