Пример #1
0
func (self RealmManager) PersistAll(values []Realm) (realms []Realm, err error) {
	m := self.Client().Main
	realms = values

	newValueIndexes := make(map[int]int)
	i := 0
	for j, value := range values {
		if !value.IsValid() {
			newValueIndexes[i] = j
			i++
		}
	}

	// ids
	var ids []int64
	if ids, err = m.IncrAll("realm_id", len(newValueIndexes)); err != nil {
		return
	}
	for i, id := range ids {
		realms[newValueIndexes[i]].Id = id
	}

	// data
	persistValues := make([]Cache.PersistValue, len(realms))
	newIds := make([]string, len(newValueIndexes))
	hashedNameKeys := map[string]string{}
	for i, realm := range realms {
		bucketKey, subKey := Cache.GetBucketKey(realm.Id, self.Namespace())

		var s string
		if s, err = realm.marshal(); err != nil {
			return
		}

		persistValues[i] = Cache.PersistValue{
			BucketKey: bucketKey,
			SubKey:    subKey,
			Value:     s,
		}
		_, isNew := newValueIndexes[i]
		if isNew {
			id := strconv.FormatInt(realm.Id, 10)
			newIds[i] = id
			hashedNameKeys[realmNameKey(realm.Region, realm.Slug)] = id
		}
	}
	if err = m.PersistAll(persistValues); err != nil {
		return
	}
	if err = m.RPushAll(fmt.Sprintf("region:%d:realm_ids", self.Region.Id), newIds); err != nil {
		return
	}
	if err = m.SetAll(hashedNameKeys); err != nil {
		return
	}

	return
}
Пример #2
0
func (self Manager) PersistAll(newCharacters []Character) (err error) {
	m := self.Client().Main

	// ids
	var ids []int64
	if ids, err = m.IncrAll(fmt.Sprintf("realm:%d:character_id", self.Realm.Id), len(newCharacters)); err != nil {
		return
	}
	for i, id := range ids {
		newCharacters[i].Id = id
	}

	// data
	values := make([]Cache.PersistValue, len(newCharacters))
	for i, character := range newCharacters {
		bucketKey, subKey := Cache.GetBucketKey(character.Id, self.Namespace())

		var s string
		if s, err = character.marshal(); err != nil {
			return
		}

		values[i] = Cache.PersistValue{
			BucketKey: bucketKey,
			SubKey:    subKey,
			Value:     s,
		}
	}
	if err = m.PersistAll(values); err != nil {
		return
	}

	// etc
	newCharacterIds := make([]string, len(newCharacters))
	newNames := make([]string, len(newCharacters))
	hashedNameKeys := map[string]string{}
	for i, character := range newCharacters {
		id := strconv.FormatInt(character.Id, 10)
		name := character.Name

		newCharacterIds[i] = id
		newNames[i] = name
		hashedNameKeys[characterNameKey(self.Realm, name)] = id
	}
	if err = m.RPushAll(fmt.Sprintf("realm:%d:character_ids", self.Realm.Id), newCharacterIds); err != nil {
		return
	}
	if err = m.SAddAll(fmt.Sprintf("realm:%d:character_names", self.Realm.Id), newNames); err != nil {
		return
	}
	if err = m.SetAll(hashedNameKeys); err != nil {
		return
	}

	return nil
}
Пример #3
0
func (self ItemManager) PersistAll(items []Item) (err error) {
	m := self.Client.Main

	// ids
	var ids []int64
	if ids, err = m.IncrAll("item_id", len(items)); err != nil {
		return
	}
	for i, id := range ids {
		items[i].Id = id
	}

	// data
	values := make([]Cache.PersistValue, len(items))
	for i, item := range items {
		bucketKey, subKey := Cache.GetBucketKey(item.Id, self.Namespace())

		var s string
		if s, err = item.marshal(); err != nil {
			return
		}

		values[i] = Cache.PersistValue{
			BucketKey: bucketKey,
			SubKey:    subKey,
			Value:     s,
		}
	}
	if err = m.PersistAll(values); err != nil {
		return
	}

	// etc
	newIds := make([]string, len(items))
	newBlizzIds := make([]string, len(items))
	for i, item := range items {
		newIds[i] = strconv.FormatInt(item.Id, 10)
		newBlizzIds[i] = strconv.FormatInt(item.BlizzId, 10)
	}
	if err = m.RPushAll("item:ids", newIds); err != nil {
		return
	}
	if err = m.SAddAll("item:blizz_ids", newBlizzIds); err != nil {
		return
	}

	return nil
}
Пример #4
0
func (self RegionManager) PersistAll(values []Region) (regions []Region, err error) {
	m := self.Client.Main
	regions = values

	// ids
	var ids []int64
	if ids, err = m.IncrAll("region_id", len(regions)); err != nil {
		return
	}
	for i, id := range ids {
		regions[i].Id = id
	}

	// data
	persistValues := make([]Cache.PersistValue, len(regions))
	hashedNameKeys := map[string]string{}
	newIds := make([]string, len(regions))
	for i, region := range regions {
		bucketKey, subKey := Cache.GetBucketKey(region.Id, self.Namespace())

		var s string
		if s, err = region.marshal(); err != nil {
			return
		}

		persistValues[i] = Cache.PersistValue{
			BucketKey: bucketKey,
			SubKey:    subKey,
			Value:     s,
		}

		id := strconv.FormatInt(region.Id, 10)
		hashedNameKeys[regionNameKey(region.Name)] = id
		newIds[i] = id
	}
	if err = m.PersistAll(persistValues); err != nil {
		return
	}
	if err = m.SetAll(hashedNameKeys); err != nil {
		return
	}
	if err = m.RPushAll("region_ids", newIds); err != nil {
		return
	}

	return
}
Пример #5
0
func (self LocaleManager) Persist(locale Locale) (Locale, error) {
	var (
		err error
		s   string
	)
	r := self.Client.Main.Redis

	// id
	isNew := !locale.IsValid()
	if isNew {
		req := r.Incr("locale_id")
		if err = req.Err(); err != nil {
			return locale, err
		}
		locale.Id = req.Val()
	}

	// data
	s, err = locale.marshal()
	if err != nil {
		return locale, err
	}
	bucketKey, subKey := Cache.GetBucketKey(locale.Id, "locale")
	req := r.HSet(bucketKey, subKey, s)
	if err = req.Err(); err != nil {
		return locale, err
	}

	// etc
	if isNew {
		id := strconv.FormatInt(locale.Id, 10)
		cmd := r.RPush("locale_ids", id)
		if err = cmd.Err(); err != nil {
			return locale, err
		}
		cmd = r.RPush(fmt.Sprintf("region:%d:locale_ids", locale.Region.Id), id)
		if err = cmd.Err(); err != nil {
			return locale, err
		}
	}

	return locale, nil
}