func()

in pkg/controller/service/listeners.go [113:295]
163 lines of code
43 McCabe index (conditional complexity)

func (mgr *ListenerManager) buildListenerFromServicePort(reqCtx *RequestContext, port v1.ServicePort) (model.ListenerAttribute, error) {
	listener := model.ListenerAttribute{
		NamedKey: &model.ListenerNamedKey{
			Prefix:      model.DEFAULT_PREFIX,
			CID:         base.CLUSTER_ID,
			Namespace:   reqCtx.Service.Namespace,
			ServiceName: reqCtx.Service.Name,
			Port:        port.Port,
		},
		ListenerPort: int(port.Port),
	}

	listener.Description = listener.NamedKey.Key()
	listener.VGroupName = getVGroupNamedKey(reqCtx.Service, port).Key()

	proto, err := protocol(reqCtx.Anno.Get(ProtocolPort), port)
	if err != nil {
		return listener, err
	}
	listener.Protocol = proto

	if reqCtx.Anno.Get(VGroupPort) != "" {
		vGroupId, err := vgroup(reqCtx.Anno.Get(VGroupPort), port)
		if err != nil {
			return listener, err
		}
		listener.VGroupId = vGroupId
	}

	if reqCtx.Anno.Get(Scheduler) != "" {
		listener.Scheduler = reqCtx.Anno.Get(Scheduler)
	}

	if reqCtx.Anno.Get(PersistenceTimeout) != "" {
		timeout, err := strconv.Atoi(reqCtx.Anno.Get(PersistenceTimeout))
		if err != nil {
			return listener, fmt.Errorf("Annotation persistence timeout must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(PersistenceTimeout), err.Error())
		}
		listener.PersistenceTimeout = &timeout
	}

	if reqCtx.Anno.Get(CertID) != "" {
		listener.CertId = reqCtx.Anno.Get(CertID)
	}

	if reqCtx.Anno.Get(EnableHttp2) != "" {
		listener.EnableHttp2 = model.FlagType(reqCtx.Anno.Get(EnableHttp2))
	}

	if reqCtx.Anno.Get(ForwardPort) != "" && listener.Protocol == model.HTTP {
		forwardPort, err := forwardPort(reqCtx.Anno.Get(ForwardPort), int(port.Port))
		if err != nil {
			return listener, fmt.Errorf("Annotation ForwardPort error: %s ", err.Error())
		}
		listener.ForwardPort = forwardPort
		listener.ListenerForward = model.OnFlag
	}

	if reqCtx.Anno.Get(IdleTimeout) != "" {
		idleTimeout, err := strconv.Atoi(reqCtx.Anno.Get(IdleTimeout))
		if err != nil {
			return listener, fmt.Errorf("Annotation IdleTimeout must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(IdleTimeout), err.Error())
		}
		listener.IdleTimeout = idleTimeout
	}

	// acl
	if reqCtx.Anno.Get(AclStatus) != "" {
		listener.AclStatus = model.FlagType(reqCtx.Anno.Get(AclStatus))
	}
	if reqCtx.Anno.Get(AclType) != "" {
		listener.AclType = reqCtx.Anno.Get(AclType)
	}
	if reqCtx.Anno.Get(AclID) != "" {
		listener.AclId = reqCtx.Anno.Get(AclID)
	}

	// connection drain
	if reqCtx.Anno.Get(ConnectionDrain) != "" {
		listener.ConnectionDrain = model.FlagType(reqCtx.Anno.Get(ConnectionDrain))
	}
	if reqCtx.Anno.Get(ConnectionDrainTimeout) != "" {
		timeout, err := strconv.Atoi(reqCtx.Anno.Get(ConnectionDrainTimeout))
		if err != nil {
			return listener, fmt.Errorf("Annotation ConnectionDrainTimeout must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(ConnectionDrainTimeout), err.Error())
		}
		listener.ConnectionDrainTimeout = timeout
	}

	// cookie
	if reqCtx.Anno.Get(Cookie) != "" {
		listener.Cookie = reqCtx.Anno.Get(Cookie)
	}
	if reqCtx.Anno.Get(CookieTimeout) != "" {
		timeout, err := strconv.Atoi(reqCtx.Anno.Get(CookieTimeout))
		if err != nil {
			return listener, fmt.Errorf("Annotation CookieTimeout must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(CookieTimeout), err.Error())
		}
		listener.CookieTimeout = timeout
	}
	if reqCtx.Anno.Get(SessionStick) != "" {
		listener.StickySession = model.FlagType(reqCtx.Anno.Get(SessionStick))
	}
	if reqCtx.Anno.Get(SessionStickType) != "" {
		listener.StickySessionType = reqCtx.Anno.Get(SessionStickType)
	}

	// x-forwarded-for
	if reqCtx.Anno.Get(XForwardedForProto) != "" {
		listener.XForwardedForProto = model.FlagType(reqCtx.Anno.Get(XForwardedForProto))
	}

	// health check
	if reqCtx.Anno.Get(HealthyThreshold) != "" {
		t, err := strconv.Atoi(reqCtx.Anno.Get(HealthyThreshold))
		if err != nil {
			return listener, fmt.Errorf("Annotation HealthyThreshold must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(HealthyThreshold), err.Error())
		}
		listener.HealthyThreshold = t
	}
	if reqCtx.Anno.Get(UnhealthyThreshold) != "" {
		t, err := strconv.Atoi(reqCtx.Anno.Get(UnhealthyThreshold))
		if err != nil {
			return listener, fmt.Errorf("Annotation UnhealthyThreshold must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(UnhealthyThreshold), err.Error())
		}
		listener.UnhealthyThreshold = t
	}
	if reqCtx.Anno.Get(HealthCheckConnectTimeout) != "" {
		timeout, err := strconv.Atoi(reqCtx.Anno.Get(HealthCheckConnectTimeout))
		if err != nil {
			return listener, fmt.Errorf("Annotation HealthCheckConnectTimeout must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(HealthCheckConnectTimeout), err.Error())
		}
		listener.HealthCheckConnectTimeout = timeout
	}
	if reqCtx.Anno.Get(HealthCheckConnectPort) != "" {
		port, err := strconv.Atoi(reqCtx.Anno.Get(HealthCheckConnectPort))
		if err != nil {
			return listener, fmt.Errorf("Annotation HealthCheckConnectPort must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(HealthCheckConnectPort), err.Error())
		}
		listener.HealthCheckConnectPort = port
	}
	if reqCtx.Anno.Get(HealthCheckInterval) != "" {
		t, err := strconv.Atoi(reqCtx.Anno.Get(HealthCheckInterval))
		if err != nil {
			return listener, fmt.Errorf("Annotation HealthCheckInterval must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(HealthCheckInterval), err.Error())
		}
		listener.HealthCheckInterval = t
	}
	if reqCtx.Anno.Get(HealthCheckDomain) != "" {
		listener.HealthCheckDomain = reqCtx.Anno.Get(HealthCheckDomain)
	}
	if reqCtx.Anno.Get(HealthCheckURI) != "" {
		listener.HealthCheckURI = reqCtx.Anno.Get(HealthCheckURI)
	}
	if reqCtx.Anno.Get(HealthCheckHTTPCode) != "" {
		listener.HealthCheckHttpCode = reqCtx.Anno.Get(HealthCheckHTTPCode)
	}
	if reqCtx.Anno.Get(HealthCheckType) != "" {
		listener.HealthCheckType = reqCtx.Anno.Get(HealthCheckType)
	}
	if reqCtx.Anno.Get(HealthCheckFlag) != "" {
		listener.HealthCheck = model.FlagType(reqCtx.Anno.Get(HealthCheckFlag))
	}
	if reqCtx.Anno.Get(HealthCheckTimeout) != "" {
		timeout, err := strconv.Atoi(reqCtx.Anno.Get(HealthCheckTimeout))
		if err != nil {
			return listener, fmt.Errorf("Annotation HealthCheckTimeout must be integer, but got [%s]. message=[%s] ",
				reqCtx.Anno.Get(HealthCheckTimeout), err.Error())
		}
		listener.HealthCheckTimeout = timeout
	}

	return listener, nil
}