func()

in pkg/jobmgr/tasksvc/handler.go [1252:1388]
124 lines of code
13 McCabe index (conditional complexity)

func (m *serviceHandler) BrowseSandbox(
	ctx context.Context,
	req *task.BrowseSandboxRequest) (resp *task.BrowseSandboxResponse, err error) {
	defer func() {
		headers := yarpcutil.GetHeaders(ctx)
		if err != nil || resp.GetError() != nil {
			entry := log.WithField("request", req).
				WithField("headers", headers)

			if err != nil {
				entry = entry.WithError(err)
			}
			if resp.GetError() != nil {
				entry = entry.WithField("browse_sandbox_err", resp.GetError().String())
			}
			entry.Warn("TaskManager.BrowseSandbox failed")
			return
		}

		log.WithField("request", req).
			WithField("headers", headers).
			Debug("TaskManager.BrowseSandbox succeeded")
	}()

	m.metrics.TaskAPIListLogs.Inc(1)

	jobConfig, err := handlerutil.GetJobConfigWithoutFillingCache(
		ctx, req.JobId, m.jobFactory, m.jobConfigOps)
	if err != nil {
		log.WithField("job_id", req.JobId.Value).
			WithError(err).
			Debug("Failed to get job config")
		m.metrics.TaskListLogsFail.Inc(1)
		return &task.BrowseSandboxResponse{
			Error: &task.BrowseSandboxResponse_Error{
				NotFound: &pb_errors.JobNotFound{
					Id:      req.JobId,
					Message: fmt.Sprintf("job %v not found, %v", req.JobId, err),
				},
			},
		}, nil
	}

	hostname, agentID, taskID, frameworkID, resp := m.getSandboxPathInfo(ctx,
		jobConfig.GetInstanceCount(), req)
	if resp != nil {
		return resp, nil
	}

	// Extract the IP address + port of the agent, if possible,
	// because the hostname may not be resolvable on the network
	agentIP := hostname
	agentPort := "5051"
	agentResponse, err := m.hostMgrClient.GetMesosAgentInfo(ctx,
		&hostsvc.GetMesosAgentInfoRequest{Hostname: hostname})
	if err == nil && len(agentResponse.Agents) > 0 {
		ip, port, err := util.ExtractIPAndPortFromMesosAgentPID(
			agentResponse.Agents[0].GetPid())
		if err == nil {
			agentIP = ip
			if port != "" {
				agentPort = port
			}
		}
	} else {
		log.WithField("hostname", hostname).Info(
			"Could not get Mesos agent info")
	}

	log.WithFields(log.Fields{
		"hostname":     hostname,
		"ip_address":   agentIP,
		"port":         agentPort,
		"agent_id":     agentID,
		"task_id":      taskID,
		"framework_id": frameworkID,
	}).Debug("Listing sandbox files")

	var logPaths []string
	logPaths, err = m.logManager.ListSandboxFilesPaths(m.mesosAgentWorkDir,
		frameworkID, agentIP, agentPort, agentID, taskID)

	if err != nil {
		m.metrics.TaskListLogsFail.Inc(1)
		log.WithError(err).WithFields(log.Fields{
			"req":          req,
			"hostname":     hostname,
			"ip_address":   agentIP,
			"port":         agentPort,
			"framework_id": frameworkID,
			"agent_id":     agentID,
		}).Error("failed to list slave logs files paths")
		return &task.BrowseSandboxResponse{
			Error: &task.BrowseSandboxResponse_Error{
				Failure: &task.BrowseSandboxFailure{
					Message: fmt.Sprintf(
						"get slave log failed on host:%s due to: %v",
						hostname,
						err,
					),
				},
			},
		}, nil
	}

	mesosMasterHostPortRespose, err := m.hostMgrClient.GetMesosMasterHostPort(ctx, &hostsvc.MesosMasterHostPortRequest{})
	if err != nil {
		m.metrics.TaskListLogsFail.Inc(1)
		log.WithError(err).WithFields(log.Fields{
			"req":          req,
			"hostname":     hostname,
			"framework_id": frameworkID,
			"agent_id":     agentID,
		}).Error("failed to list slave logs files paths")
		return &task.BrowseSandboxResponse{
			Error: &task.BrowseSandboxResponse_Error{
				Failure: &task.BrowseSandboxFailure{
					Message: fmt.Sprintf(
						"%v",
						err,
					),
				},
			},
		}, nil
	}

	m.metrics.TaskListLogs.Inc(1)
	resp = &task.BrowseSandboxResponse{
		Hostname:            agentIP,
		Port:                agentPort,
		Paths:               logPaths,
		MesosMasterHostname: mesosMasterHostPortRespose.Hostname,
		MesosMasterPort:     mesosMasterHostPortRespose.Port,
	}
	log.WithField("response", resp).Debug("TaskSVC.BrowseSandbox returned")
	return resp, nil
}