gob: interface is only registered on Encode but not on Decode

Question

I'm working on an appengine app using the datastore. I'm attempting to gob encode an interface and store it into the datastore. But when I try to load from the datastore, I get the error:

gob: name not registered for interface: "main27155.strand"

The peculiar thing is that the load() method starts working after having called the save() method. It no longer returns an error, and everything saved in the datastore is loaded as expected. But when I restart the intance, the load() method stops working again.

The load and save methods I mention refer to the methods defined by the datastore.PropertyLoadSaver interface

From the looks of it, it seems like a problem with registering the type/interfaces with gob, but I have exactly the same gob.Register() calls in both the load() and save() methods.

I even tried removing the gob.Register() calls from both load and save methods and adding it to init() . The exact same behavior was observed.

How can I load my datastore on a cold start?

type bio struct {¬                          
    Id       string¬                        
    Hp       int¬                           
    godie    chan bool //should be buffered¬
    dam      chan int¬                      
    Genetics dna¬                           
}¬                                          

type dna interface {
    decode() mRNA
    Get(int) trait
    Set(int, trait)
    Duplicate() dna
    Len() int
}
type trait interface {
    mutate() trait
}

// implements dna{}
type strand []trait

// implements trait{}
type tdecoration string
type color struct {
    None bool // If true, colors are not shown in theme
    Bg   bool // If true, color is a background color
    R    int  // 0-255
    G    int
    B    int
}

.

func start(w http.ResponseWriter, r *http.Request) error {
    c := appengine.NewContext(r)

    var bs []bio
    if _, err := datastore.NewQuery("bio").GetAll(c, &bs); err != nil {
        log.Println("bs is len: ", len(bs))
        return err
    }

    ...
    return nil
}

func stop(w http.ResponseWriter, r *http.Request) error {
    c := appengine.NewContext(r)
    log.Println("Saving top 20 colors")
    var k []*datastore.Key
    var bs []*bio
    stat := getStats()
    for i, b := range stat.Leaderboard {
        k = append(k, datastore.NewKey(c, "bio", b.Id, 0, nil))
        bv := b
        bs = append(bs, &bv)
        // At most 20 bios survive across reboots
        if i > 178 {
            break
        }
    }

    // Assemble slice of keys for deletion
    dk, err := datastore.NewQuery("bio").KeysOnly().GetAll(c, nil)
    if err != nil {
        return errors.New(fmt.Sprintf("Query error: %s", err.Error()))
    }

    fn := func(c appengine.Context) error {
        // Delete all old entries
        err := datastore.DeleteMulti(c, dk)
        if err != nil {
            return errors.New(fmt.Sprintf("Delete error: %s", err.Error()))
        }

        // save the elite in the datastore
        _, err = datastore.PutMulti(c, k, bs)
        if err != nil {
            return err
        }
        return nil
    }

    return datastore.RunInTransaction(c, fn, &datastore.TransactionOptions{XG: true})
}

// satisfy datastore PropertyLoadSaver interface ===============================

func (b *bio) Load(c <-chan datastore.Property) error {
    gob.Register(&color{})
    gob.Register(new(tdecoration))
    var str strand
    gob.Register(str)

    tmp := struct {
        Id     string
        Hp     int
        Gengob []byte
    }{}
    if err := datastore.LoadStruct(&tmp, c); err != nil {
        return err
    }

    b.Id = tmp.Id
    b.Hp = tmp.Hp

    return gob.NewDecoder(strings.NewReader(string(tmp.Gengob))).Decode(&(b.Genetics))
}
func (b *bio) Save(c chan<- datastore.Property) error {
    defer close(c)
    gob.Register(&color{})
    gob.Register(new(tdecoration))
    var str strand
    gob.Register(str)

    var buf bytes.Buffer
    gen := b.Genetics
    if err := gob.NewEncoder(&buf).Encode(&gen); err != nil {
        log.Println(err)
        return err
    }
    dp := []datastore.Property{
        {Name: "Id", Value: b.Id},
        {Name: "Hp", Value: int64(b.Hp)},
        {Name: "Gengob", Value: buf.Bytes(), NoIndex: true},
    }
    for _, p := range dp {
        c <- p
    }
    return nil
}

Additional info: This behavior was not present before I stuffed the datastore calls in stop() into datastore.RunInTransaction()

Answer 1

Register all types an in init() functions using RegisterName() . Delete all existing data from the store and you should be good to go.

App Engine generates a mangled name for the main package every time the application is built. The name generated by Register() includes this mangled package name. Any gobs encoded with the mangled name will only be readable using the same build of the app. If you cause the application to be rebuilt by modifying the code, then the app will not be able to decode gobs stored previously.