func doInitExtensions()

in lambda/rapid/handlers.go [131:188]
47 lines of code
8 McCabe index (conditional complexity)

func doInitExtensions(domain string, agentPaths []string, execCtx *rapidContext, env *env.Environment) error {
	initFlow := execCtx.registrationService.InitFlow()

	// we don't bring it into the loop below because we don't want unnecessary broadcasts on agent gate
	if err := initFlow.SetExternalAgentsRegisterCount(uint16(len(agentPaths))); err != nil {
		return err
	}

	for _, agentPath := range agentPaths {
		// Using path.Base(agentPath) not agentName because the agent name is contact, as standalone can get the internal state.
		agent, err := execCtx.registrationService.CreateExternalAgent(path.Base(agentPath))
		if err != nil {
			return err
		}

		if execCtx.registrationService.CountAgents() > core.MaxAgentsAllowed {
			agentLaunchError(agent, execCtx.appCtx, core.ErrTooManyExtensions)
			return core.ErrTooManyExtensions
		}

		env := env.AgentExecEnv()

		agentStdoutWriter, agentStderrWriter, err := execCtx.logsEgressAPI.GetExtensionSockets()
		if err != nil {
			return err
		}
		agentName := fmt.Sprintf("extension-%s-%d", path.Base(agentPath), execCtx.runtimeDomainGeneration)

		err = execCtx.supervisor.Exec(context.Background(), &supvmodel.ExecRequest{
			Domain: domain,
			Name:   agentName,
			Path:   agentPath,
			Env:    &env,
			Logging: supvmodel.Logging{
				Managed: supvmodel.ManagedLogging{
					Topic: supvmodel.RtExtensionManagedLoggingTopic,
					Formats: []supvmodel.ManagedLoggingFormat{
						supvmodel.LineBasedManagedLogging,
					},
				},
			},
			StdoutWriter: agentStdoutWriter,
			StderrWriter: agentStderrWriter,
		})
		if err != nil {
			agentLaunchError(agent, execCtx.appCtx, err)
			return err
		}

		execCtx.shutdownContext.createExitedChannel(agentName)
	}

	if err := initFlow.AwaitExternalAgentsRegistered(); err != nil {
		return err
	}

	return nil
}