internal/pkg/commands/loglevel.go

/*
 * Copyright 2019-present Ciena Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package commands

import (
	"context"
	"fmt"
	"github.com/fullstorydev/grpcurl"
	flags "github.com/jessevdk/go-flags"
	"github.com/jhump/protoreflect/dynamic"
	"github.com/opencord/voltctl/pkg/format"
	"github.com/opencord/voltctl/pkg/model"
	"google.golang.org/grpc"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
	"strings"
)

type SetLogLevelOutput struct {
	ComponentName string
	Status        string
	Error         string
}

type SetLogLevelOpts struct {
	OutputOptions
	Package string `short:"p" long:"package" description:"Package name to set log level"`
	Args    struct {
		Level     string
		Component []string
	} `positional-args:"yes" required:"yes"`
}

type GetLogLevelsOpts struct {
	ListOutputOptions
	Args struct {
		Component []string
	} `positional-args:"yes" required:"yes"`
}

type ListLogLevelsOpts struct {
	ListOutputOptions
}

type LogLevelOpts struct {
	SetLogLevel   SetLogLevelOpts   `command:"set"`
	GetLogLevels  GetLogLevelsOpts  `command:"get"`
	ListLogLevels ListLogLevelsOpts `command:"list"`
}

var logLevelOpts = LogLevelOpts{}

const (
	DEFAULT_LOGLEVELS_FORMAT   = "table{{ .ComponentName }}\t{{.PackageName}}\t{{.Level}}"
	DEFAULT_SETLOGLEVEL_FORMAT = "table{{ .ComponentName }}\t{{.Status}}\t{{.Error}}"
)

func RegisterLogLevelCommands(parent *flags.Parser) {
	_, err := parent.AddCommand("loglevel", "loglevel commands", "Get and set log levels", &logLevelOpts)
	if err != nil {
		Error.Fatalf("Unable to register log level commands with voltctl command parser: %s", err.Error())
	}
}

func MapListAppend(m map[string][]string, name string, item string) {
	list, okay := m[name]
	if okay {
		m[name] = append(list, item)
	} else {
		m[name] = []string{item}
	}
}

/*
 * A roundabout way of going of using the LogLevel enum to map from
 * a string to an integer that we can pass into the dynamic
 * proto.
 *
 * TODO: There's probably an easier way.
 */
func LogLevelStringToInt(logLevelString string) (int32, error) {
	ProcessGlobalOptions() // required for GetMethod()

	/*
	 * Use GetMethod() to get us a descriptor on the proto file we're
	 * interested in.
	 */

	descriptor, _, err := GetMethod("update-log-level")
	if err != nil {
		return 0, err
	}

	/*
	 * Map string LogLevel to enumerated type LogLevel
	 * We have descriptor from above, which is a DescriptorSource
	 * We can use FindSymbol to get at the message
	 */

	loggingSymbol, err := descriptor.FindSymbol("common.LogLevel")
	if err != nil {
		return 0, err
	}

	/*
	 * LoggingSymbol is a Descriptor, but not a MessageDescrptior,
	 * so we can't look at it's fields yet. Go back to the file,
	 * call FindMessage to get the Message, then we can get the
	 * embedded enum.
	 */

	loggingFile := loggingSymbol.GetFile()
	logLevelMessage := loggingFile.FindMessage("common.LogLevel")
	logLevelEnumType := logLevelMessage.GetNestedEnumTypes()[0]
	enumLogLevel := logLevelEnumType.FindValueByName(logLevelString)

	if enumLogLevel == nil {
		return 0, fmt.Errorf("Unknown log level %s", logLevelString)
	}

	return enumLogLevel.GetNumber(), nil
}

// Validate a list of component names and throw an error if any one of them is bad.
func ValidateComponentNames(kube_to_arouter map[string][]string, names []string) error {
	var badNames []string
	for _, name := range names {
		_, ok := kube_to_arouter[name]
		if !ok {
			badNames = append(badNames, name)
		}
	}

	if len(badNames) > 0 {
		allowedNames := make([]string, len(kube_to_arouter))
		i := 0
		for k := range kube_to_arouter {
			allowedNames[i] = k
			i++
		}

		return fmt.Errorf("Unknown component(s): %s.\n  (Allowed values for component names: \n    %s)",
			strings.Join(badNames, ", "),
			strings.Join(allowedNames, ",\n    "))
	} else {
		return nil
	}
}

func BuildKubernetesNameMap() (map[string][]string, map[string]string, error) {
	kube_to_arouter := make(map[string][]string)
	arouter_to_kube := make(map[string]string)

	// use the current context in kubeconfig
	config, err := clientcmd.BuildConfigFromFlags("", GlobalOptions.K8sConfig)
	if err != nil {
		return nil, nil, err
	}

	// create the clientset
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		return nil, nil, err
	}

	pods, err := clientset.CoreV1().Pods("").List(metav1.ListOptions{
		LabelSelector: "app.kubernetes.io/part-of=voltha",
	})
	if err != nil {
		return nil, nil, err
	}

	if len(pods.Items) == 0 {
		return nil, nil, fmt.Errorf("No Voltha pods found in Kubernetes -- verify pod is setup")
	}

	for _, pod := range pods.Items {
		app, ok := pod.Labels["app"]
		if !ok {
			continue
		}

		var arouter_name string

		switch app {
		case "voltha-api-server":
			/*
			 * Assumes a single api_server for now.
			 * TODO: Make labeling changes in charts to be able to derive name from labels
			 */
			arouter_name = "api_server0.api_server01"
		case "rw-core":
			affinity_group, ok := pod.Labels["affinity-group"]
			if !ok {
				Warn.Printf("rwcore %s lacks affinity-group label", pod.Name)
				continue
			}
			affinity_group_core_id, ok := pod.Labels["affinity-group-core-id"]
			if !ok {
				Warn.Printf("rwcore %s lacks affinity-group-core-id label", pod.Name)
				continue
			}
			arouter_name = "vcore" + affinity_group + ".vcore" + affinity_group + affinity_group_core_id
		case "ro-core":
			/*
			 * Assumes a single rocore for now.
			 * TODO: Make labeling changes in charts to be able to derive name from labels
			 */
			arouter_name = "ro_vcore0.ro_vcore01"
		default:
			// skip this pod as it's not relevant
			continue
		}

		// Multiple ways to identify the component

		// 1) The pod name. One pod name maps to exactly one pod.

		arouter_to_kube[arouter_name] = pod.Name
		MapListAppend(kube_to_arouter, pod.Name, arouter_name)

		// 2) The kubernetes component name. A single component (i.e. "core") may map to multiple pods.

		component, ok := pod.Labels["app.kubernetes.io/component"]
		if ok {
			MapListAppend(kube_to_arouter, component, arouter_name)
		}

		// 3) The voltha app label. A single app (i.e. "rwcore") may map to multiple pods.

		MapListAppend(kube_to_arouter, app, arouter_name)

	}

	return kube_to_arouter, arouter_to_kube, nil
}

func (options *SetLogLevelOpts) Execute(args []string) error {
	if len(options.Args.Component) == 0 {
		return fmt.Errorf("Please specify at least one component")
	}

	kube_to_arouter, arouter_to_kube, err := BuildKubernetesNameMap()
	if err != nil {
		return err
	}

	var output []SetLogLevelOutput

	// Validate component names, throw error now to avoid doing partial work
	err = ValidateComponentNames(kube_to_arouter, options.Args.Component)
	if err != nil {
		return err
	}

	// Validate and map the logLevel string to an integer, throw error now to avoid doing partial work
	intLogLevel, err := LogLevelStringToInt(options.Args.Level)
	if err != nil {
		return err
	}

	for _, kubeComponentName := range options.Args.Component {
		var descriptor grpcurl.DescriptorSource
		var conn *grpc.ClientConn
		var method string

		componentNameList := kube_to_arouter[kubeComponentName]

		for _, componentName := range componentNameList {
			conn, err = NewConnection()
			if err != nil {
				return err
			}
			defer conn.Close()
			if strings.HasPrefix(componentName, "api_server") {
				// apiserver's UpdateLogLevel is in the afrouter.Configuration gRPC package
				descriptor, method, err = GetMethod("apiserver-update-log-level")
			} else {
				descriptor, method, err = GetMethod("update-log-level")
			}
			if err != nil {
				return err
			}

			ctx, cancel := context.WithTimeout(context.Background(), GlobalConfig.Grpc.Timeout)
			defer cancel()

			ll := make(map[string]interface{})
			ll["component_name"] = componentName
			ll["package_name"] = options.Package
			ll["level"] = intLogLevel

			h := &RpcEventHandler{
				Fields: map[string]map[string]interface{}{"common.Logging": ll},
			}
			err = grpcurl.InvokeRPC(ctx, descriptor, conn, method, []string{}, h, h.GetParams)
			if err != nil {
				return err
			}

			if h.Status != nil && h.Status.Err() != nil {
				output = append(output, SetLogLevelOutput{ComponentName: arouter_to_kube[componentName], Status: "Failure", Error: h.Status.Err().Error()})
				continue
			}

			output = append(output, SetLogLevelOutput{ComponentName: arouter_to_kube[componentName], Status: "Success"})
		}
	}

	outputFormat := CharReplacer.Replace(options.Format)
	if outputFormat == "" {
		outputFormat = GetCommandOptionWithDefault("loglevel-set", "format", DEFAULT_SETLOGLEVEL_FORMAT)
	}

	result := CommandResult{
		Format:    format.Format(outputFormat),
		OutputAs:  toOutputType(options.OutputAs),
		NameLimit: options.NameLimit,
		Data:      output,
	}

	GenerateOutput(&result)
	return nil
}

func (options *GetLogLevelsOpts) getLogLevels(methodName string, args []string) error {
	if len(options.Args.Component) == 0 {
		return fmt.Errorf("Please specify at least one component")
	}

	kube_to_arouter, arouter_to_kube, err := BuildKubernetesNameMap()
	if err != nil {
		return err
	}

	var data []model.LogLevel

	// Validate component names, throw error now to avoid doing partial work
	err = ValidateComponentNames(kube_to_arouter, options.Args.Component)
	if err != nil {
		return err
	}

	for _, kubeComponentName := range options.Args.Component {
		var descriptor grpcurl.DescriptorSource
		var conn *grpc.ClientConn
		var method string

		componentNameList := kube_to_arouter[kubeComponentName]

		for _, componentName := range componentNameList {
			conn, err = NewConnection()
			if err != nil {
				return err
			}
			defer conn.Close()
			if strings.HasPrefix(componentName, "api_server") {
				// apiserver's UpdateLogLevel is in the afrouter.Configuration gRPC package
				descriptor, method, err = GetMethod("apiserver-get-log-levels")
			} else {
				descriptor, method, err = GetMethod("get-log-levels")
			}
			if err != nil {
				return err
			}

			ctx, cancel := context.WithTimeout(context.Background(), GlobalConfig.Grpc.Timeout)
			defer cancel()

			ll := make(map[string]interface{})
			ll["component_name"] = componentName

			h := &RpcEventHandler{
				Fields: map[string]map[string]interface{}{"common.LoggingComponent": ll},
			}
			err = grpcurl.InvokeRPC(ctx, descriptor, conn, method, []string{}, h, h.GetParams)
			if err != nil {
				return err
			}

			if h.Status != nil && h.Status.Err() != nil {
				return h.Status.Err()
			}

			d, err := dynamic.AsDynamicMessage(h.Response)
			if err != nil {
				return err
			}
			items, err := d.TryGetFieldByName("items")
			if err != nil {
				return err
			}

			for _, item := range items.([]interface{}) {
				logLevel := model.LogLevel{}
				logLevel.PopulateFrom(item.(*dynamic.Message))
				logLevel.ComponentName = arouter_to_kube[logLevel.ComponentName]

				data = append(data, logLevel)
			}
		}
	}

	outputFormat := CharReplacer.Replace(options.Format)
	if outputFormat == "" {
		outputFormat = GetCommandOptionWithDefault(methodName, "format", DEFAULT_LOGLEVELS_FORMAT)
	}
	orderBy := options.OrderBy
	if orderBy == "" {
		orderBy = GetCommandOptionWithDefault(methodName, "order", "")
	}

	result := CommandResult{
		Format:    format.Format(outputFormat),
		Filter:    options.Filter,
		OrderBy:   orderBy,
		OutputAs:  toOutputType(options.OutputAs),
		NameLimit: options.NameLimit,
		Data:      data,
	}
	GenerateOutput(&result)
	return nil
}

func (options *GetLogLevelsOpts) Execute(args []string) error {
	return options.getLogLevels("loglevel-get", args)
}

func (options *ListLogLevelsOpts) Execute(args []string) error {
	var getOptions GetLogLevelsOpts
	var podNames []string

	_, arouter_to_kube, err := BuildKubernetesNameMap()
	if err != nil {
		return err
	}

	for _, podName := range arouter_to_kube {
		podNames = append(podNames, podName)
	}

	// Just call GetLogLevels with a list of podnames that includes everything relevant.

	getOptions.ListOutputOptions = options.ListOutputOptions
	getOptions.Args.Component = podNames

	return getOptions.getLogLevels("loglevel-list", args)
}