func()

in pkg/client/mock/stub_serverV2.go [197:281]

• 82 lines of code
• 17 McCabe index (conditional complexity)

func (s *StubServerV2) Actions(server proto.ElasticAgent_ActionsServer) error {
	var m sync.Mutex
	done := make(chan bool)
	go func() {
		for {
			select {
			case <-done:
				return
			case act := <-s.ActionsChan:
				id := uuid.Must(uuid.NewV4())
				m.Lock()
				s.SentActions[id.String()] = act
				m.Unlock()
				err := server.Send(&proto.ActionRequest{
					Type:     act.Type,
					Id:       id.String(),
					Name:     act.Name,
					Params:   act.Params,
					UnitId:   act.UnitID,
					UnitType: act.UnitType,
					Level:    act.Level,
				})
				if err != nil {
					panic(err)
				}
			}
		}
	}()
	defer close(done)

	for {
		response, err := server.Recv()
		if err != nil {
			return err
		}
		err = s.ActionImpl(response)
		if err != nil {
			// close connection to client
			return nil
		}
		m.Lock()
		action, ok := s.SentActions[response.Id]
		if !ok {
			// nothing to do, unknown action
			m.Unlock()
			continue
		}
		delete(s.SentActions, response.Id)
		m.Unlock()
		var result map[string]interface{}
		if response.Result != nil {
			err = json.Unmarshal(response.Result, &result)
			if err != nil {
				return err
			}
		}
		if action.Type == proto.ActionRequest_CUSTOM {
			if response.Status == proto.ActionResponse_FAILED {
				error, ok := result["error"]
				if ok {
					err = fmt.Errorf("%s", error)
				} else {
					err = fmt.Errorf("unknown error")
				}
				action.Callback(nil, err)
			} else {
				action.Callback(result, nil)
			}
		} else if action.Type == proto.ActionRequest_DIAGNOSTICS {
			if response.Status == proto.ActionResponse_FAILED {
				error, ok := result["error"]
				if ok {
					err = fmt.Errorf("%s", error)
				} else {
					err = fmt.Errorf("unknown error")
				}
				action.DiagCallback(nil, err)
			} else {
				action.DiagCallback(response.Diagnostic, nil)
			}
		} else {
			panic("unknown action type")
		}
	}
}