Golang Backend.Redis方法代码示例

func addVM(backend env.Backend, params *AddVmParams) (result interface{}, err error) {
	redis := backend.Redis()
	defer redis.Close()

	nameLock := vmNameLock(params.Name)
	nameLocked, err := redis.Lock(nameLock)
	if err != nil || !nameLocked {
		return nil, fmt.Errorf("VM with name '%s' is already being created", params.Name)
	}
	defer redis.Unlock(nameLock)

	existing, err := redis.GetString("q:VM:name:" + params.Name)
	if existing != "" {
		return nil, fmt.Errorf("VM with name '%s' already exists", params.Name)
	}

	vm := &model.VM{
		ID:        model.NewGUID(),
		Name:      params.Name,
		MemSizeMB: params.MemSizeMB,
	}

	tx := redis.Tx().Begin()
	tx.Put(vm)
	err = tx.Commit()

	return "Created", err
}

func removeHostFromCluster(backend env.Backend, params ClusterHostParams) (result interface{}, err error) {
	conn := backend.Redis()
	defer conn.Close()

	hostID := config.Conf.HostID.String()
	conn.Send("MULTI")
	conn.Send("SREM", "Cluster:"+params.ClusterID, hostID)
	conn.Send("SREM", "Host:"+hostID+":clusters", params.ClusterID)
	_, err = conn.Do("EXEC")

	scheduler.StopListen(backend, params.ClusterID)

	return "Removed", err
}

func addHostToCluster(backend env.Backend, params ClusterHostParams) (result interface{}, err error) {
	conn := backend.Redis()
	defer conn.Close()

	hostID := config.Conf.HostID.String()

	conn.Send("MULTI")
	conn.Send("SADD", "Cluster:"+params.ClusterID, hostID)
	conn.Send("SADD", "Host:"+hostID+":clusters", params.ClusterID)
	_, err = conn.Do("EXEC")

	go scheduler.Listen(backend, params.ClusterID)

	return "Added", err
}

func Listen(backend env.Backend, queue string) {
	conn := backend.Redis()
	defer conn.Close()

	log.Println("Started listening on queue:", queue)

	for {
		values, err := redis.Values(conn.Do("BRPOP", queue, 0))
		if err != nil {
			log.Fatal(err)
		}

		body := values[1].([]byte)

		var request Request
		err = json.Unmarshal(body, &request)
		if err != nil {
			fmt.Println("command.Listen: received malformed response. Skipping.")
			continue
		}

		id := request.ID
		if id == "" {
			fmt.Println("command.Listen: Received a command without 'id'. Skipping")
			continue
		}

		name := request.Name
		if name == "" {
			respondError(conn, id, "Received a command without 'name'")
			continue
		}

		cmd := commands[name]
		if cmd == nil {
			respondError(conn, id, "Unknown command")
			continue
		}

		result, err := invokeCommandHandler(backend, cmd.handler, request.Params)
		if err != nil {
			respondError(conn, id, err.Error())
		} else {
			respondSuccess(conn, id, result)
		}
	}
}

func removeVM(backend env.Backend, params *IDParams) (result interface{}, err error) {
	conn := backend.Redis()
	defer conn.Close()

	exists, err := conn.Exists("VM:" + params.ID.String())
	if err != nil {
		return
	}
	if !exists {
		return nil, fmt.Errorf("VM with ID '%s' does not exist", params.ID)
	}

	tx := conn.Tx().Begin()
	tx.Delete(&model.VM{ID: params.ID})
	err = tx.Commit()

	return "Removed", err
}

func runVM(backend env.Backend, params *IDParams) (result interface{}, err error) {
	conn := backend.Redis()
	defer conn.Close()

	ok, err := conn.Exists("VM:" + params.ID.String())
	if err != nil {
		return
	}
	if !ok {
		return nil, fmt.Errorf("VM with ID '%s' does not exist", params.ID)
	}

	vm := &model.VM{ID: params.ID}
	err = conn.Get(vm)
	if err != nil {
		return
	}
	err = backend.Virt().StartVM(vm)
	return "Started", err
}

func Run(backend env.Backend, name string, params map[string]interface{}) (result map[string]interface{}, err error) {
	cmd := commands[name]
	if cmd == nil {
		return nil, fmt.Errorf(`command.Run: Unknown command: "%s"`, name)
	}
	request := Request{
		Name:   name,
		ID:     uuid.NewV4().String(),
		Params: params,
	}

	queue, err := queueByClass(cmd.Class, params)
	if err != nil {
		return nil, err
	}

	conn := backend.Redis()
	defer conn.Close()

	requestBody, err := json.Marshal(request)
	if err != nil {
		return nil, err
	}

	_, err = conn.Do("LPUSH", queue, requestBody)
	if err != nil {
		return nil, err
	}

	reply := replyQueue(request.ID)
	values, err := redis.Values(conn.Do("BRPOP", reply, config.Conf.CommandTimeout))
	if err != nil || values[0] == nil {
		return nil, TimedOut
	}

	response := values[1].([]byte)

	err = json.Unmarshal(response, &result)
	return
}

func updateVM(backend env.Backend, params *UpdateVmParams) (result interface{}, err error) {
	conn := backend.Redis()
	defer conn.Close()

	ok, err := conn.Exists("VM:" + params.ID.String())
	if err != nil {
		return
	}
	if !ok {
		return nil, fmt.Errorf("VM with ID '%s' does not exist", params.ID)
	}
	vm := &model.VM{
		ID:   params.ID,
		Name: params.Name,
	}

	tx := conn.Tx().Begin()
	tx.Put(vm)
	err = tx.Commit()

	return "Updated", err
}