func getDetailServers()

in traffic_ops/traffic_ops_golang/server/detail.go [187:362]

• 168 lines of code
• 20 McCabe index (conditional complexity)

func getDetailServers(tx *sql.Tx, user *auth.CurrentUser, hostName string, physLocationID int, orderBy string, limit int, reqVersion api.Version) ([]tc.ServerDetailV40, error) {
	allowedOrderByCols := map[string]string{
		"":                "",
		"cachegroup":      "server.cachegroup",
		"cdn_name":        "cdn.name",
		"domain_name":     "server.domain_name",
		"guid":            "server.guid",
		"host_name":       "server.host_name",
		"https_port":      "server.https_port",
		"id":              "server.id",
		"ilo_ip_address":  "server.ilo_ip_address",
		"ilo_ip_gateway":  "server.ilo_ip_gateway",
		"ilo_ip_netmask":  "server.ilo_ip_netmask",
		"ilo_password":    "server.ilo_password",
		"ilo_username":    "server.ilo_username",
		"mgmt_ip_address": "server.mgmt_ip_address",
		"mgmt_ip_gateway": "server.mgmt_ip_gateway",
		"mgmt_ip_netmask": "server.mgmt_ip_netmask",
		"offline_reason":  "server.offline_reason",
		"phys_location":   "pl.name",
		"profile":         "p.name",
		"profile_desc":    "p.description",
		"rack":            "server.rack",
		"status":          "st.name",
		"tcp_port":        "server.tcp_port",
		"server_type":     "t.name",
		"xmpp_id":         "server.xmpp_id",
		"xmpp_passwd":     "server.xmpp_passwd",
	}
	orderBy, ok := allowedOrderByCols[orderBy]
	if !ok {
		return nil, errors.New("orderBy '" + orderBy + "' not permitted")
	}

	queryFormatString := `
SELECT
	server.id
	%v
FROM server
JOIN cachegroup cg ON server.cachegroup = cg.id
JOIN cdn ON server.cdn_id = cdn.id
JOIN phys_location pl ON server.phys_location = pl.id
JOIN profile p ON server.profile = p.id
JOIN status st ON server.status = st.id
JOIN type t ON server.type = t.id
`
	limitStr := ""
	if limit != 0 {
		limitStr = " LIMIT " + strconv.Itoa(limit)
	}
	orderByStr := ""
	if orderBy != "" {
		orderByStr = " ORDER BY " + orderBy
	}
	idRows, err := AddWhereClauseAndQuery(tx, fmt.Sprintf(queryFormatString, ""), hostName, physLocationID, orderByStr, limitStr)
	if err != nil {
		return nil, fmt.Errorf("querying delivery service eligible servers: %w", err)
	}
	defer log.Close(idRows, "getting IDs for server details names")
	var serverIDs []int
	for idRows.Next() {
		var serverID *int
		err := idRows.Scan(&serverID)
		if err != nil {
			return nil, fmt.Errorf("querying delivery service eligible server ids: %w", err)
		}
		serverIDs = append(serverIDs, *serverID)
	}
	serversMap, err := dbhelpers.GetServersInterfaces(serverIDs, tx)
	if err != nil {
		return nil, fmt.Errorf("unable to get server interfaces: %w", err)
	}
	rows, err := AddWhereClauseAndQuery(tx, fmt.Sprintf(queryFormatString, dataFetchQuery), hostName, physLocationID, orderByStr, limitStr)
	if err != nil {
		return nil, fmt.Errorf("querying detail servers: %w", err)
	}

	defer log.Close(rows, "getting server details data")
	sIDs := []int{}
	servers := []tc.ServerDetailV40{}

	serviceAddress := new(string)
	service6Address := new(string)
	serviceGateway := new(string)
	service6Gateway := new(string)
	serviceNetmask := new(string)
	serviceInterface := new(string)
	serviceMtu := new(string)

	for rows.Next() {
		s := tc.ServerDetailV40{}
		err = rows.Scan(
			&s.ID,
			&s.CacheGroup,
			&s.CDNName,
			pq.Array(&s.DeliveryServiceIDs),
			&s.DomainName,
			&s.GUID,
			&s.HostName,
			&s.HTTPSPort,
			&s.ILOIPAddress,
			&s.ILOIPGateway,
			&s.ILOIPNetmask,
			&s.ILOPassword,
			&s.ILOUsername,
			&serviceAddress,
			&service6Address,
			&serviceGateway,
			&service6Gateway,
			&serviceNetmask,
			&serviceInterface,
			&serviceMtu,
			&s.MgmtIPAddress,
			&s.MgmtIPGateway,
			&s.MgmtIPNetmask,
			&s.OfflineReason,
			&s.PhysLocation,
			pq.Array(&s.ProfileNames),
			&s.Rack,
			&s.Status,
			&s.TCPPort,
			&s.Type,
			&s.XMPPID,
			&s.XMPPPasswd,
		)
		if err != nil {
			return nil, fmt.Errorf("scanning detail server: %w", err)
		}
		s.ServerInterfaces = []tc.ServerInterfaceInfoV40{}
		if interfacesMap, ok := serversMap[*s.ID]; ok {
			for _, interfaceInfo := range interfacesMap {
				s.ServerInterfaces = append(s.ServerInterfaces, interfaceInfo)
			}
		}

		hiddenField := "********"
		if user.PrivLevel < auth.PrivLevelOperations {
			s.ILOPassword = &hiddenField
			s.XMPPPasswd = &hiddenField
		}

		servers = append(servers, s)
		sIDs = append(sIDs, *s.ID)
	}

	rows, err = tx.Query(`SELECT serverid, description, val from hwinfo where serverid = ANY($1);`, pq.Array(sIDs))
	if err != nil {
		return nil, fmt.Errorf("querying detail servers hardware info: %w", err)
	}
	defer log.Close(rows, "getting hwinfo data")
	hwInfos := map[int]map[string]string{}
	for rows.Next() {
		serverID := 0
		desc := ""
		val := ""
		if err := rows.Scan(&serverID, &desc, &val); err != nil {
			return nil, fmt.Errorf("scanning detail server hardware info: %w", err)
		}

		hwInfo, ok := hwInfos[serverID]
		if !ok {
			hwInfo = map[string]string{}
		}
		hwInfo[desc] = val
		hwInfos[serverID] = hwInfo
	}
	for i, server := range servers {
		hw, ok := hwInfos[*server.ID]
		if !ok {
			continue
		}
		server.HardwareInfo = hw
		servers[i] = server
	}
	return servers, nil
}