解决方案

Question

我使用MongoDB在存储中保存用户生成的链接。用户可以在过期之前说明他们希望保存URL多长时间。每个用户ID也是唯一的。

理想情况下，我希望我的要求是幂等的。我想拨打尽可能多的电话而不必检查最后一次电话是否有到期值。

我的代码似乎给了我：

＆＃34;索引名称：creationtime_1已经存在，具有不同的选项＆＃34;或
索引不存在。

这是我第一次使用MongoDB运行，我很感激任何见解。我想我的代码也可能有多余的检查，但我无法弄清楚其他方法呢

```

//mongo settings
sessionTTL := mgo.Index{
    Key:         []string{"creationtime"},
    Unique:      false,
    DropDups:    false,
    Background:  true,
    ExpireAfter: time.Hour * time.Duration(expires)} // Expire in expire time

// START MONGODB
session, err := mgo.Dial(tokenMongo)
if err != nil {
    return "", err
}
defer session.Close()
//session.SetSafe(&mgo.Safe{})

// Optional. Switch the session to a monotonic behavior.
id := uuid.NewV4().String()

thistime := time.Now().Local()


// find index
err = session.DB("tokenresults").C("tokenurl").Find(bson.M{"id": id}).One(&result)
if err == nil{
    //Drop old values if exist // cant drop if empty
    if err := session.DB("tokenresults").C("tokenurl").DropIndex("creationtime"); err != nil {
        return "", err
    }
}

//add stuff
c := session.DB("tokenresults").C("tokenurl")
err = c.Insert(&TokenUrl{id, tokenstring, thistime}, )
if err != nil {
    return "", err
}

// create index //add session ttl // cant create if exists
if err := session.DB("tokenresults").C("tokenurl").EnsureIndex(sessionTTL); err != nil {
    return "", err
}

```

Answer 1

解决方案

方法is documented：使用日期字段，将值设置为文档过期的日期，创建一个ExpireAfterSeconds设置为0的TTL索引，MongoDB后台TTL清除过程将删除过期的文件。

注释

然而，使用TTL指数存在一些模糊性。由于每个文档的过程过期，等待过期时间然后删除文档成本太高，MongoDB选择了不同的解决方案。 There is a background process which checks for expired documents once a minute。因此，无法保证您的文档在到期时间内立即过期，并且文档可能存在的时间比设置的到期日期稍长2分钟（由于过载或其他原因而错过第一次运行，并且仅在下一次删除跑）。但请注意，这仅在非常特殊的情况下才会发生。通常，您的文档会在到期后的一分钟内被删除。

解释

我们在这里基本上做的是添加一个字段ExpirationDate并创建一个TTL索引，该索引设置为检查此过期日期。设置ExpirationDate的值完全取决于您。使用工厂模式生成会话或其他任何内容。

请注意，下面的代码中解释了一些注意事项。

package main

import (
    "flag"
    "fmt"
    "log"
    "time"

    mgo "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

const (
    // SESSION_TIMEOUT is a fixed and relatively short
    // timeout for demo purposes
    SESSION_TIMEOUT = 1 * time.Minute
)

// Session is just a sample session struct
// with various session related data and the
// date on which a session should expire.
type Session struct {
    ID             bson.ObjectId `bson:"_id"`
    User           string
    Foo            string
    Bar            string
    ExpirationDate time.Time `bson:"expirationDate"`
}

// NewSession is just a simple helper method to
// return a session with a properly set expiration time
func NewSession(user, foo, bar string) Session {
    // We use a static timeout here.
    // However, you can easily adapt this to use an arbitrary timeout.
    return Session{
        ID:             bson.NewObjectId(),
        User:           user,
        Foo:            foo,
        Bar:            bar,
        ExpirationDate: time.Now().Add(SESSION_TIMEOUT),
    }
}

var (
    mgohost string
    mgoport int
    db      string
    col     string
)

func init() {
    flag.StringVar(&mgohost, "host", "localhost", "MongoDB host")
    flag.IntVar(&mgoport, "port", 27017, "MongoDB port")
    flag.StringVar(&db, "db", "test", "MongoDB database")
    flag.StringVar(&col, "collection", "ttltest", "MongoDB collection")

}

func main() {
    flag.Parse()

    c, err := mgo.Dial(fmt.Sprintf("mongodb://%s:%d/%s", mgohost, mgoport, db))
    if err != nil {
        log.Fatalf("Error connecting to '%s:%d/%s': %s", mgohost, mgoport, db, err)
    }

    // We use a goroutine here in order to make sure
    // that even when EnsureIndex blocks, our program continues
    go func() {
        log.Println("Ensuring sessionTTL index in background")

        // Request a conncetion from the pool
        m := c.DB(db).Session.Copy()
        defer m.Close()

        // We need to set this to 1 as 0 would fail to create the TTL index.
        // See https://github.com/go-mgo/mgo/issues/103 for details
        // This will expire the session within the minute after ExpirationDate.
        //
        // The TTL purging is done once a minute only.
        // See https://docs.mongodb.com/manual/core/index-ttl/#timing-of-the-delete-operation
        // for details
        m.DB(db).C(col).EnsureIndex(mgo.Index{ExpireAfter: 1 * time.Second, Key: []string{"expirationDate"}})

        log.Println("sessionTTL index is ready")
    }()

    s := NewSession("mwmahlberg", "foo", "bar")

    if err := c.DB(db).C(col).Insert(&s); err != nil {
        log.Fatalf("Error inserting %#v into %s.%s: %s", s, db, col, err)
    }

    l := Session{}

    if err := c.DB(db).C(col).Find(nil).One(&l); err != nil {
        log.Fatalf("Could not load session from %s.%s: %s", db, col, err)
    }
    log.Printf("Session with ID %s loaded for user '%s' which will expire in %s", l.ID, l.User, time.Until(l.ExpirationDate))
    time.Sleep(2 * time.Minute)

    // Let's check if the session is still there

    if n, err := c.DB(db).C(col).Count(); err != nil {
        log.Fatalf("Error counting documents in %s.%s: %s", db, col, err)
    } else if n > 1 {
        log.Fatalf("Uups! Someting went wrong!")
    }

    log.Println("All sessions were expired.")
}

确保MongoDB以动态时间间隔过期数据，并且调用是幂等的

1 个答案:

解决方案

注释

解释