예제 #1
0
파일: archive.go 프로젝트: brianbrunner/omg
func init() {

	go func() {

		for {
			archiveJob := <-archive_chan
			filename := fmt.Sprintf("./db/archive/%s.omg", archiveJob.key)
			f, err := os.Create(filename)
			if err != nil {
				panic(err)
			}

			if _, err = f.Write(archiveJob.data); err != nil {
				panic(err)
			}
			f.Close()
		}
	}()

	store.RegisterStoreType(ArchiveType)
	store.DefaultDBManager.AddFuncWithSideEffects("archive", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], data.Any)
		if ok {
			if elem.EntryType != ArchiveType {
				str_rep, ok := db.StoreDump(args[0])
				if ok {
					archive_chan <- ArchiveJob{args[0], str_rep}
					db.StoreDel(args[0])
					db.ArchiveRecord[args[0]] = 0
					return reply.IntReply(1)
				} else {
					return reply.NilReply
				}
			} else {
				return reply.IntReply(0)
			}
		} else {
			return reply.NilReply
		}
	})
	store.DefaultDBManager.AddFuncWithSideEffects("unarchive", func(db *store.DB, args []string) string {
		_, ok, _ := db.StoreGet(args[0], ArchiveType)
		if ok {
			filename := fmt.Sprintf("./db/archive/%s.omg", args[0])
			data, err := ioutil.ReadFile(filename)
			if err != nil {
				panic(err)
			}
			delete(db.ArchiveRecord, args[0])
			db.StoreLoad(args[0], data)
			return reply.OKReply
		} else {
			return reply.NilReply
		}
	})
}
예제 #2
0
파일: strings.go 프로젝트: brianbrunner/omg
func init() {

	store.RegisterStoreType(StringType)

	store.DefaultDBManager.AddFuncWithSideEffects("append", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		if ok {
			str, _ := elem.Value.(string)
			str += args[1]
			elem.Value = str
			return reply.IntReply(len(str))
		} else {
			db.StoreSet(args[0], &data.Entry{args[1], StringType})
			return reply.IntReply(len(args[1]))
		}
	})

	bitCount := []uint8{0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
		4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}

	store.DefaultDBManager.AddFuncWithSideEffects("bitcount", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		if ok {
			byte_arr, _ := elem.Value.([]byte)
			c := 0
			for _, c := range byte_arr {
				c += bitCount[c]
			}
			return reply.IntReply(c)
		} else {
			return reply.IntReply(0)
		}
	})

	store.DefaultDBManager.AddFuncWithSideEffects("decr", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		var num int
		if ok {
			str, _ := elem.Value.(string)
			num, err := strconv.Atoi(str)
			if err != nil {
				panic(err)
			}
			num -= 1
			elem.Value = fmt.Sprintf("%d", num)
		} else {
			num = -1
			db.StoreSet(args[0], &data.Entry{"-1", StringType})
		}
		return reply.IntReply(num)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("decrby", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		var num int

		decrby, err := strconv.Atoi(args[1])
		if err != nil {
			panic(err)
		}

		if ok {
			str, _ := elem.Value.(string)

			num, err := strconv.Atoi(str)
			if err != nil {
				panic(err)
			}

			num -= decrby
			elem.Value = fmt.Sprintf("%d", num)
		} else {
			str := fmt.Sprintf("-%d", decrby)
			db.StoreSet(args[0], &data.Entry{str, StringType})
		}
		println(num)
		return reply.IntReply(num)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("incr", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		var num int
		if ok {
			str, _ := elem.Value.(string)
			num, err := strconv.Atoi(str)
			if err != nil {
				panic(err)
			}
			num += 1
			elem.Value = fmt.Sprintf("%d", num)
		} else {
			num = 1
			db.StoreSet(args[0], &data.Entry{"-1", StringType})
		}
		return reply.IntReply(num)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("incrby", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		var num int

		decrby, err := strconv.Atoi(args[1])
		if err != nil {
			panic(err)
		}

		if ok {
			str, _ := elem.Value.(string)

			num, err := strconv.Atoi(str)
			if err != nil {
				panic(err)
			}

			num += decrby
			elem.Value = fmt.Sprintf("%d", num)
		} else {
			str := fmt.Sprintf("%d", decrby)
			db.StoreSet(args[0], &data.Entry{str, StringType})
		}
		println(num)
		return reply.IntReply(num)
	})

	store.DefaultDBManager.AddFunc("get", func(db *store.DB, args []string) string {
		elem, ok, err := db.StoreGet(args[0], StringType)
		if err != nil {
			return reply.ErrorReply(err)
		}
		if ok {
			str := elem.GetString()
			return reply.BulkReply(str)
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFunc("getset", func(db *store.DB, args []string) string {
		elem, ok, err := db.StoreGet(args[0], StringType)
		if err != nil {
			return reply.ErrorReply(err)
		}
		if ok {
			str := elem.GetString()
			elem.Value = args[1]
			return reply.BulkReply(str)
		} else {
			db.StoreSet(args[0], &data.Entry{args[1], StringType})
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFuncWithSideEffects("psetex", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)

		millis, err := strconv.Atoi(args[1])
		if err != nil {
			panic(err)
		}

		db.ExpiryRecord[args[0]] = store.Milliseconds() + uint64(millis)

		if ok {
			elem.Value = args[2]
		} else {
			db.StoreSet(args[0], &data.Entry{args[2], StringType})
		}

		return reply.OKReply
	})

	store.DefaultDBManager.AddFuncWithSideEffects("setex", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)

		seconds, err := strconv.Atoi(args[1])
		if err != nil {
			panic(err)
		}

		db.ExpiryRecord[args[0]] = store.Milliseconds() + uint64(seconds)*1000

		if ok {
			elem.Value = args[2]
		} else {
			db.StoreSet(args[0], &data.Entry{args[2], StringType})
		}

		return reply.OKReply
	})

	store.DefaultDBManager.AddFuncWithSideEffects("set", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], StringType)
		if ok {
			elem.Value = args[1]
		} else {
			db.StoreSet(args[0], &data.Entry{args[1], StringType})
		}
		return reply.OKReply
	})

	store.DefaultDBManager.AddFuncWithSideEffects("setnx", func(db *store.DB, args []string) string {
		s := args[0]
		_, ok, _ := db.StoreGet(s, StringType)
		if ok {
			return reply.IntReply(0)
		}
		db.StoreSet(s, &data.Entry{args[1], StringType})
		return reply.IntReply(1)
	})

	store.DefaultDBManager.AddFunc("strlen", func(db *store.DB, args []string) string {
		elem, ok, err := db.StoreGet(args[0], StringType)
		if err != nil {
			return reply.ErrorReply(err)
		}
		if ok {
			str := elem.GetString()
			return reply.IntReply(len(str))
		} else {
			return reply.IntReply(0)
		}
	})

}
예제 #3
0
파일: keys.go 프로젝트: brianbrunner/omg
func init() {

	store.DefaultDBManager.AddFuncWithSideEffects("del", func(db *store.DB, args []string) string {
		del_count := 0
		for _, v := range args {
			ok := db.StoreDel(v)
			if ok {
				del_count += 1
			}
		}
		return reply.IntReply(del_count)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("expire", func(db *store.DB, args []string) string {
		_, ok, _ := db.StoreGet(args[0], data.Any)
		if ok {
			millis := store.Milliseconds()
			expires, err := strconv.Atoi(args[1])
			if err != nil {
				return reply.IntReply(0)
			} else {
				db.ExpiryRecord[args[0]] = millis + uint64(expires*1000)
				return reply.IntReply(1)
			}
		}
		return reply.IntReply(0)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("pexpire", func(db *store.DB, args []string) string {
		_, ok, _ := db.StoreGet(args[0], data.Any)
		if ok {
			millis := store.Milliseconds()
			expires, err := strconv.Atoi(args[1])
			if err != nil {
				return reply.IntReply(0)
			} else {
				db.ExpiryRecord[args[0]] = millis + uint64(expires)
				return reply.IntReply(1)
			}
		}
		return reply.IntReply(0)
	})

	store.DefaultDBManager.AddFunc("ttl", func(db *store.DB, args []string) string {
		_, ok, _ := db.StoreGet(args[0], data.Any)
		if !ok {
			return reply.IntReply(-2)
		}

		time, ok := db.ExpiryRecord[args[0]]
		millis := store.Milliseconds()

		if ok {
			if time == 0 {
				return reply.IntReply(-1)
			} else if time < millis {
				db.StoreDel(args[0])
				return reply.IntReply(-2)
			} else {
				return reply.IntReply(int((time - millis) / 1000))
			}
		} else {
			return reply.IntReply(-1)
		}
	})

	store.DefaultDBManager.AddFunc("pttl", func(db *store.DB, args []string) string {
		_, ok, _ := db.StoreGet(args[0], data.Any)
		if !ok {
			return reply.IntReply(-2)
		}

		time, ok := db.ExpiryRecord[args[0]]
		millis := store.Milliseconds()

		if ok {
			if time == 0 {
				return reply.IntReply(-1)
			} else if time < millis {
				db.StoreDel(args[0])
				return reply.IntReply(-2)
			} else {
				return reply.IntReply(int(time - millis))
			}
		} else {
			return reply.IntReply(-1)
		}
	})

	store.DefaultDBManager.AddFunc("exists", func(db *store.DB, args []string) string {
		_, ok, _ := db.StoreGet(args[0], data.Any)
		if ok {
			return reply.IntReply(1)
		}
		return reply.IntReply(0)
	})

	store.DefaultDBManager.AddFunc("dump", func(db *store.DB, args []string) string {
		bytes_rep, ok := db.StoreDump(args[0])
		fmt.Println(bytes_rep)
		str_rep := string(bytes_rep)
		if ok {
			return reply.BulkReply(str_rep)
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFuncWithSideEffects("restore", func(db *store.DB, args []string) string {
		unquoted_data, _ := strconv.Unquote(args[1])
		fmt.Println(unquoted_data)
		bytes_rep := []byte(unquoted_data)
		ok := db.StoreLoad(args[0], bytes_rep)
		if ok {
			return reply.OKReply
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFunc("type", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], data.Any)
		if ok {
			return reply.IntReply(int(elem.Type()))
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFunc("keys", func(db *store.DB, args []string) string {
		keys := db.StoreKeysMatch(args[0])
		var writer reply.MultiBulkWriter
		writer.WriteCount(len(keys))
		for _, key := range keys {
			writer.WriteString(key)
		}
		return writer.String()
	})

	store.DefaultDBManager.AddFunc("randomkey", func(db *store.DB, args []string) string {
		for key, _ := range db.Store {
			return reply.BulkReply(key)
		}
		return reply.NilReply
	})

	store.DefaultDBManager.AddFunc("ping", func(db *store.DB, args []string) string {
		return reply.BulkReply("PONG")
	})

}
예제 #4
0
파일: server.go 프로젝트: brianbrunner/omg
func init() {

	store.DefaultDBManager.AddFunc("select", func(db *store.DB, args []string) string {
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("info", func(db *store.DB, args []string) string {
		return reply.BulkReply("# Server\r\nredis_version:2.6.7\r\n")
	})

	store.DefaultDBManager.AddFunc("meminuse", func(db *store.DB, args []string) string {
		return reply.IntReply(int(store.MemInUse()))
	})

	store.DefaultDBManager.AddFunc("objectsinuse", func(db *store.DB, args []string) string {
		var memProfiles []runtime.MemProfileRecord
		n, _ := runtime.MemProfile(memProfiles, false)
		memProfiles = make([]runtime.MemProfileRecord, n)
		n, _ = runtime.MemProfile(memProfiles, false)

		objects := int64(0)
		for _, prof := range memProfiles {
			objects += prof.InUseObjects()
		}

		return reply.IntReply(int(objects))
	})

	store.DefaultDBManager.AddFunc("gc", func(db *store.DB, args []string) string {
		runtime.GC()
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("freeosmemory", func(db *store.DB, args []string) string {
		debug.FreeOSMemory()
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("save", func(db *store.DB, args []string) string {
		err := db.SaveToDiskSync()
		if err != nil {
			return reply.ErrorReply(err)
		} else {
			return reply.OKReply
		}
	})

	store.DefaultDBManager.AddFunc("bgsave", func(db *store.DB, args []string) string {
		store.DefaultDBManager.SaveToDiskAsync(nil)
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("__end_save_mode__", func(db *store.DB, args []string) string {
		db.EndSaveMode()
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("dbsize", func(db *store.DB, args []string) string {
		return reply.IntReply(store.DefaultDBManager.DBSize())
	})

	store.DefaultDBManager.AddFunc("lastdump", func(db *store.DB, args []string) string {
		elem, ok, _ := db.StoreGet(args[0], data.Any)
		if ok {
			return reply.IntReply(int(elem.LastDump()))
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFunc("lastdumpdb", func(db *store.DB, args []string) string {
		return reply.IntReply(int(db.LastDump()))
	})

	store.DefaultDBManager.AddFunc("flush", func(db *store.DB, args []string) string {
		db.Flush()
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("keysperdb", func(db *store.DB, args []string) string {
		var w reply.MultiBulkWriter
		dbs := store.DefaultDBManager.GetDBs()
		w.WriteCount(len(dbs))
		for _, db := range dbs {
			w.WriteString(fmt.Sprintf("%d", len(db.Store)))
		}
		return w.String()
	})

}
예제 #5
0
파일: feed.go 프로젝트: brianbrunner/omg
func init() {

	gob.Register(&Post{})
	gob.Register(&Feed{})

	store.RegisterStoreType(FeedType)

	store.DefaultDBManager.AddFuncWithSideEffects("feedcap", func(db *store.DB, args []string) string {
		s := args[0]
		cap, err := strconv.Atoi(args[1])
		if err != nil {
			return reply.ErrorReply(err)
		}
		e, ok, _ := db.StoreGet(s, FeedType)
		if ok {
			if f, ok := e.Value.(*Feed); ok {
				f.Capacity = cap
				return reply.OKReply
			} else {
				return reply.ErrorReply("Type Mismatch")
			}
		} else {
			f := &Feed{s, cap, 0, make([]*Post, 0)}
			db.StoreSet(s, &data.Entry{f, FeedType})
		}
		return reply.OKReply
	})

	store.DefaultDBManager.AddFunc("feedget", func(db *store.DB, args []string) string {
		if e, ok, _ := db.StoreGet(args[0], FeedType); ok {
			if f, ok := e.Value.(*Feed); ok {
				cap_str := fmt.Sprintf("%d", f.Capacity)
				var rep reply.MultiBulkWriter
				rep.WriteCount(2)
				rep.WriteString(f.Name)
				rep.WriteString(cap_str)
				return rep.String()
			} else {
				return "-ERR Type mismatch\r\n"
			}
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFuncWithSideEffects("feedpost", func(db *store.DB, args []string) string {
		e, ok, _ := db.StoreGet(args[0], FeedType)
		if !ok {
			s := args[0]
			f := &Feed{s, -1, 0, make([]*Post, 0)}
			e = &data.Entry{f, FeedType}
			db.StoreSet(s, e)
		}
		if f, ok := e.Value.(*Feed); ok {
			timestamp := store.Milliseconds()
			if timestamp == f.LastTimestamp {
				timestamp += 1
			}
			f.LastTimestamp = timestamp
			p := &Post{args[1], args[2], timestamp, 0, make(map[string]string)}
			f.Posts = append(f.Posts, p)
			return reply.OKReply
		} else {
			return reply.ErrorReply("Type mismatch")
		}
	})

	store.DefaultDBManager.AddFunc("feedposts", func(db *store.DB, args []string) string {
		if e, ok, _ := db.StoreGet(args[0], FeedType); ok {
			if f, ok := e.Value.(*Feed); ok {
				post_count := len(f.Posts)
				offset := 0
				count := post_count
				if len(args) == 3 {

					var err error
					offset, err = strconv.Atoi(args[1])
					if err != nil {
						panic(err)
					}

					count, err = strconv.Atoi(args[2])
					if err != nil {
						panic(err)
					}

				}

				if offset >= post_count {
					return reply.NilReply
				}

				if offset+count > post_count {
					count = post_count - offset
				}

				var rep reply.MultiBulkWriter
				rep.WriteCount(3 * post_count)
				for i := post_count - offset; i >= post_count-offset-count; i-- {
					p := f.Posts[i]
					timestamp_str := fmt.Sprintf("%d", p.Timestamp)
					rep.WriteString(p.Author)
					rep.WriteString(p.Body)
					rep.WriteString(timestamp_str)
				}
				return rep.String()
			} else {
				return reply.ErrorReply("Type mismatch")
			}
		} else {
			return reply.NilReply
		}
	})

	store.DefaultDBManager.AddFunc("feedlen", func(db *store.DB, args []string) string {
		if e, ok, _ := db.StoreGet(args[0], FeedType); ok {
			if f, ok := e.Value.(*Feed); ok {
				return reply.IntReply(len(f.Posts))
			}
		}
		return reply.NilReply
	})

	//store.DefaultDBManager.AddFuncWithSideEffects("feedlike", func (db *store.DB, args []string) string {
	//})
}
예제 #6
0
파일: set.go 프로젝트: brianbrunner/omg
func init() {

	gob.Register(make(map[string]bool))

	store.RegisterStoreType(SetType)

	store.DefaultDBManager.AddFuncWithSideEffects("sadd", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)

		if err != nil {
			return reply.ErrorReply("Type Mismatch")
		}

		var setData map[string]bool
		if !ok {
			setData = make(map[string]bool)
			db.StoreSet(args[0], &data.Entry{setData, SetType})
		} else {
			setData, _ = e.Value.(map[string]bool)
		}

		l := len(args)
		sdata := args[1:l]
		count := 0
		for _, member := range sdata {
			_, ok = setData[member]
			if !ok {
				setData[member] = true
				count += 1
			}
		}
		return reply.IntReply(count)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("srem", func(db *store.DB, args []string) string {

		e, ok, err := db.StoreGet(args[0], SetType)
		if err != nil {
			return reply.ErrorReply("Type Mismatch")
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if !ok {
			setData = make(map[string]bool)
			db.StoreSet(args[0], &data.Entry{setData, SetType})
		}

		l := len(args)
		sdata := args[1:l]
		count := 0
		for _, member := range sdata {
			_, ok = setData[member]
			if ok {
				delete(setData, member)
				count += 1
			}
		}

		return reply.IntReply(count)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("srem", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)
		if err != nil {
			return reply.ErrorReply("Type Mismatch")
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if !ok {
			setData = make(map[string]bool)
		}
		l := len(args)
		sdata := args[1:l]
		count := 0
		for _, member := range sdata {
			_, ok = setData[member]
			if ok {
				delete(setData, member)
				count += 1
			}
		}
		return reply.IntReply(count)
	})

	store.DefaultDBManager.AddFunc("sismember", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)

		if err != nil || !ok {
			return "-ERR Type Mismatch\r\n"
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if !ok {
			return reply.IntReply(0)
		}
		_, ok = setData[args[1]]
		if ok {
			return reply.IntReply(1)
		}
		return reply.IntReply(0)
	})

	store.DefaultDBManager.AddFunc("scard", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)

		if err != nil || !ok {
			return reply.ErrorReply("Type Mismatch")
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if ok {
			return reply.IntReply(len(setData))
		}
		return reply.IntReply(0)
	})

	store.DefaultDBManager.AddFuncWithSideEffects("spop", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)

		if err != nil || !ok {
			return "-ERR Type Mismatch\r\n"
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if !ok {
			return reply.NilReply
		}
		for k, _ := range setData {
			delete(setData, k)
			return reply.BulkReply(k)
		}
		return reply.NilReply
	})

	store.DefaultDBManager.AddFuncWithSideEffects("smembers", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)

		if err != nil || !ok {
			return "-ERR Type Mismatch\r\n"
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if !ok {
			return reply.NilReply
		}

		var w reply.MultiBulkWriter
		w.WriteCount(len(setData))
		for k, _ := range setData {
			w.WriteString(k)
		}
		return w.String()
	})

	store.DefaultDBManager.AddFuncWithSideEffects("srandmember", func(db *store.DB, args []string) string {
		e, ok, err := db.StoreGet(args[0], SetType)

		if err != nil || !ok {
			return "-ERR Type Mismatch\r\n"
		}
		if !ok {
			return reply.NilReply
		}

		setData, ok := e.Value.(map[string]bool)
		if !ok {
			return reply.NilReply
		}

		if len(args) > 1 {

			count, err := strconv.Atoi(args[1])
			if err != nil {
				panic(err)
			}

			var w reply.MultiBulkWriter
			w.WriteCount(count)
			for k, _ := range setData {
				w.WriteString(k)
				count -= 1
				if count == 0 {
					break
				}
			}
			return w.String()

		} else {

			for k, _ := range setData {
				return reply.BulkReply(k)
			}

		}

		return reply.NilReply

	})

}