path_traversal.go

package util

import (
	"fmt"
	"github.com/openconfig/goyang/pkg/yang"
	"github.com/openconfig/ygot/ytypes"
	log "github.com/sirupsen/logrus"
	"strings"
)

const DELIM = "/"

type PathElement struct {
	Children []*PathElement
	Name     string
}

func (p *PathElement) Print() {
	printPE(0, p)
}

func printPE(indent int, pe *PathElement) {
	for i := 0; i < indent; i++ {
		fmt.Print("    ")
	}
	fmt.Println(pe.Name)
	if len(pe.Children) > 0 {
		for _, p := range pe.Children {
			printPE(indent+1, p)
		}
	}
}

func NewPaths() Paths {
	return make(map[string]*PathElement)
}

type Paths map[string]*PathElement

func processEntry(e *yang.Entry) *PathElement {
	if e.Dir != nil {
		elem := &PathElement{
			Children: make([]*PathElement, len(e.Dir)),
			Name:     e.Name,
		}
		i := 0
		for _, v := range e.Dir {
			elem.Children[i] = processEntry(v)
			i++
		}
		return elem
	}
	leaf := &PathElement{
		Name: e.Name,
	}
	return leaf
}

func (p Paths) ParseSchema(schema *ytypes.Schema, root string) error {
	tree := schema.SchemaTree
	for k, v := range tree {
		if v.Parent != nil {
			if v.Parent.Name == root {
				path := processEntry(v)
				p[k] = path
			}
		}
	}
	return nil
}

func (p Paths) StringBuilder() []string {
	paths := make([]string, 0)
	ch := make(chan string)
	stop := make(chan bool)
	val := make(chan []string)
	go appendix(ch, stop, val)
	for _, v := range p {
		var b strings.Builder
		stringBuilder(ch, &b, v)
	}
	stop <- true
	paths = <-val
	return paths
}

func appendix(c chan string, stop chan bool,p chan []string) {
	paths := make([]string, 0)
	var sig bool
	for {
		select {
		case path := <-c:
			paths = append(paths, path)
			log.Debug(path)
		case sig = <-stop:
			log.Debugf("Signal received: %v", sig)

		}
		if sig {break}
	}
	p <- paths
}

func stringBuilder(ch chan string, b *strings.Builder, v *PathElement) {
	if b.Len() == 0 {
		b.WriteString(DELIM)
	}
	b.WriteString(v.Name)
	if v.Children != nil {
		b.WriteString(DELIM)
		for _, c := range v.Children {
			var b_cpy strings.Builder
			b_cpy.WriteString(b.String())
			stringBuilder(ch, &b_cpy, c)
		}
	} else {
		log.Debug("leaf")
		ch <- b.String()
	}
}