func (server *Server) getStats(writer http.ResponseWriter, request *http.Request) *statsResponse {
	sourceSet := set.New(set.ThreadSafe)
	metricSet := set.New(set.ThreadSafe)

	for _, origin := range server.Catalog.GetOrigins() {
		for _, source := range origin.GetSources() {
			sourceSet.Add(source.Name)

			for _, metric := range source.GetMetrics() {
				metricSet.Add(metric.Name)
			}
		}
	}

	sourceGroupsCount := 0
	metricGroupsCount := 0

	for _, group := range server.Library.Groups {
		if group.Type == library.LibraryItemSourceGroup {
			sourceGroupsCount++
		} else {
			metricGroupsCount++
		}
	}

	return &statsResponse{
		Origins:      len(server.Catalog.GetOrigins()),
		Sources:      sourceSet.Size(),
		Metrics:      metricSet.Size(),
		Graphs:       len(server.Library.Graphs),
		Collections:  len(server.Library.Collections),
		SourceGroups: sourceGroupsCount,
		MetricGroups: metricGroupsCount,
	}
}

func (server *Server) serveMetricList(writer http.ResponseWriter, request *http.Request) {
	var offset, limit int

	if response, status := server.parseListRequest(writer, request, &offset, &limit); status != http.StatusOK {
		server.serveResponse(writer, response, status)
		return
	}

	originName := request.FormValue("origin")
	sourceName := request.FormValue("source")

	sourceSet := set.New(set.ThreadSafe)

	if strings.HasPrefix(sourceName, library.LibraryGroupPrefix) {
		for _, entryName := range server.Library.ExpandSourceGroup(
			strings.TrimPrefix(sourceName, library.LibraryGroupPrefix),
		) {
			sourceSet.Add(entryName)
		}
	} else if sourceName != "" {
		sourceSet.Add(sourceName)
	}

	metricSet := set.New(set.ThreadSafe)

	for _, origin := range server.Catalog.GetOrigins() {
		if originName != "" && origin.Name != originName {
			continue
		}

		for _, source := range origin.GetSources() {
			if sourceName != "" && sourceSet.IsEmpty() || !sourceSet.IsEmpty() && !sourceSet.Has(source.Name) {
				continue
			}

			for _, metric := range source.GetMetrics() {
				if request.FormValue("filter") != "" && !utils.FilterMatch(request.FormValue("filter"), metric.Name) {
					continue
				}

				metricSet.Add(metric.Name)
			}
		}
	}

	response := &listResponse{
		list:   StringListResponse(set.StringSlice(metricSet)),
		offset: offset,
		limit:  limit,
	}

	server.applyResponseLimit(writer, request, response)

	server.serveResponse(writer, response.list, http.StatusOK)
}

// toSet converts a slice of strings into a set
func toSet(s []string) set.Interface {
	if s == nil {
		return set.New(set.NonThreadSafe)
	}
	is := make([]interface{}, len(s))
	for i, s := range s {
		is[i] = s
	}
	set := set.New(set.NonThreadSafe)
	set.Add(is...)
	return set
}

func LoadConf() {
	var err error
	conf, err = yaml.ReadFile("botconf.yaml")
	if err != nil {
		log.Panic(err)
	}
	Categories = List2SliceInConf("catagoris")
	CategoriesSet = set.New(set.NonThreadSafe)
	Groups = []Group{}
	for _, v := range Categories {
		CategoriesSet.Add(v)
		for _, i := range List2SliceInConf(v) {
			reg := regexp.MustCompile("^(.+) (http(s)?://(.*))$")
			strs := reg.FindAllStringSubmatch(i, -1)
			if !reg.MatchString(i) {
				Groups = append(Groups,
					Group{GroupName: i,
						GroupURL: ""})
			}
			if len(strs) > 0 {
				Groups = append(Groups,
					Group{GroupName: strs[0][1],
						GroupURL: strs[0][2]})
			}
		}
	}
}

func (server *Server) serveOriginList(writer http.ResponseWriter, request *http.Request) {
	var offset, limit int

	if response, status := server.parseListRequest(writer, request, &offset, &limit); status != http.StatusOK {
		server.serveResponse(writer, response, status)
		return
	}

	originSet := set.New(set.ThreadSafe)
	for _, origin := range server.Catalog.GetOrigins() {
		if request.FormValue("filter") == "" || utils.FilterMatch(request.FormValue("filter"), origin.Name) {
			originSet.Add(origin.Name)
		}
	}

	response := &listResponse{
		list:   StringListResponse(set.StringSlice(originSet)),
		offset: offset,
		limit:  limit,
	}

	server.applyResponseLimit(writer, request, response)

	server.serveResponse(writer, response.list, http.StatusOK)
}

func (server *Server) serveSource(writer http.ResponseWriter, request *http.Request) {
	name := routeTrimPrefix(request.URL.Path, urlCatalogPath+"sources")

	if name == "" {
		server.serveSourceList(writer, request)
		return
	} else if response, status := server.parseShowRequest(writer, request); status != http.StatusOK {
		server.serveResponse(writer, response, status)
		return
	}

	originSet := set.New(set.ThreadSafe)
	for _, origin := range server.Catalog.GetOrigins() {
		if origin.SourceExists(name) {
			originSet.Add(origin.Name)
		}
	}

	if originSet.Size() == 0 {
		server.serveResponse(writer, serverResponse{mesgResourceNotFound}, http.StatusNotFound)
		return
	}

	origins := set.StringSlice(originSet)
	sort.Strings(origins)

	response := SourceResponse{
		Name:    name,
		Origins: origins,
	}

	server.serveResponse(writer, response, http.StatusOK)
}

func init() {
	rc = redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})

	// Init categories
	categories = []string{
		"Linux", "Programming", "Software",
		"影音", "科幻", "ACG", "IT", "社区",
		"闲聊", "资源", "同城", "Others",
	}
	categoriesSet = set.New(set.NonThreadSafe)
	for _, v := range categories {
		categoriesSet.Add(v)
	}

	LoadConf()
	botapi, _ := conf.Get("botapi")
	vimTipsCache, _ := conf.GetInt("vimTipsCache")
	hitokotoCache, _ := conf.GetInt("hitokotoCache")
	vimtips = new(Tips).GetChan(int(vimTipsCache))
	hitokoto = new(Hitokoto).GetChan(int(hitokotoCache))
	sticker = RandSticker(rc)

	var err error
	bot, err = tgbotapi.NewBotAPI(botapi)
	if err != nil {
		log.Panic(err)
	}

	u := tgbotapi.NewUpdate(0)
	u.Timeout = 60
	bot.UpdatesChan(u)
}

func (server *Server) serveMetric(writer http.ResponseWriter, request *http.Request) {
	metricName := routeTrimPrefix(request.URL.Path, urlCatalogPath+"metrics")

	if metricName == "" {
		server.serveMetricList(writer, request)
		return
	} else if response, status := server.parseShowRequest(writer, request); status != http.StatusOK {
		server.serveResponse(writer, response, status)
		return
	}

	originSet := set.New(set.ThreadSafe)
	sourceSet := set.New(set.ThreadSafe)

	for _, origin := range server.Catalog.GetOrigins() {
		for _, source := range origin.GetSources() {
			if source.MetricExists(metricName) {
				originSet.Add(origin.Name)
				sourceSet.Add(source.Name)
			}
		}
	}

	if originSet.Size() == 0 {
		server.serveResponse(writer, serverResponse{mesgResourceNotFound}, http.StatusNotFound)
		return
	}

	origins := set.StringSlice(originSet)
	sort.Strings(origins)

	sources := set.StringSlice(sourceSet)
	sort.Strings(sources)

	response := MetricResponse{
		Name:    metricName,
		Origins: origins,
		Sources: sources,
	}

	server.serveResponse(writer, response, http.StatusOK)
}

func (s *Server) handleAPIHosts(c *gin.Context) {
	hs := set.New(set.ThreadSafe)

	// Get hosts list
	hosts, _ := s.poller.GetHosts()
	for _, h := range hosts {
		hs.Add(h.Name)
	}

	// Get unique set of hosts names
	result := set.StringSlice(hs)
	sort.Strings(result)

	c.Header("Cache-Control", "private, max-age=0")
	c.JSON(http.StatusOK, result)
}

func GetQuestions() []Question {
	var result []Question
	questions := List2SliceInConf("questions")

	for _, v := range questions {
		qs := strings.Split(v, "|")
		question := qs[0]
		answers := strings.Split(qs[1], ";")

		s := set.New(set.ThreadSafe)
		for _, v := range answers {
			s.Add(v)
		}
		result = append(result, Question{question, s})
	}
	return result
}

func GetQuestions(config *yaml.File, text string) []Question {
	var result []Question
	questions := YamlList2Slice(config, text)

	for _, v := range questions {
		qs := strings.Split(v, "|")
		question := qs[0]
		answers := strings.Split(qs[1], ";")

		s := set.New(set.ThreadSafe)
		for _, v := range answers {
			s.Add(v)
		}
		result = append(result, Question{question, s})
	}
	return result
}

func (g *GitHub) GetNotes(owner string, repo string, milestoneID string) (*Note, error) {
	opt := github.IssueListByRepoOptions{Milestone: milestoneID, State: "all"}

	note := &Note{}
	issues, _, err := g.ListByRepo(owner, repo, &opt)
	if err != nil {
		return note, err
	}

	note.Mentioned = set.New(set.NonThreadSafe)
	//var buf bytes.Buffer

	for _, issue := range issues {
		summary := fmt.Sprintf("- %v [%s #%d / %s](%s)\n", issue.Labels, repo, *issue.Number, *issue.Title, *issue.HTMLURL)
		note.IssueSummary += summary

		note.RepoVersion = fmt.Sprintf("- [%s:%s]()\n", repo, *issue.Milestone.Title)

		// TODO: check Mentions
		m := getMensionedPersons(issue.Body)
		if m != "" {
			ids := strings.Split(m, " ")
			// fmt.Println("******** m : ", m)
			// fmt.Println("******** ids : ", ids)

			for i := range ids {
				id := strings.TrimRight(ids[i], ",")
				note.Mentioned.Add(id)
				// fmt.Println("******** id : ", id)
			}
		}

		// TODO 하루 전 날로 나올까? (지금은 +1 해줬다)
		//note.MilestoneDate = fmt.Sprintf("- %s:%s 10:00\n", repo, issue.Milestone.DueOn.Format("2006-01-02"))
		note.MilestoneDate = fmt.Sprintf("- %s:%s 10:00\n", repo, issue.Milestone.DueOn.AddDate(0, 0, 1).Format("2006-01-02"))
		//note.DeployDate = issue.Milestone.DueOn.Format("2006-01-02")
		note.DeployDate = issue.Milestone.DueOn.AddDate(0, 0, 1).Format("2006-01-02")

		//fmt.Println("DeployDate ", note.DeployDate)
	}

	//fmt.Println("after mention:", buf.String())

	return note, nil
}

// TODO: classify by Labels
func main() {
	gitHubURL := baseGitHubURL
	url := os.Getenv("GITHUB_URL")
	if url != "" {
		gitHubURL = url
	}
	clientID := os.Getenv("CLIENT_ID")
	clientSecret := os.Getenv("CLIENT_SECRET")
	owner := os.Getenv("OWNER")
	milestoneID := os.Getenv("MILESTONE_ID")
	repos := os.Getenv("REPOS")

	// check arguments..
	if gitHubURL == "" || owner == "" || milestoneID == "" || repos == "" {
		fmt.Println(getUsage())
		os.Exit(0)
	}

	var note Note
	hub := GitHub{
		apiURL:   gitHubURL,
		user:     clientID,
		password: clientSecret,
	}

	// TODO: magic string
	note.Title = "통합검색 배포 안내드립니다."
	note.Mentioned = set.New(set.NonThreadSafe)

	for _, repo := range strings.Split(repos, ":") {
		n, err := hub.GetNotes(owner, repo, milestoneID)
		if err != nil {
			log.Fatalln("error: %v", err)
		}
		note.Merge(n)
	}

	note.MentionedPersons = fmt.Sprintf("- %v", strings.Trim(note.Mentioned.String(), "[]"))

	t := template.Must(template.New("note").Parse(noteTemplate))
	err := t.Execute(os.Stdout, note)
	if err != nil {
		log.Fatalln("template error:", err)
	}
}

func LoadConf() {
	var err error
	conf, err = yaml.ReadFile("botconf.yaml")
	if err != nil {
		log.Panic(err)
	}
	Categories = List2SliceInConf("catagoris")
	CategoriesSet = set.New(set.NonThreadSafe)
	Groups = []string{}
	for _, v := range Categories {
		CategoriesSet.Add(v)
		for _, i := range List2SliceInConf(v) {
			if i != "\\n" {
				Groups = append(Groups, i)
			}
		}
	}
}

func (s *Server) handleAPIGroups(c *gin.Context) {
	gs := set.New(set.ThreadSafe)

	// Get unique sets of groups names
	hosts, _ := s.poller.GetHosts()
	for _, h := range hosts {
		for _, g := range h.Groups {
			gs.Add(g)
		}

		for _, s := range h.Services {
			for _, g := range s.Groups {
				gs.Add(g)
			}
		}
	}

	result := set.StringSlice(gs)
	natsort.Sort(result)

	c.Header("Cache-Control", "private, max-age=0")
	c.JSON(http.StatusOK, result)
}

// NewPoller returns a new poller instance
func NewPoller(c Config) *Poller {
	p := &Poller{
		config:  c,
		Workers: make([]*Worker, 0),
		wg:      &sync.WaitGroup{},
	}

	logger.Info("poller", "starting poller workers")

	names := set.New(set.ThreadSafe)

	for _, n := range c.Nodes {
		if n.Name == "" {
			logger.Error("poller", "missing mandatory `name' node parameter")
			continue
		} else if n.Address == "" {
			logger.Error("poller", "missing mandatory `remote_addr' node parameter")
			continue
		} else if names.Has(n.Name) {
			logger.Error("poller", "duplicate name `%s' found in node definition", n.Name)
			continue
		}

		w := NewWorker(n, p.wg)

		p.Workers = append(p.Workers, w)
		p.wg.Add(1)

		go w.Start()
		w.Refresh()

		names.Add(n.Name)
	}

	return p
}

func (server *Server) serveSourceList(writer http.ResponseWriter, request *http.Request) {
	var offset, limit int

	if response, status := server.parseListRequest(writer, request, &offset, &limit); status != http.StatusOK {
		server.serveResponse(writer, response, status)
		return
	}

	originName := request.FormValue("origin")

	sourceSet := set.New(set.ThreadSafe)

	for _, origin := range server.Catalog.GetOrigins() {
		if originName != "" && origin.Name != originName {
			continue
		}

		for _, source := range origin.GetSources() {
			if request.FormValue("filter") != "" && !utils.FilterMatch(request.FormValue("filter"), source.Name) {
				continue
			}

			sourceSet.Add(source.Name)
		}
	}

	response := &listResponse{
		list:   StringListResponse(set.StringSlice(sourceSet)),
		offset: offset,
		limit:  limit,
	}

	server.applyResponseLimit(writer, request, response)

	server.serveResponse(writer, response.list, http.StatusOK)
}

func init() {
	var err error
	// Init categories
	categories = []string{
		"Linux", "Programming", "Software",
		"影音", "科幻", "ACG", "IT", "社区",
		"闲聊", "资源", "同城", "Others",
	}
	categoriesSet = set.New(set.NonThreadSafe)
	for _, v := range categories {
		categoriesSet.Add(v)
	}

	loge.Level = logrus.DebugLevel

	LoadConf()
	botapi, _ := conf.Get("botapi")
	redisPass, _ := conf.Get("redisPass")
	vimTipsCache, _ := conf.GetInt("vimTipsCache")
	hitokotoCache, _ := conf.GetInt("hitokotoCache")
	vimtips = new(Tips).GetChan(int(vimTipsCache))
	hitokoto = new(Hitokoto).GetChan(int(hitokotoCache))
	papertrailURL, _ := conf.Get("papertrailUrl")
	papertrailPort, _ := conf.GetInt("papertrailPort")

	rc = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: redisPass,
	})

	sticker = RandSticker(rc)

	//logger
	hook, err := logrus_papertrail.NewPapertrailHook(
		papertrailURL, int(papertrailPort), "nyan")
	if err != nil {
		loge.Println(err)
	} else {
		loge.Hooks.Add(hook)
	}

	//bot init
	bot, err = tgbotapi.NewBotAPI(botapi)
	if err != nil {
		loge.Panic(err)
	}

	if runMode == "debug" {
		hook := tgbotapi.NewWebhook("")
		bot.SetWebhook(hook)
		u := tgbotapi.NewUpdate(0)
		u.Timeout = 60
		bot.UpdatesChan(u)
	} else {
		hook := tgbotapi.NewWebhookWithCert("https://jqs7.com:8443/"+bot.Token, "crt.pem")
		bot.SetWebhook(hook)
		bot.ListenForWebhook("/" + bot.Token)
		go http.ListenAndServeTLS(":8443", "crt.pem", "key.pem", nil)
	}

	initRss()
	MIndex()
	dailySave()
	scheduler.Every().Day().At("00:05").Run(dailySave)
	go GinServer()
}

// Refresh triggers a full connector data update.
func (c *RRDConnector) Refresh(originName string, outputChan chan<- *catalog.Record) error {
	// Search for files and parse their path for source/metric pairs
	walkFunc := func(filePath string, fileInfo os.FileInfo, err error) error {
		var sourceName, metricName string

		// Report errors
		if err != nil {
			logger.Log(logger.LevelWarning, "connector", "rrd[%s]: error while walking: %s", c.name, err)
			return nil
		}

		// Skip non-files
		mode := fileInfo.Mode() & os.ModeType
		if mode != 0 {
			return nil
		}

		// Get pattern matches
		m, err := matchSeriesPattern(c.re, strings.TrimPrefix(filePath, c.path+"/"))
		if err != nil {
			logger.Log(logger.LevelInfo, "connector", "rrd[%s]: file `%s' does not match pattern, ignoring", c.name,
				filePath)
			return nil
		}

		sourceName, metricName = m[0], m[1]

		if _, ok := c.metrics[sourceName]; !ok {
			c.metrics[sourceName] = make(map[string]*rrdMetric)
		}

		// Extract metric information from .rrd file
		info, err := rrd.Info(filePath)
		if err != nil {
			logger.Log(logger.LevelWarning, "connector", "rrd[%s]: %s", c.name, err)
			return nil
		}

		// Extract consolidation functions list
		cfSet := set.New(set.ThreadSafe)

		if cf, ok := info["rra.cf"].([]interface{}); ok {
			for _, entry := range cf {
				if name, ok := entry.(string); ok {
					cfSet.Add(name)
				}
			}
		}

		cfList := set.StringSlice(cfSet)

		if _, ok := info["ds.index"]; ok {
			indexes, ok := info["ds.index"].(map[string]interface{})
			if !ok {
				return nil
			}

			for dsName := range indexes {
				for _, cfName := range cfList {
					metricFullName := metricName + "/" + dsName + "/" + strings.ToLower(cfName)

					c.metrics[sourceName][metricFullName] = &rrdMetric{
						Dataset:  dsName,
						FilePath: filePath,
						Step:     time.Duration(info["step"].(uint)) * time.Second,
						Cf:       cfName,
					}

					outputChan <- &catalog.Record{
						Origin:    originName,
						Source:    sourceName,
						Metric:    metricFullName,
						Connector: c,
					}
				}
			}
		}

		return nil
	}

	if err := utils.WalkDir(c.path, walkFunc); err != nil {
		return err
	}

	return nil
}

func (s *Server) handleAPISearch(c *gin.Context) {
	var hgs, sgs set.Interface

	// Parse search query
	q := searchQuery{}
	if err := c.BindJSON(&q); err != nil {
		fmt.Printf("ERROR: unable to parse JSON data: %s\n", err)
		c.JSON(http.StatusBadRequest, nil)
		return
	}

	// Get groups set
	gs := set.New(set.ThreadSafe)
	for _, g := range q.Groups {
		gs.Add(g)
	}

	// Prepare hosts response
	result := make(searchResponseList, 0)

	hosts, _ := s.poller.GetHosts()
	for _, h := range hosts {
		// Check for node and name filters
		if len(q.Nodes) > 0 && slice.StringIndexOf(q.Nodes, h.Catalog.Worker.Config.Name) == -1 ||
			q.Filter != "" && !strings.Contains(strings.ToLower(h.Name), strings.ToLower(q.Filter)) {
			continue
		}

		// Prepare search response
		sr := searchResponse{
			hostResponse: hostResponse{
				Name:         h.Name,
				State:        h.State,
				StateChanged: h.StateChanged,
				Comments:     make(commentList, 0),
				Links:        h.Links,
			},
			Services: make(serviceResponseList, 0),
		}

		// Fill comments and sort them by date
		for _, c := range h.Comments {
			if c.Type == poller.CommentTypeDowntime {
				// Check for downtimes filter
				if !q.Downtimes {
					goto nextHost
				}

				sr.hostResponse.InDowntime = true
			} else if c.Type == poller.CommentTypeAcknowledgement {
				// Check for acknowledges filter
				if !q.Acknowledges {
					goto nextHost
				}

				sr.hostResponse.Acknowledged = true
			}

			sr.hostResponse.Comments = append(sr.Comments, commentEntry{
				Author:  c.Author,
				Content: c.Content,
				Type:    c.Type,
				Date:    c.Date,
			})
		}

		sort.Sort(sr.Comments)

		// Add extra node information
		if h.Catalog.Worker.Config.Label != "" {
			sr.Node = h.Catalog.Worker.Config.Label
		} else {
			sr.Node = h.Catalog.Worker.Config.Name
		}

		// Prepare set for groups filtering
		if !gs.IsEmpty() {
			hgs = set.New(set.ThreadSafe)
			for _, g := range h.Groups {
				hgs.Add(g)
			}
		}

		// Fill services list
		for _, svc := range h.Services {
			// Check for states filter
			if len(q.States) > 0 && slice.Int64IndexOf(q.States, svc.State) == -1 {
				continue
			}

			// Check for groups filter
			if !gs.IsEmpty() {
				if len(svc.Groups) > 0 {
					sgs = set.New(set.ThreadSafe)
					for _, g := range svc.Groups {
						sgs.Add(g)
					}
				} else {
					sgs = hgs
				}
//.........这里部分代码省略.........