Пример #1
0
func (self RedisDB) GetPost(messageID string) (*model.Post, error) {
	var p model.Post
	cmd := self.client.HGetAll(ARTICLE_POST_PREFIX + messageID)
	hashres, err := cmd.Result()
	if err == nil {
		mapRes := processHashResult(hashres)
		p.Board = mapRes["newsgroup"]
		p.Message_id = mapRes["message_id"]
		p.Parent = mapRes["ref_id"]
		p.PostName = mapRes["name"]
		p.PostSubject = mapRes["subject"]
		p.MessagePath = mapRes["path"]
		tmp, _ := strconv.Atoi(mapRes["time_posted"])
		p.Posted = int64(tmp)
		p.Addr = mapRes["addr"]
		p.PostMessage = mapRes["message"]

		p.OP = len(p.Parent) == 0
		if len(p.Parent) == 0 {
			p.Parent = p.Message_id
		}
		p.Sage = util.IsSage(p.PostSubject)
		atts, err := self.GetPostAttachments(messageID)
		if atts != nil {
			p.Files = append(p.Files, atts...)
		}
		// quiet fail
		p.Key, _ = self.client.Get(ARTICLE_KEY_PREFIX + messageID).Result()
		return &p, err
	}
	return &p, err
}
Пример #2
0
// register a message with the database
func (self RedisDB) RegisterArticle(message *model.Article) (err error) {
	pipe := self.client.Pipeline()
	defer pipe.Close()

	msgid := message.MessageID
	group := message.Newsgroup

	has, _ := self.HasNewsgroup(group)
	if !has {
		self.RegisterNewsgroup(group)
	}
	has, _ = self.HasArticle(msgid)
	if has {
		return
	}

	//insert IP

	addr := message.Addr
	ip := net.ParseIP(addr)

	if ip != nil {
		addr = util.ZeroIPString(ip)
		pipe.ZAddNX(IP_RANGE_BAN_KR, redis.Z{Score: 0.0, Member: addr})
	}
	pipe.SAdd(IP_ARTICLE_KR_PREFIX+addr, msgid)

	now := util.TimeNow()

	// insert article metadata
	pipe.HMSet(ARTICLE_PREFIX+msgid, "msgid", msgid, "message_id_hash", util.HashMessageID(msgid), "message_newsgroup", group, "time_obtained", strconv.Itoa(int(now)), "message_ref_id", message.Reference)
	pipe.Set(HASH_MESSAGEID_PREFIX+util.HashMessageID(msgid), msgid, 0)

	// update newsgroup
	pipe.ZAddXX(GROUP_POSTTIME_WKR, redis.Z{Score: float64(now), Member: group})
	pipe.ZAddNX(GROUP_ARTICLE_POSTTIME_WKR_PREFIX+group, redis.Z{Score: float64(now), Member: msgid})

	// insert article post
	pipe.HMSet(ARTICLE_POST_PREFIX+msgid, "newsgroup", group, "message_id", msgid, "ref_id", message.Reference, "name", message.Name, "subject", message.Subject, "path", message.Path, "time_posted", strconv.Itoa(int(message.Posted)), "message", message.Text, "addr", addr)

	if group != "ctl" { // control messages aren't added to the global keyring
		pipe.ZAddNX(ARTICLE_WKR, redis.Z{Score: float64(now), Member: msgid})
	}

	// set / update thread state
	if message.Reference == "" {
		// insert new thread for op
		pipe.ZAddNX(GROUP_THREAD_POSTTIME_WKR_PREFIX+group, redis.Z{Score: float64(message.Posted), Member: msgid})
		pipe.ZAddNX(GROUP_THREAD_BUMPTIME_WKR_PREFIX+group, redis.Z{Score: float64(message.Posted), Member: msgid})
		if group != "ctl" {
			pipe.ZAddNX(THREAD_BUMPTIME_WKR, redis.Z{Score: float64(message.Posted), Member: msgid})
		}

	} else {
		ref := message.Reference
		if !util.IsSage(message.Subject) {
			// bump it nigguh
			pipe.ZAddXX(GROUP_THREAD_BUMPTIME_WKR_PREFIX+group, redis.Z{Score: float64(message.Posted), Member: ref})
			pipe.ZAddXX(THREAD_BUMPTIME_WKR, redis.Z{Score: float64(message.Posted), Member: ref})
		}
		// update last posted
		pipe.ZAddXX(GROUP_THREAD_POSTTIME_WKR_PREFIX+group, redis.Z{Score: float64(message.Posted), Member: ref})
		pipe.ZAddNX(THREAD_POST_WKR+ref, redis.Z{Score: float64(message.Posted), Member: msgid})
	}
	// register article header
	for k, val := range message.Header {
		k = strings.ToLower(k)
		for _, v := range val {
			k = strings.ToLower(k)
			header := "Name::" + k + "::Value::" + v
			pipe.SAdd(HEADER_KR_PREFIX+header, msgid)
			pipe.SAdd(MESSAGEID_HEADER_KR_PREFIX+msgid, header)
		}
	}
	// add nntp message numbers
	number, _ := self.client.ZIncrBy(ARTICLE_NUMBERS_PREFIX+"last", float64(1), group).Result()
	pipe.ZAddNX(ARTICLE_NUMBERS_PREFIX+"group::"+group, redis.Z{Score: number, Member: msgid})

	// register all attachments
	atts := message.Attachments
	if atts != nil {
		for _, att := range atts {
			hash := att.Hash
			pipe.SAdd(ATTACHMENT_ARTICLE_KR_PREFIX+hash, msgid)
			pipe.SAdd(ARTICLE_ATTACHMENT_KR_PREFIX+msgid, hash)
			pipe.HSetNX(ATTACHMENT_PREFIX+hash, "message_id", msgid)
			pipe.HSetNX(ATTACHMENT_PREFIX+hash, "sha_hash", hash)
			pipe.HSetNX(ATTACHMENT_PREFIX+hash, "filename", att.Name)
			pipe.HSetNX(ATTACHMENT_PREFIX+hash, "filepath", att.Path)
			pipe.HSetNX(ATTACHMENT_PREFIX+hash, "mime", att.Mime)
		}
	}

	_, err = pipe.Exec()
	if err != nil {
		log.Println("failed to register nntp article", err)
	}
	return
}