Golang rpc.Transmitter類代碼示例

func subscribeReqHF(params interface{}, t *rpc.Transmitter) error {
	subscribeParams := params.(SubscribeParams)

	mask := maskFromTypes(subscribeParams.EventTypes)
	if mask == 0 {
		return rpc.NewArgsError(errors.New("Required at least 1 valid event type"))
	}

	subscriber := Subscriber{
		Id:      t.Channel.Id,
		Mask:    mask,
		Channel: t.Channel.Events,
	}
	// Check whether subscriber should see previous logs or not
	if subscribeParams.After == "" {
		if err := AddSubscriber(subscribeParams.Pid, subscriber); err != nil {
			return asRpcError(err)
		}
	} else {
		after, err := time.Parse(DateTimeFormat, subscribeParams.After)
		if err != nil {
			return rpc.NewArgsError(errors.New("Bad format of 'after', " + err.Error()))
		}
		if err := RestoreSubscriber(subscribeParams.Pid, subscriber, after); err != nil {
			return err
		}
	}
	t.Send(&SubscribeResult{
		Pid:        subscribeParams.Pid,
		EventTypes: subscribeParams.EventTypes,
		Text:       "Successfully subscribed",
	})
	return nil
}

func getProcessReqHF(body interface{}, t *rpc.Transmitter) error {
	params := body.(GetProcessParams)
	p, err := Get(params.Pid)
	if err != nil {
		return asRpcError(err)
	}
	t.Send(p)
	return nil
}

func unsubscribeReqHF(params interface{}, t *rpc.Transmitter) error {
	unsubscribeParams := params.(UnsubscribeParams)
	if err := RemoveSubscriber(unsubscribeParams.Pid, t.Channel.Id); err != nil {
		return asRpcError(err)
	}
	t.Send(&ProcessResult{
		Pid:  unsubscribeParams.Pid,
		Text: "Successfully unsubscribed",
	})
	return nil
}

func killProcessReqHF(params interface{}, t *rpc.Transmitter) error {
	killParams := params.(KillParams)
	if err := Kill(killParams.Pid); err != nil {
		return asRpcError(err)
	}
	t.Send(&ProcessResult{
		Pid:  killParams.Pid,
		Text: "Successfully killed",
	})
	return nil
}

func updateSubscriberReqHF(params interface{}, t *rpc.Transmitter) error {
	updateParams := params.(UpdateSubscriberParams)
	if updateParams.EventTypes == "" {
		return rpc.NewArgsError(errors.New("'eventTypes' required for subscriber update"))
	}
	if err := UpdateSubscriber(updateParams.Pid, t.Channel.Id, maskFromTypes(updateParams.EventTypes)); err != nil {
		return asRpcError(err)
	}
	t.Send(&SubscribeResult{
		Pid:        updateParams.Pid,
		EventTypes: updateParams.EventTypes,
		Text:       "Subscriber successfully updated",
	})
	return nil
}

func getProcessLogsReqHF(params interface{}, t *rpc.Transmitter) error {
	getLogsParams := params.(GetLogsParams)

	if getLogsParams.Skip < 0 {
		getLogsParams.Skip = 0
	}
	if getLogsParams.Limit < 0 {
		getLogsParams.Limit = 0
	}

	from, err := parseTime(getLogsParams.From, time.Time{})
	if err != nil {
		return rpc.NewArgsError(errors.New("Bad format of 'from', " + err.Error()))
	}

	till, err := parseTime(getLogsParams.Till, time.Now())
	if err != nil {
		return rpc.NewArgsError(errors.New("Bad format of 'till', " + err.Error()))
	}

	logs, err := ReadLogs(getLogsParams.Pid, from, till)
	if err != nil {
		return asRpcError(err)
	}

	limit := DefaultLogsPerPageLimit
	if getLogsParams.Limit != 0 {
		if limit < 1 {
			return rpc.NewArgsError(errors.New("Required 'limit' to be > 0"))
		}
		limit = getLogsParams.Limit
	}

	skip := 0
	if getLogsParams.Skip != 0 {
		if skip < 0 {
			return rpc.NewArgsError(errors.New("Required 'skip' to be >= 0"))
		}
		skip = getLogsParams.Skip
	}

	logsLen := len(logs)
	fromIdx := int(math.Max(float64(logsLen-limit-skip), 0))
	toIdx := logsLen - int(math.Min(float64(skip), float64(logsLen)))

	t.Send(logs[fromIdx:toIdx])
	return nil
}

func startProcessReqHF(params interface{}, t *rpc.Transmitter) error {
	startParams := params.(StartParams)
	command := Command{
		Name:        startParams.Name,
		CommandLine: startParams.CommandLine,
		Type:        startParams.Type,
	}
	if err := checkCommand(&command); err != nil {
		return rpc.NewArgsError(err)
	}

	_, err := NewBuilder().
		Cmd(command).
		FirstSubscriber(Subscriber{
			Id:      t.Channel.Id,
			Mask:    parseTypes(startParams.EventTypes),
			Channel: t.Channel.Events,
		}).
		BeforeEventsHook(func(process MachineProcess) {
			t.Send(process)
		}).
		Start()
	return err
}

func getProcessesReqHF(body interface{}, t *rpc.Transmitter) error {
	params := body.(GetProcessesParams)
	t.Send(GetProcesses(params.All))
	return nil
}