Why am I always getting random results regardless of seed value? - go

Question

I have a fairly complex Go application. It generates many random results in a long chain. It is seeded only once - when an HTTP request comes in.
No matter what the seed is - whether it's unix time, or whether it's my own alphanumeric seed function - it always generates completely random results.
I've attempted cutting out my alphanumeric seed function, but that doesn't alter the behavior. I have also tried setting the seed always to 1111. This has no effect.
Here is a sample (verbose and lifted directly from the source, since that's what was requested):
func main() {
sentryDSN := os.Getenv("SENTRY_DSN")
sentry.Init(sentry.ClientOptions{
Dsn: sentryDSN,
})
sentryHandler := sentryhttp.New(sentryhttp.Options{
Repanic: true,
})
r := chi.NewRouter()
r.Use(middleware.RequestID)
r.Use(middleware.RealIP)
r.Use(middleware.Logger)
r.Use(middleware.Recoverer)
r.Use(middleware.URLFormat)
r.Use(middleware.SetHeader("Content-Type", "application/json"))
r.Use(middleware.Timeout(60 * time.Second))
r.Get("/buildingstyle", sentryHandler.HandleFunc(getBuildingStyleRandom))
r.Get("/buildingstyle/{id}", sentryHandler.HandleFunc(getBuildingStyle))
r.Get("/character", sentryHandler.HandleFunc(getCharacterRandom))
r.Get("/character/{id}", sentryHandler.HandleFunc(getCharacter))
r.Get("/climate", sentryHandler.HandleFunc(getClimateRandom))
r.Get("/climate/{id}", sentryHandler.HandleFunc(getClimate))
port := 7531
fmt.Printf("World Generator API is running on http://localhost:%d.\n", port)
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", port), r))
}
func SeedFromString(source string) error {
h := md5.New()
_, err := io.WriteString(h, source)
if err != nil {
err = fmt.Errorf("Failed to seed random number generator: %w", err)
return err
}
seed := binary.BigEndian.Uint64(h.Sum(nil))
rand.Seed(int64(seed))
return nil
}
func getClimate(w http.ResponseWriter, r *http.Request) {
id := chi.URLParam(r, "id")
var o climate.SimplifiedClimate
err := random.SeedFromString(id)
if err != nil {
handleError(w, r, err)
return
}
randomClimate, err := climate.Random()
if err != nil {
handleError(w, r, err)
return
}
o = randomClimate.Simplify()
json.NewEncoder(w).Encode(o)
}
// Generate generates a climate with a given name
func Generate(name string) (Climate, error) {
rawClimate, err := ByName(name)
if err != nil {
err = fmt.Errorf("Could not generate climate by name: %w", err)
return Climate{}, err
}
climate, err := rawClimate.populate()
if err != nil {
err = fmt.Errorf("Could not generate climate by name: %w", err)
return Climate{}, err
}
return climate, nil
}
func (climate Climate) populate() (Climate, error) {
gems := mineral.Gems()
insects := climate.getFilteredInsects()
metals := mineral.Metals()
stones := mineral.Stones()
trees := climate.getFilteredTrees()
climate.Seasons = climate.getSeasons()
lakeChance := rand.Intn(100)
riverChance := rand.Intn(100)
oceanChance := rand.Intn(100)
wetlandsChance := rand.Intn(100)
if lakeChance > 30 {
climate.HasLakes = true
}
if riverChance > 20 {
climate.HasRivers = true
}
if oceanChance > 80 {
climate.HasOcean = true
}
if wetlandsChance > 80 {
climate.HasWetlands = true
}
soils := climate.getFilteredSoils()
if climate.HasLakes || climate.HasRivers || climate.HasOcean {
climate.Fish = climate.getFish()
} else {
climate.Fish = []fish.Fish{}
}
climate.Insects = insect.RandomSubset(7, insects)
filteredMetals, err := mineral.RandomWeightedSet(climate.MaxMetals, metals)
if err != nil {
err = fmt.Errorf("Could not populate climate: %w", err)
return Climate{}, err
}
climate.Metals = filteredMetals
climate.Gems = mineral.Random(climate.MaxGems, gems)
climate.OtherMinerals = mineral.OtherMinerals()
climate.Animals, err = climate.getAnimals()
if err != nil {
err = fmt.Errorf("Could not populate climate: %w", err)
return Climate{}, err
}
climate.Plants, err = climate.getPlants()
if err != nil {
err = fmt.Errorf("Could not populate climate: %w", err)
return Climate{}, err
}
climate.Soils = soil.Random(climate.MaxSoils, soils)
climate.Stones = mineral.Random(climate.MaxStones, stones)
climate.Trees = tree.RandomSubset(climate.MaxTrees, trees)
resources := climate.getResources()
climate.Resources = resources
description, err := climate.getDescription()
if err != nil {
err = fmt.Errorf("Could not populate climate: %w", err)
return Climate{}, err
}
climate.Description = description
climate.Habitability = climate.calculateHabitability()
return climate, nil
}
Many of the functions like doStuff() return n random elements from a slice with some filtering applied.
All of this I expect to be consistent and identical when the same seed is used for multiple runs. However, this is not the case. Instead, the results are random every single time, regardless of seed value.
Is there some fundamental piece of rand.Intn()'s or rand.Seed()'s operation that I'm unaware of?

Answer 1

You're seeding the default source, which is used by many parts of the system. In a large, complicated project, it is very likely that there is some other part that is consuming an indeterminate number of random values dependent on the environment. It's even possible that somewhere else in your code you have a call to rand.Seed().
If you want your random values to be independent, create your own rand.Rand and use that for the pieces you want to be determined by your seed.
If you can reproduce this in a self-contained piece of code, then we can explore the specific case, but I expect when you create a self-contained piece of code the problem will go away because you will have removed the other value consumer(s).