quota_mongodb/producer.go

// iterator
package main

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/garyburd/redigo/redis"
)

type userQuota struct {
	user     string
	storage  int
	messages int
}

type produced struct {
	user   string
	logins []string
}

func producer() {
	conn := dbs.rdb.Get()
	defer conn.Close()

	val := "0"

	loop := true

	start := time.Now()
	users := make(map[string]bool)
	for loop {

		status = _Producer

		retval, err := redis.Values(conn.Do("SCAN", val, "COUNT", strconv.Itoa(opts.MaxBulk)))

		keys, _ := redis.Strings(retval[1], err)

		for _, key := range keys {
			user := key[:strings.Index(key, "@")]
			users[user] = true
		}

		val, _ = redis.String(retval[0], err)

		if opts.Debug {
			fmt.Println(val, len(users))
		}

		if val == "0" {
			loop = false
		}
	}

	if opts.Debug {
		fmt.Printf("\nKEYS: %+v\n", time.Since(start))
	}

	max := 0
	block := make([]string, 0)
	for user, _ := range users {
		block = append(block, user)
		if max >= opts.MaxBulk {
			wg.Add(1)
			mget_chan <- block
			max = 0
			block = make([]string, 0)
			continue
		}
		max += 1
	}

	done <- true
}

/*

	keys, err := redis.Strings(conn.Do("KEYS", "*"))

	if err != nil {
		if opts.Debug {
			fmt.Printf("Keys error: %v\n", err)
		}
		log.Printf("Keys error: %v\n", err)
		exit()
	}

	users := make(map[string]bool)

	for _, key := range keys {
		user := key[:strings.Index(key, "@")]
		users[user] = true
	}

	uq := make([]userQuota, 0)
	max := 0

	for key, _ := range users {

		if !loop {
			break
		}

		//		wg.Wait()
		status = _Producer

		start := time.Now()
		if opts.Test {
			fmt.Printf("MGET: %s (%d)\n", key, max)
		}
		// estrae un userid dalla lista degli utenti che hanno fatto login
		quota, err := redis.Strings(conn.Do("mget", fmt.Sprintf("%s@tiscali.it/quota/messages", key), fmt.Sprintf("%s@tiscali.it/quota/storage", key)))
		// se non ci sono piu' userid esce
		if err != nil {
			if opts.Debug {
				fmt.Printf("MGET err: %v\n", err)
			}
			log.Printf("MGET err: %v\n", err)
			continue
		}

		counter <- Counterchan{
			tipo: "user",
			val:  1,
		}

		msg, err := strconv.Atoi(quota[0])
		if err != nil {
			msg = 0
		}
		store, err := strconv.Atoi(quota[1])
		if err != nil {
			store = 0
		}

		uq = append(uq, userQuota{
			user:     key,
			messages: msg,
			storage:  store,
		})

		if opts.Test {
			fmt.Printf("User: %s - %+v\n", key, quota)
		}

		if max >= opts.MaxBulk {
			if opts.Debug {
				fmt.Printf("\nPROD: %+v\n", time.Since(start))
			}

			//			wg.Add(1)
			//			counter <- Counterchan{
			//				tipo: "wg",
			//				val:  1,
			//			}

			consume <- uq
			uq = make([]userQuota, 0)
			max = 0
		}

		max += 1
	}

	done <- true
*/