func parseConfig()

in plugins/wasm-go/extensions/api-workflow/main.go [47:153]
94 lines of code
24 McCabe index (conditional complexity)

func parseConfig(json gjson.Result, c *PluginConfig, log wrapper.Log) error {

	edges := make([]Edge, 0)
	nodes := make(map[string]Node)
	var err error
	// env
	env := json.Get("env")
	// timeout
	c.Env.Timeout = uint32(env.Get("timeout").Int())
	if c.Env.Timeout == 0 {
		c.Env.Timeout = DefaultTimeout
	}
	// max_depth
	c.Env.MaxDepth = uint32(env.Get("max_depth").Int())
	if c.Env.MaxDepth == 0 {
		c.Env.MaxDepth = DefaultMaxDepth
	}
	// workflow
	workflow := json.Get("workflow")
	if !workflow.Exists() {
		return errors.New("workflow is empty")
	}
	// workflow.edges
	edges_ := workflow.Get("edges")
	if edges_.Exists() && edges_.IsArray() {
		for _, w := range edges_.Array() {
			task := Task{}
			edge := Edge{}
			edge.Source = w.Get("source").String()
			if edge.Source == "" {
				return errors.New("source is empty")
			}
			edge.Target = w.Get("target").String()
			if edge.Target == "" {
				return errors.New("target is empty")
			}
			edge.Task = &task

			edge.Conditional = w.Get("conditional").String()
			edges = append(edges, edge)
		}
	}
	c.Workflow.Edges = edges
	// workflow.nodes
	nodes_ := workflow.Get("nodes")
	if nodes_.Exists() && nodes_.IsArray() {
		for _, value := range nodes_.Array() {
			node := Node{}
			node.Name = value.Get("name").String()
			if node.Name == "" {
				return errors.New("tool name is empty")
			}
			node.ServiceName = value.Get("service_name").String()
			if node.ServiceName == "" {
				return errors.New("tool service name is empty")
			}
			node.ServicePort = value.Get("service_port").Int()
			if node.ServicePort == 0 {
				if strings.HasSuffix(node.ServiceName, ".static") {
					// use default logic port which is 80 for static service
					node.ServicePort = 80
				} else {
					return errors.New("tool service port is empty")
				}

			}
			node.ServiceDomain = value.Get("service_domain").String()
			node.ServicePath = value.Get("service_path").String()
			if node.ServicePath == "" {
				node.ServicePath = "/"
			}
			node.ServiceMethod = value.Get("service_method").String()
			if node.ServiceMethod == "" {
				return errors.New("service_method is empty")
			}
			serviceHeaders := value.Get("service_headers")
			if serviceHeaders.Exists() && serviceHeaders.IsArray() {
				serviceHeaders_ := []ServiceHeader{}
				err = ejson.Unmarshal([]byte(serviceHeaders.Raw), &serviceHeaders_)
				node.ServiceHeaders = serviceHeaders_
			}

			node.ServiceBodyTmpl = value.Get("service_body_tmpl").String()
			serviceBodyReplaceKeys := value.Get("service_body_replace_keys")
			if serviceBodyReplaceKeys.Exists() && serviceBodyReplaceKeys.IsArray() {
				serviceBodyReplaceKeys_ := []BodyReplaceKeyPair{}
				err = ejson.Unmarshal([]byte(serviceBodyReplaceKeys.Raw), &serviceBodyReplaceKeys_)
				node.ServiceBodyReplaceKeys = serviceBodyReplaceKeys_
				if err != nil {
					return fmt.Errorf("unmarshal service body replace keys failed, err:%v", err)
				}
			}

			nodes[node.Name] = node
		}
		c.Workflow.Nodes = nodes
		// workflow.WorkflowExecStatus
		c.Workflow.WorkflowExecStatus, err = initWorkflowExecStatus(c)
		log.Debugf("init status : %v", c.Workflow.WorkflowExecStatus)
		if err != nil {
			log.Errorf("init workflow exec status failed, err:%v", err)
			return fmt.Errorf("init workflow exec status failed, err:%v", err)
		}
	}
	log.Debugf("config : %v", c)
	return nil
}