[webapp] Full Local Topology Support and Multi-IA Selection (#84)

* [webapp] Full Local Topology Support and Multi-IA Selection

- Removed use of gen/ia
- Scans local gen dir endhosts for all local IAs
- Allows local topology user to switch src IAs from nav bar.
- Allows local topology user to switch dest IAs from bwtest server.
- Saves src IA selection in persistent  user setting.
- Updates health checks to ignore gen/ia, using nav bar selection.
- Sorts paths tree list consistently by # hops.
- Adds full reverse-sorted list of server localhost IAs.
- Minor Go linting.

* Addresses comments from r1 review

* Addresses r2 comments + added missing IA error msg

Author: mwfarb

webapp/lib/config.go

@@ -1,15 +1,19 @@
 package lib
 
 import (
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"os"
 	"path"
+	"path/filepath"
+	"regexp"
 	"sort"
 	"strings"
 
+	log "github.com/inconshreveable/log15"
 	. "github.com/netsec-ethz/scion-apps/webapp/util"
 )
 
@@ -23,7 +27,6 @@ var LABROOT = "src/github.com/netsec-ethz/scion-apps"
 var GOPATH = os.Getenv("GOPATH")
 
 // default params for localhost testing
-var cliIaDef = "1-ff00:0:111"
 var serIaDef = "1-ff00:0:112"
 var cliPortDef = "30001"
 var serPortDefBwt = "30100"
@@ -36,18 +39,66 @@ var cfgFileSerUser = "config/servers_user.json"
 var cfgFileCliDef = "config/clients_default.json"
 var cfgFileSerDef = "config/servers_default.json"
 
-// GetLocalIa reads locally generated file for this IA's name, if written
-func GetLocalIa() string {
-	filepath := path.Join(GOPATH, SCIONROOT, "gen/ia")
-	b, err := ioutil.ReadFile(filepath)
-	if CheckError(err) {
-		return ""
+// UserSetting holds the serialized structure for persistent user settings
+type UserSetting struct {
+	MyIA string `json:"myIa"`
+}
+
+// WriteUserSetting writes the settings to disk.
+func WriteUserSetting(srcpath string, settings UserSetting) {
+	cliUserFp := path.Join(srcpath, cfgFileCliUser)
+	settingsJSON, _ := json.Marshal(settings)
+
+	err := ioutil.WriteFile(cliUserFp, settingsJSON, 0644)
+	CheckError(err)
+}
+
+// ReadUserSetting reads the settings from disk.
+func ReadUserSetting(srcpath string) UserSetting {
+	var settings UserSetting
+	cliUserFp := path.Join(srcpath, cfgFileCliUser)
+
+	// no problem when user settings not set yet
+	raw, err := ioutil.ReadFile(cliUserFp)
+	log.Debug("ReadClientsUser", "settings", string(raw))
+	if !CheckError(err) {
+		json.Unmarshal([]byte(raw), &settings)
 	}
-	return strings.Replace(strings.TrimSpace(string(b)), "_", ":", -1)
+	return settings
 }
 
-func GetCliIaDef() string {
-	return cliIaDef
+// ScanLocalIAs will load list of locally available IAs
+func ScanLocalIAs() []string {
+	var localIAs []string
+	var reIaFilePathCap = `\/ISD([0-9]+)\/AS(\w+)`
+	re := regexp.MustCompile(reIaFilePathCap)
+	var searchPath = path.Join(GOPATH, SCIONROOT, "gen")
+	filepath.Walk(searchPath, func(path string, f os.FileInfo, _ error) error {
+		if f != nil && f.IsDir() {
+			capture := re.FindStringSubmatch(path)
+			if len(capture) > 0 {
+				ia := capture[1] + "-" + capture[2]
+				ia = strings.Replace(ia, "_", ":", -1) // convert once
+				if !StringInSlice(localIAs, ia) {
+					log.Debug("Local IA Found:", "ia", ia)
+					localIAs = append(localIAs, ia)
+				}
+			}
+		}
+		return nil
+	})
+	sort.Strings(localIAs)
+	return localIAs
+}
+
+// StringInSlice can check a slice for a unique string
+func StringInSlice(arr []string, i string) bool {
+	for _, v := range arr {
+		if v == i {
+			return true
+		}
+	}
+	return false
 }
 
 // Makes interfaces sortable, by preferred name
@@ -87,39 +138,31 @@ func (c byPrefInterface) Less(i, j int) bool {
 }
 
 // GenServerNodeDefaults creates server defaults for localhost testing
-func GenServerNodeDefaults(srcpath string) {
+func GenServerNodeDefaults(srcpath string, localIAs []string) {
+	// reverse sort so that the default server will oppose the default client
+	sort.Sort(sort.Reverse(sort.StringSlice(localIAs)))
+
 	serFp := path.Join(srcpath, cfgFileSerUser)
-	jsonBuf := []byte(`{ `)
-	json := []byte(`"bwtester": [{"name":"lo ` + serIaDef + `","isdas":"` +
-		serIaDef + `", "addr":"` + serDefAddr + `","port":` + serPortDefBwt +
-		`},{"name":"lo 2-ff00:0:222","isdas":"2-ff00:0:222", "addr":"127.0.0.22","port":30101}], `)
-	jsonBuf = append(jsonBuf, json...)
-	json = []byte(`"camerapp": [{"name":"localhost","isdas":"` +
-		serIaDef + `", "addr":"` + serDefAddr + `","port":` + serPortDefImg + `}], `)
-	jsonBuf = append(jsonBuf, json...)
-	json = []byte(`"sensorapp": [{"name":"localhost","isdas":"` +
-		serIaDef + `", "addr":"` + serDefAddr + `","port":` + serPortDefSen + `}], `)
-	jsonBuf = append(jsonBuf, json...)
-	json = []byte(`"echo": [{"name":"localhost","isdas":"` +
-		serIaDef + `", "addr":"` + serDefAddr + `","port":` + serPortDefSen + `}], `)
-	jsonBuf = append(jsonBuf, json...)
-	json = []byte(`"traceroute": [{"name":"localhost","isdas":"` +
-		serIaDef + `", "addr":"` + serDefAddr + `","port":` + serPortDefSen + `}]`)
-	jsonBuf = append(jsonBuf, json...)
-
-	jsonBuf = append(jsonBuf, []byte(` }`)...)
+	jsonBuf := []byte(`{ "all": [`)
+	for i := 0; i < len(localIAs); i++ {
+		// use all localhost endpoints as possible servers for bwtester as least
+		ia := strings.Replace(localIAs[i], "_", ":", -1)
+		json := []byte(`{"name":"lo ` + ia + `","isdas":"` + ia +
+			`", "addr":"` + serDefAddr + `","port":` + serPortDefBwt + `}`)
+		jsonBuf = append(jsonBuf, json...)
+		if i < (len(localIAs) - 1) {
+			jsonBuf = append(jsonBuf, []byte(`,`)...)
+		}
+	}
+	jsonBuf = append(jsonBuf, []byte(`] }`)...)
 	err := ioutil.WriteFile(serFp, jsonBuf, 0644)
 	CheckError(err)
 }
 
 // GenClientNodeDefaults queries network interfaces and writes local client
 // SCION addresses as json
-func GenClientNodeDefaults(srcpath string) {
+func GenClientNodeDefaults(srcpath, cisdas string) {
 	cliFp := path.Join(srcpath, cfgFileCliDef)
-	cisdas := GetLocalIa()
-	if len(cisdas) == 0 {
-		cisdas = cliIaDef
-	}
 	cport := cliPortDef
 
 	// find interface addresses

webapp/lib/health.go

@@ -44,7 +44,7 @@ type ResHealthCheck struct {
 
 // HealthCheckHandler handles calling the default health-check scripts and
 // returning the json-formatted results of each script.
-func HealthCheckHandler(w http.ResponseWriter, r *http.Request, srcpath string) {
+func HealthCheckHandler(w http.ResponseWriter, r *http.Request, srcpath string, ia string) {
 	hcResFp := path.Join(srcpath, resFileHealthCheck)
 	// read specified tests from json definition
 	fp := path.Join(srcpath, defFileHealthCheck)
@@ -78,7 +78,7 @@ func HealthCheckHandler(w http.ResponseWriter, r *http.Request, srcpath string)
 		pass := true
 		log.Info(test.Script + ": " + test.Desc)
 		// execute script
-		cmd := exec.Command("bash", test.Script)
+		cmd := exec.Command("bash", test.Script, ia)
 		cmd.Dir = filepath.Dir(fp)
 		var stdout, stderr bytes.Buffer
 		cmd.Stdout = &stdout

webapp/lib/sciond.go

@@ -13,15 +13,16 @@ import (
 	"path"
 	"path/filepath"
 	"runtime"
+	"sort"
 	"strconv"
 	"strings"
 
 	log "github.com/inconshreveable/log15"
+	"github.com/netsec-ethz/scion-apps/lib/scionutil"
 	pathdb "github.com/netsec-ethz/scion-apps/webapp/models/path"
 	. "github.com/netsec-ethz/scion-apps/webapp/util"
 	"github.com/scionproto/scion/go/lib/addr"
 	"github.com/scionproto/scion/go/lib/common"
-	"github.com/scionproto/scion/go/lib/sciond"
 	"github.com/scionproto/scion/go/lib/snet"
 	"github.com/scionproto/scion/go/lib/spath/spathmeta"
 	"github.com/scionproto/scion/go/proto"
@@ -38,14 +39,14 @@ func returnError(w http.ResponseWriter, err error) {
 	fmt.Fprintf(w, `{"err":`+strconv.Quote(err.Error())+`}`)
 }
 
-func returnPathHandler(w http.ResponseWriter, pathJson []byte, segJson []byte, err error) {
+func returnPathHandler(w http.ResponseWriter, pathJSON []byte, segJSON []byte, err error) {
 	var buffer bytes.Buffer
 	buffer.WriteString(`{"src":"sciond"`)
-	if pathJson != nil {
-		buffer.WriteString(fmt.Sprintf(`,"paths":%s`, pathJson))
+	if pathJSON != nil {
+		buffer.WriteString(fmt.Sprintf(`,"paths":%s`, pathJSON))
 	}
-	if segJson != nil {
-		buffer.WriteString(fmt.Sprintf(`,"segments":%s`, segJson))
+	if segJSON != nil {
+		buffer.WriteString(fmt.Sprintf(`,"segments":%s`, segJSON))
 	}
 	if err != nil {
 		buffer.WriteString(fmt.Sprintf(`,"err":%s`, strconv.Quote(err.Error())))
@@ -54,6 +55,26 @@ func returnPathHandler(w http.ResponseWriter, pathJson []byte, segJson []byte, e
 	fmt.Fprintf(w, buffer.String())
 }
 
+func getNetworkByIA(iaCli string) (*snet.SCIONNetwork, error) {
+	ia, err := addr.IAFromString(iaCli)
+	if CheckError(err) {
+		return nil, err
+	}
+	dispatcherPath := "/run/shm/dispatcher/default.sock"
+	sciondPath := scionutil.GetSCIONDPath(&ia)
+	if snet.DefNetwork == nil {
+		err := snet.Init(ia, sciondPath, dispatcherPath)
+		if CheckError(err) {
+			return nil, err
+		}
+	}
+	network, err := snet.NewNetwork(ia, sciondPath, dispatcherPath)
+	if CheckError(err) {
+		return nil, err
+	}
+	return network, nil
+}
+
 // sciond data sources and calls
 
 // PathTopoHandler handles requests for paths, returning results from sciond.
@@ -76,25 +97,13 @@ func PathTopoHandler(w http.ResponseWriter, r *http.Request) {
 	clientCCAddr, _ := snet.AddrFromString(optClient)
 	serverCCAddr, _ := snet.AddrFromString(optServer)
 
-	if snet.DefNetwork == nil {
-		dispatcherPath := "/run/shm/dispatcher/default.sock"
-
-		var sciondPath string
-		isdCli, _ := strconv.Atoi(strings.Split(CIa, "-")[0])
-		if isdCli < 16 {
-			sciondPath = sciond.GetDefaultSCIONDPath(&clientCCAddr.IA)
-		} else {
-			sciondPath = sciond.GetDefaultSCIONDPath(nil)
-		}
-
-		err := snet.Init(clientCCAddr.IA, sciondPath, dispatcherPath)
-		if CheckError(err) {
-			returnError(w, err)
-			return
-		}
+	network, err := getNetworkByIA(CIa)
+	if CheckError(err) {
+		returnError(w, err)
+		return
 	}
 
-	paths, err := getPathsJSON(*clientCCAddr, *serverCCAddr)
+	paths, err := getPathsJSON(*clientCCAddr, *serverCCAddr, *network)
 	if CheckError(err) {
 		returnError(w, err)
 		return
@@ -138,6 +147,16 @@ func getSegmentsJSON(local snet.Addr) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
+	sort.Slice(segments, func(i, j int) bool {
+		// sort by segment type, then shortest # hops
+		if segments[i].SegType < segments[j].SegType {
+			return true
+		}
+		if segments[i].SegType > segments[j].SegType {
+			return false
+		}
+		return len(segments[i].Interfaces) < len(segments[j].Interfaces)
+	})
 	jsonSegsInfo, err := json.Marshal(segments)
 	if err != nil {
 		return nil, err
@@ -196,8 +215,8 @@ func removeAllDir(dirName string) {
 	CheckError(err)
 }
 
-func getPathsJSON(local snet.Addr, remote snet.Addr) ([]byte, error) {
-	pathMgr := snet.DefNetwork.PathResolver()
+func getPathsJSON(local snet.Addr, remote snet.Addr, network snet.SCIONNetwork) ([]byte, error) {
+	pathMgr := network.PathResolver()
 	pathSet := pathMgr.Query(context.Background(), local.IA, remote.IA)
 	if len(pathSet) == 0 {
 		return nil, fmt.Errorf("No paths from %s to %s", local.IA, remote.IA)
@@ -206,6 +225,16 @@ func getPathsJSON(local snet.Addr, remote snet.Addr) ([]byte, error) {
 	for _, path := range pathSet {
 		appPaths = append(appPaths, path)
 	}
+	sort.Slice(appPaths, func(i, j int) bool {
+		// sort by shortest # hops, then by IA/interface
+		if len(appPaths[i].Entry.Path.Interfaces) < len(appPaths[j].Entry.Path.Interfaces) {
+			return true
+		}
+		if len(appPaths[i].Entry.Path.Interfaces) > len(appPaths[j].Entry.Path.Interfaces) {
+			return false
+		}
+		return appPaths[i].Entry.String() < appPaths[j].Entry.String()
+	})
 	jsonPathInfo, err := json.Marshal(appPaths)
 	if err != nil {
 		return nil, err
@@ -217,30 +246,13 @@ func getPathsJSON(local snet.Addr, remote snet.Addr) ([]byte, error) {
 func AsTopoHandler(w http.ResponseWriter, r *http.Request) {
 	r.ParseForm()
 	CIa := r.PostFormValue("src")
-	ia, err := addr.IAFromString(CIa)
+
+	network, err := getNetworkByIA(CIa)
 	if CheckError(err) {
 		returnError(w, err)
 		return
 	}
-	if snet.DefNetwork == nil {
-		dispatcherPath := "/run/shm/dispatcher/default.sock"
-
-		var sciondPath string
-		isdCli, _ := strconv.Atoi(strings.Split(CIa, "-")[0])
-		if isdCli < 16 {
-			sciondPath = sciond.GetDefaultSCIONDPath(&ia)
-		} else {
-			sciondPath = sciond.GetDefaultSCIONDPath(nil)
-		}
-
-		err := snet.Init(ia, sciondPath, dispatcherPath)
-		if CheckError(err) {
-			returnError(w, err)
-			return
-		}
-	}
-
-	c := snet.DefNetwork.Sciond()
+	c := network.Sciond()
 
 	asir, err := c.ASInfo(context.Background(), addr.IA{})
 	if CheckError(err) {

webapp/models/path/db.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 )
 
+// InitDB controls the opening connection to the database.
 func InitDB(filepath string) (*sql.DB, error) {
 	//var err error
 	db, err := sql.Open("sqlite3", filepath+"?mode=ro")
@@ -17,6 +18,7 @@ func InitDB(filepath string) (*sql.DB, error) {
 	return db, nil
 }
 
+// CloseDB will close the database, only use when app closes.
 func CloseDB(db *sql.DB) error {
 	err := db.Close()
 	return err

webapp/models/path/segments.go

@@ -56,6 +56,7 @@ func newSegment(segType proto.PathSegType, srcI addr.ISD, srcA addr.AS, dstI add
 		Interfaces: interfaces, Updated: time.Unix(0, updateTime), Expiry: time.Unix(expiryTime, 0)}
 }
 
+// ReadSegTypesAll operates on the DB to return all SegType rows.
 func ReadSegTypesAll(db *sql.DB) (map[int64]proto.PathSegType, error) {
 	sqlReadAll := `
     SELECT
@@ -84,6 +85,7 @@ func ReadSegTypesAll(db *sql.DB) (map[int64]proto.PathSegType, error) {
 	return result, nil
 }
 
+// ReadIntfToSegAll operates on the DB to return all IntfToSeg rows.
 func ReadIntfToSegAll(db *sql.DB) (map[int64][]asIface, error) {
 	sqlReadAll := `
     SELECT
@@ -118,6 +120,7 @@ func ReadIntfToSegAll(db *sql.DB) (map[int64][]asIface, error) {
 	return result, nil
 }
 
+// ReadSegmentsAll operates on the DB to return all Segments rows.
 func ReadSegmentsAll(db *sql.DB, segTypes map[int64]proto.PathSegType) ([]segment, error) {
 	sqlReadAll := `
     SELECT