github.com/therealbill/libredis@v0.0.0-20161227004305-7d50abda5ccf/client/server.go

package client

import (
	"errors"
	"fmt"
	"io"
	"net"
	"strconv"

	"github.com/therealbill/libredis/info"
	"github.com/therealbill/libredis/structures"
)

// BgRewriteAof Instruct Redis to start an Append Only File rewrite process.
// The rewrite will create a small optimized version of the current Append Only File.
func (r *Redis) BgRewriteAof() error {
	_, err := r.ExecuteCommand("BGREWRITEAOF")
	return err
}

// BgSave save the DB in background.
// The OK code is immediately returned.
// Redis forks, the parent continues to serve the clients, the child saves the DB on disk then exits.
// A client my be able to check if the operation succeeded using the LASTSAVE command.
func (r *Redis) BgSave() error {
	_, err := r.ExecuteCommand("BGSAVE")
	return err
}

// ClientKill closes a given client connection identified by ip:port.
// Due to the single-treaded nature of Redis,
// it is not possible to kill a client connection while it is executing a command.
// However, the client will notice the connection has been closed
// only when the next command is sent (and results in network error).
// Status code reply: OK if the connection exists and has been closed
func (r *Redis) ClientKill(ip string, port int) error {
	rp, err := r.ExecuteCommand("CLIENT", "KILL", net.JoinHostPort(ip, strconv.Itoa(port)))
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// Role() returns the current role name on the server. Requires Redis >= 2.8.12
func (r *Redis) Role() (sl []string, err error) {
	rp, err := r.ExecuteCommand("ROLE")
	if err != nil {
		return sl, err
	}
	return rp.Multi[1].ListValue()
}

// RoleName() returns the current role name on the server. Requires Redis >= 2.8.12
// This is a shorthand for those who only want the name of the role rather than
// all the details.
func (r *Redis) RoleName() (string, error) {
	rp, err := r.ExecuteCommand("ROLE")
	if err != nil {
		return "", err
	}
	return rp.Multi[0].StringValue()
}

// ClientList returns information and statistics
// about the client connections server in a mostly human readable format.
// Bulk reply: a unique string, formatted as follows:
// One client connection per line (separated by LF)
// Each line is composed of a succession of property=value fields separated by a space character.
func (r *Redis) ClientList() (string, error) {
	rp, err := r.ExecuteCommand("CLIENT", "LIST")
	if err != nil {
		return "", err
	}
	return rp.StringValue()
}

// ClientGetName returns the name of the current connection as set by CLIENT SETNAME.
// Since every new connection starts without an associated name,
// if no name was assigned a null bulk reply is returned.
func (r *Redis) ClientGetName() ([]byte, error) {
	rp, err := r.ExecuteCommand("CLIENT", "GETNAME")
	if err != nil {
		return nil, err
	}
	return rp.BytesValue()
}

// ClientPause stops the server processing commands from clients for some time.
func (r *Redis) ClientPause(timeout uint64) error {
	rp, err := r.ExecuteCommand("CLIENT", "PAUSE", timeout)
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// ClientSetName assigns a name to the current connection.
func (r *Redis) ClientSetName(name string) error {
	rp, err := r.ExecuteCommand("CLIENT", "SETNAME", name)
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// ConfigGet is used to read the configuration parameters of a running Redis server.
// Not all the configuration parameters are supported in Redis 2.4,
// while Redis 2.6 can read the whole configuration of a server using this command.
// CONFIG GET takes a single argument, which is a glob-style pattern.
func (r *Redis) ConfigGet(parameter string) (map[string]string, error) {
	rp, err := r.ExecuteCommand("CONFIG", "GET", parameter)
	if err != nil {
		return nil, err
	}
	return rp.HashValue()
}

// ConfigRewrite rewrites the redis.conf file the server was started with,
// applying the minimal changes needed to make it reflecting the configuration currently used by the server,
// that may be different compared to the original one because of the use of the CONFIG SET command.
// Available since 2.8.0.
func (r *Redis) ConfigRewrite() error {
	rp, err := r.ExecuteCommand("CONFIG", "REWRITE")
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// ConfigSet is used in order to reconfigure the server at run time without the need to restart Redis.
// You can change both trivial parameters or switch from one to another persistence option using this command.
func (r *Redis) ConfigSet(parameter, value string) error {
	rp, err := r.ExecuteCommand("CONFIG", "SET", parameter, value)
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// ConfigSetInt is a convenience wrapper for passing integers to ConfigSet
func (r *Redis) ConfigSetInt(parameter string, value int) error {
	sval := fmt.Sprintf("%d", value)
	rp, err := r.ExecuteCommand("CONFIG", "SET", parameter, sval)
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// ConfigResetStat resets the statistics reported by Redis using the INFO command.
// These are the counters that are reset:
// Keyspace hits
// Keyspace misses
// Number of commands processed
// Number of connections received
// Number of expired keys
// Number of rejected connections
// Latest fork(2) time
// The aof_delayed_fsync counter
func (r *Redis) ConfigResetStat() error {
	_, err := r.ExecuteCommand("CONFIG", "RESETSTAT")
	return err
}

// DBSize return the number of keys in the currently-selected database.
func (r *Redis) DBSize() (int64, error) {
	rp, err := r.ExecuteCommand("DBSIZE")
	if err != nil {
		return 0, err
	}
	return rp.IntegerValue()
}

// DebugObject is a debugging command that should not be used by clients.
func (r *Redis) DebugObject(key string) (string, error) {
	rp, err := r.ExecuteCommand("DEBUG", "OBJECT", key)
	if err != nil {
		return "", err
	}
	return rp.StatusValue()
}

// FlushAll delete all the keys of all the existing databases,
// not just the currently selected one.
// This command never fails.
func (r *Redis) FlushAll() error {
	_, err := r.ExecuteCommand("FLUSHALL")
	return err
}

// FlushDB delete all the keys of the currently selected DB.
// This command never fails.
func (r *Redis) FlushDB() error {
	_, err := r.ExecuteCommand("FLUSHDB")
	return err
}

// Info returns information and statistics about the server
// In RedisInfoAll struct see the github.com/therealbill/libredis/info package
// for details
func (r *Redis) Info() (sinfo structures.RedisInfoAll, err error) {
	rp, err := r.ExecuteCommand("info", "all")
	if err != nil {
		return
	}
	strval, _ := rp.StringValue()
	if err != nil {
		return
	}
	sinfo = info.GetAllInfo(strval)
	return
}

// SentinelInfo returns information and statistics for a sentinel instance
// In RedisInfoAll struct see the github.com/therealbill/libredis/info package
// for details
func (r *Redis) SentinelInfo() (sinfo structures.RedisInfoAll, err error) {
	rp, err := r.ExecuteCommand("info")
	if err != nil {
		return
	}
	strval, _ := rp.StringValue()
	if err != nil {
		return
	}
	sinfo = info.GetAllInfo(strval)
	return
}

// InfoString returns information and statistics about the server
// in a format that is simple to parse by computers and easy to read by humans.
// format document at http://redis.io/commands/info
func (r *Redis) InfoString(section string) (string, error) {
	args := packArgs("INFO", section)
	rp, err := r.ExecuteCommand(args...)
	if err != nil {
		return "", err
	}
	return rp.StringValue()
}

// LastSave return the UNIX TIME of the last DB save executed with success.
// A client may check if a BGSAVE command succeeded reading the LASTSAVE value,
// then issuing a BGSAVE command and checking at regular intervals every N seconds if LASTSAVE changed.
// Integer reply: an UNIX time stamp.
func (r *Redis) LastSave() (int64, error) {
	rp, err := r.ExecuteCommand("LASTSAVE")
	if err != nil {
		return 0, err
	}
	return rp.IntegerValue()
}

// MonitorCommand is a debugging command that streams back every command processed by the Redis server.
type MonitorCommand struct {
	redis *Redis
	conn  *connection
}

// Monitor sned MONITOR command to redis server.
func (r *Redis) Monitor() (*MonitorCommand, error) {
	c, err := r.pool.Get()
	if err != nil {
		return nil, err
	}
	if err := c.SendCommand("MONITOR"); err != nil {
		return nil, err
	}
	rp, err := c.RecvReply()
	if err != nil {
		return nil, err
	}
	if err := rp.OKValue(); err != nil {
		return nil, err
	}
	return &MonitorCommand{r, c}, nil
}

// Receive read from redis server and return the reply.
func (m *MonitorCommand) Receive() (string, error) {
	rp, err := m.conn.RecvReply()
	if err != nil {
		return "", err
	}
	return rp.StatusValue()
}

// Close closes current monitor command.
func (m *MonitorCommand) Close() error {
	return m.conn.SendCommand("QUIT")
}

// Save performs a synchronous save of the dataset
// producing a point in time snapshot of all the data inside the Redis instance,
// in the form of an RDB file.
// You almost never want to call SAVE in production environments
// where it will block all the other clients. Instead usually BGSAVE is used.
func (r *Redis) Save() error {
	rp, err := r.ExecuteCommand("SAVE")
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// Shutdown behavior is the following:
// Stop all the clients.
// Perform a blocking SAVE if at least one save point is configured.
// Flush the Append Only File if AOF is enabled.
// Quit the server.
func (r *Redis) Shutdown(save bool) error {
	args := packArgs("SHUTDOWN")
	if save {
		args = append(args, "SAVE")
	} else {
		args = append(args, "NOSAVE")
	}
	rp, err := r.ExecuteCommand(args...)
	if err == io.EOF {
		return nil
	}
	if err != nil {
		return err
	}
	return errors.New(rp.Status)
}

// SlaveOf can change the replication settings of a slave on the fly.
// If a Redis server is already acting as slave, the command SLAVEOF NO ONE will turn off the replication,
// turning the Redis server into a MASTER.
// In the proper form SLAVEOF hostname port will make the server a slave of
// another server listening at the specified hostname and port.
//
// If a server is already a slave of some master,
// SLAVEOF hostname port will stop the replication against the old server
// and start the synchronization against the new one, discarding the old dataset.
// The form SLAVEOF NO ONE will stop replication, turning the server into a MASTER,
// but will not discard the replication.
// So, if the old master stops working,
// it is possible to turn the slave into a master and set the application to use this new master in read/write.
// Later when the other Redis server is fixed, it can be reconfigured to work as a slave.
func (r *Redis) SlaveOf(host, port string) error {
	rp, err := r.ExecuteCommand("SLAVEOF", host, port)
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// SlowLog is used in order to read and reset the Redis slow queries log.
type SlowLog struct {
	ID           int64
	Timestamp    int64
	Microseconds int64
	Command      []string
}

// SlowLogGet returns slow logs.
func (r *Redis) SlowLogGet(n int64) ([]*SlowLog, error) {
	rp, err := r.ExecuteCommand("SLOWLOG", "GET", n)
	if err != nil {
		return nil, err
	}
	if rp.Type == ErrorReply {
		return nil, errors.New(rp.Error)
	}
	if rp.Type != MultiReply {
		return nil, errors.New("slowlog get protocol error")
	}
	var slow []*SlowLog
	for _, subrp := range rp.Multi {
		if subrp.Multi == nil || len(subrp.Multi) != 4 {
			return nil, errors.New("slowlog get protocol error")
		}
		id, err := subrp.Multi[0].IntegerValue()
		if err != nil {
			return nil, err
		}
		timestamp, err := subrp.Multi[1].IntegerValue()
		if err != nil {
			return nil, err
		}
		microseconds, err := subrp.Multi[2].IntegerValue()
		if err != nil {
			return nil, err
		}
		command, err := subrp.Multi[3].ListValue()
		if err != nil {
			return nil, err
		}
		slow = append(slow, &SlowLog{id, timestamp, microseconds, command})
	}
	return slow, nil
}

// SlowLogLen Obtaining the current length of the slow log
func (r *Redis) SlowLogLen() (int64, error) {
	rp, err := r.ExecuteCommand("SLOWLOG", "LEN")
	if err != nil {
		return 0, err
	}
	return rp.IntegerValue()
}

// SlowLogReset resetting the slow log.
// Once deleted the information is lost forever.
func (r *Redis) SlowLogReset() error {
	rp, err := r.ExecuteCommand("SLOWLOG", "RESET")
	if err != nil {
		return err
	}
	return rp.OKValue()
}

// Time returns a multi bulk reply containing two elements:
// unix time in seconds,
// microseconds.
func (r *Redis) Time() ([]string, error) {
	rp, err := r.ExecuteCommand("TIME")
	if err != nil {
		return nil, err
	}
	return rp.ListValue()
}

// Command returns the Redis command info structures
func (r *Redis) Command() (comms []structures.CommandEntry, err error) {
	rp, err := r.ExecuteCommand("COMMAND")
	if err != nil {
		return nil, err
	}
	for _, subrp := range rp.Multi {
		name, _ := subrp.Multi[0].StringValue()
		arity, _ := subrp.Multi[1].IntegerValue()
		first, _ := subrp.Multi[3].IntegerValue()
		last, _ := subrp.Multi[4].IntegerValue()
		repeat, _ := subrp.Multi[5].IntegerValue()
		ce := structures.CommandEntry{Name: name, Arity: arity, FirstKey: first, LastKey: last, RepeatCount: repeat}
		flagmap := make(map[string]bool)
		for _, crp := range subrp.Multi[2].Multi {
			flag, _ := crp.StatusValue()
			flagmap[flag] = true
		}
		ce.Flags = flagmap
		comms = append(comms, ce)
	}
	return
}