store multiple values in maps

problem: Store both an IP address as well as a time to a counter. something like this

ip, time, count

and then i would like to be able to increment the count for each ip:

ip++

in my map, and then on a given interval, i would like to iterate all keys and find the keys with a time stamp older than N minutes.

I need this to make sure i don't "forget" a key in memory if for some reason, client disconnect and i dont delete the key properly.

http://play.golang.org/p/RiWWOCARq7

Question: How do i add a time stamp to every IP address i store in my map. Also i need this be be used across multiple go routines

Im new to both programming and Golang, so if this is not even the correct approach, if anyone could point me in the right direction, i would appreciate it.

For example,

package main

import (
	"sync"
	"time"
)

type IPCounter struct {
	IPAddr string
	Time   time.Time
	Count  int
}

type ipCounterMap struct {
	counters map[string]IPCounter
	mutex    sync.RWMutex
}

var ipCounters = ipCounterMap{counters: make(map[string]IPCounter)}

// Get IP address counter
func Counter(ipAddr string) IPCounter {
	ipCounters.mutex.RLock()
	defer ipCounters.mutex.RUnlock()
	counter, found := ipCounters.counters[ipAddr]
	if !found {
		counter.IPAddr = ipAddr
	}
	return counter
}

// Increment IP address counter
func Incr(ipAddr string) {
	now := time.Now().UTC()
	ipCounters.mutex.Lock()
	defer ipCounters.mutex.Unlock()
	counter, found := ipCounters.counters[ipAddr]
	if !found {
		counter.IPAddr = ipAddr
	}
	counter.Time = now
	counter.Count++
	ipCounters.counters[ipAddr] = counter
}

// Delete IP address counter
func Delete(ipAddr string) {
	ipCounters.mutex.Lock()
	defer ipCounters.mutex.Unlock()
	delete(ipCounters.counters, ipAddr)
}

// Get old IP address counters old durations ago
func OldIPCounters(old time.Duration) []IPCounter {
	var counters []IPCounter
	oldTime := time.Now().UTC().Add(-old)
	ipCounters.mutex.RLock()
	defer ipCounters.mutex.RUnlock()
	for _, counter := range ipCounters.counters {
		if counter.Time.Before(oldTime) {
			counters = append(counters, counter)
		}
	}
	return counters
}

func main() {}

You probably want a map of ip -> struct { ip, counter, lastTime }
that way, you can look up the counter by ip and then update it

var Counters = map[string]*Counter{}

type Counter struct {
	ip       string
	count    int
	lastTime time.Time
}

Here's a working example on Play http://play.golang.org/p/TlCTc_4iq5

Adding the find older than is simply range over the values of the map comparing to now and do something when it's old enough.

It sounds like you need a struct. A map is for storing a collection where all the keys are of one type and all the elements are of another (or the same type).

For grouping a collection of variables of different data types, that are related, use a struct

e.g.

type IPCounter struct {
    ip    string
    time  time.Time
    count int
}

Here's some sample code that creates one of these objects and increments the count:

package main

import (
	"fmt"
	"time"
)

type IPAddressCounter struct {
	ip    string
	time  time.Time
	count int
}

func (i *IPAddressCounter) IncrementCount() {
	i.count++
}

func makeCounter(ip string) IPAddressCounter {
	return IPAddressCounter{
		ip:   ip,
		time: time.Now(),
	}
}

func main() {
	mapOfIPCounters := make(map[string]IPAddressCounter)

	mapOfIPCounters["192.168.1.1"] = makeCounter("192.168.1.1")
	mapOfIPCounters["192.168.1.2"] = makeCounter("192.168.1.2")
	mapOfIPCounters["192.168.1.3"] = makeCounter("192.168.1.3")

	for key, value := range mapOfIPCounters {
		value.IncrementCount()
		mapOfIPCounters[key] = value
		
		fmt.Println("The counter for "+key+" is", mapOfIPCounters[key].count)
	}

}