llmongodb/llmongo.go

// llmongo.go
package main

import (
	"github.com/fzzy/radix/redis"
//	"github.com/garyburd/redigo/redis"
	"flag"
	"fmt"
	"os"
    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"	
	"time"
	"strings"
	"strconv"
)

type Options struct {
	MongoUri    string
	RedisUri    string
	rdb			*redis.Client
	mdb			*mgo.Session
	ll			*mgo.Collection
}

type MongoLogin struct {
	User 		string		`json:"user"`
	Protocol		string		`json:"protocol"`
	Ip			string		`json:"ip"`
	Date			time.Time	`json:"date"`
}

var (
	opts = Options{
//		MongoUri: "mongodb://127.0.0.1:27018",
		MongoUri: "mongodb://10.39.81.85:27018",
		RedisUri: "127.0.0.1:6379",
//		RedisUri: "redis-ll.mail.tiscali.sys:6379",
	}
)

func usage() {
	fmt.Println("Usage: llmongo -m <mongo uri> -r <redis uri>\n")
	os.Exit(0)
}

func init() {
	flag.StringVar(&opts.MongoUri, "m", opts.MongoUri, "Mongodb")
	flag.StringVar(&opts.RedisUri, "r", opts.RedisUri, "Redis")
}

func connectRedis() {
	var err error
	opts.rdb, err = redis.Dial("tcp", opts.RedisUri)
	if err != nil {
		fmt.Println("Redis connect Error: ", err.Error())
		os.Exit(-1)
	}	
}

func connectMongo() {
	var err error
	opts.mdb, err = mgo.Dial(opts.MongoUri)
	if err != nil {
		fmt.Println("Mongodb connect Error: ", err.Error())
		os.Exit(-3)
	}
	opts.ll = opts.mdb.DB("dovecot").C("lastlogin")
}

func main() {
	flag.Usage = usage
	flag.Parse()	

	fmt.Println(opts)

	connectRedis()
	defer opts.rdb.Close()

	connectMongo()
	defer opts.mdb.Close()


	llindex := opts.rdb.Cmd("smembers", "llindex")
	lista, err := llindex.List()

	for _, user := range lista {	
		for {
			val, err := opts.rdb.Cmd("lindex", user, "-1").Str()
			if err != nil {
				fmt.Println("lindex error: ", err.Error())
				break
			}
			fmt.Println("Val: ", val)
			sval := strings.Split(val, ":")
			date, err := strconv.ParseInt(sval[1], 10, 64)
			if err != nil {
				fmt.Println("Date Error: ", err.Error())
				continue
			}
			ml := MongoLogin{
				User:	user,
				Protocol: sval[0],
				Ip:		sval[2],
				Date:	time.Unix(date, 0),		
			}
			err = opts.ll.Insert(ml)
			if err != nil {
				fmt.Println("Insert error: ", err.Error())
			}		
			retval := opts.rdb.Cmd("lrem", user, "-1", val)
			fmt.Println("lrem retval: ", retval, val)
		}
		llen, _ := opts.rdb.Cmd("llen", user).Int64()
		if llen == 0 {
			retval := opts.rdb.Cmd("srem", "llindex", user)
			fmt.Println("srem retval: ", retval)
		}		
	}

	last := time.Now().Add(-time.Minute*10).UTC()

	retval, err := opts.ll.Find(bson.M{ "date": bson.M{ "$gte": last }}).Count()
	if err != nil {
		fmt.Println("Query error: ", err.Error())
		os.Exit(-4)
	}

	fmt.Println(last, retval)	
}