Added routing handler for webdav fs

def.go

@@ -0,0 +1,14 @@
+package main
+
+import "flag"
+
+var (
+	/* Start Flags */
+	httpPort    = flag.Int("p", 9000, "Port to serve on (Plain HTTP)")
+	devMode     = flag.Bool("dev", false, "Enable development mode")
+	config      = flag.String("c", "./config", "Path to the config folder")
+	serveSecure = flag.Bool("s", false, "Serve HTTPS. Default false")
+
+	/* Runtime Variables */
+
+)

go.mod

@@ -5,7 +5,10 @@ go 1.23.2
 require (
 	github.com/anatol/smart.go v0.0.0-20241126061019-f03d79b340d2
 	github.com/google/uuid v1.6.0
-	golang.org/x/net v0.35.0
+	golang.org/x/net v0.21.0
 )
 
-require golang.org/x/sys v0.30.0 // indirect
+require (
+	golang.org/x/crypto v0.33.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+)

go.sum

@@ -16,8 +16,8 @@ github.com/tmc/scp v0.0.0-20170824174625-f7b48647feef h1:7D6Nm4D6f0ci9yttWaKjM1T
 github.com/tmc/scp v0.0.0-20170824174625-f7b48647feef/go.mod h1:WLFStEdnJXpjK8kd4qKLwQKX/1vrDzp5BcDyiZJBHJM=
 golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
 golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
-golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

main.go

@@ -1,76 +1,89 @@
 package main
 
 import (
+	"embed"
 	"flag"
 	"fmt"
-	"strconv"
+	"io/fs"
+	"net/http"
+	"os"
 
 	"imuslab.com/bokofs/bokofsd/mod/bokofs"
 	"imuslab.com/bokofs/bokofsd/mod/bokofs/bokoworker"
 )
 
-func main() {
-
-	httpPort := flag.Int("p", 80, "Port to serve on (Plain HTTP)")
-	serveSecure := flag.Bool("s", false, "Serve HTTPS. Default false")
+//go:embed web/*
+var embeddedFiles embed.FS
 
+func main() {
 	flag.Parse()
 
-	//Create a test worker register at /test
-	testWorker, err := bokoworker.GetDefaultWorker("/teacat")
-	if err != nil {
-		panic(err)
+	var fileSystem http.FileSystem
+	if *devMode {
+		fmt.Println("Development mode enabled. Serving files from ./web directory.")
+		fileSystem = http.Dir("./web")
+	} else {
+		fmt.Println("Production mode enabled. Serving files from embedded filesystem.")
+		subFS, err := fs.Sub(embeddedFiles, "web")
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error accessing embedded subdirectory: %v\n", err)
+			os.Exit(1)
+		}
+		fileSystem = http.FS(subFS)
 	}
 
-	webdavHandler, err := bokofs.NewWebdavInterfaceServer(bokofs.Options{
-		ListeningAddress: ":" + strconv.Itoa(*httpPort),
-		SecureServe:      *serveSecure,
-	})
+	configFolderPath := "./config"
+	if *config != "" {
+		configFolderPath = *config
+	}
+	if _, err := os.Stat(configFolderPath); os.IsNotExist(err) {
+		fmt.Printf("Config folder does not exist. Creating folder at %s\n", configFolderPath)
+		if err := os.Mkdir(configFolderPath, os.ModePerm); err != nil {
+			fmt.Fprintf(os.Stderr, "Error creating config folder: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	//DEBUG
+	wds, err := bokofs.NewWebdavInterfaceServer("/disk/")
 	if err != nil {
 		panic(err)
 	}
 
-	webdavHandler.AddWorker(testWorker)
-
-	err = webdavHandler.Start()
+	test, err := bokoworker.NewWorker("test", "./web")
 	if err != nil {
 		panic(err)
 	}
+	wds.AddWorker(test)
 
-	fmt.Println("Bokofs daemon started")
-	select {}
-}
-
-/*
-//Get all the devices under /dev that is either sd or nvme
-	deviceFiles, err := os.ReadDir("/dev")
+	test2, err := bokoworker.NewWorker("test2", "./mod")
 	if err != nil {
 		panic(err)
 	}
-
-	for _, deviceFile := range deviceFiles {
-		if deviceFile.IsDir() {
-			continue
-		}
-
-		fullPath := "/dev/" + deviceFile.Name()
-		if !smart.IsRootDisk(fullPath) {
-			continue
-		}
-
-		if !smart.IsDiskSupportedType(fullPath) {
-			fmt.Println("Unsupported disk type")
-			continue
-		}
-		fmt.Println(fullPath)
-		//Get the SMART data printout in json
-		smartdata, err := smart.GetSMARTData(fullPath)
-		if err != nil {
-			fmt.Println(err)
-		}
-
-		js, _ := json.MarshalIndent(smartdata, "", " ")
-		fmt.Println(string(js))
-
+	wds.AddWorker(test2)
+
+	http.Handle("/", http.FileServer(fileSystem))
+	http.Handle("/disk/", wds.Handler())
+
+	http.Handle("/meta", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// TODO: Implement handler logic for /meta
+		fmt.Fprintln(w, "Meta handler not implemented yet")
+	}))
+
+	http.Handle("/cache", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// TODO: Implement handler logic for /cache
+		fmt.Fprintln(w, "Cache handler not implemented yet")
+	}))
+
+	http.Handle("/thumb", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// TODO: Implement handler logic for /thumb
+		fmt.Fprintln(w, "Thumb handler not implemented yet")
+	}))
+
+	addr := fmt.Sprintf(":%d", *httpPort)
+	fmt.Printf("Starting static web server on %s\n", addr)
+	if err := http.ListenAndServe(addr, nil); err != nil {
+		fmt.Fprintf(os.Stderr, "Error starting server: %v\n", err)
+		os.Exit(1)
 	}
-*/
+}

mod/bokofs/bokofs.go

@@ -1,13 +1,10 @@
 package bokofs
 
 import (
-	"context"
-	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"sync"
-	"time"
 
 	"golang.org/x/net/webdav"
 	"imuslab.com/bokofs/bokofsd/mod/bokofs/bokoworker"
@@ -20,28 +17,19 @@ import (
 	through the middle ware
 */
 
-type Options struct {
-	ListeningAddress string //Listening address, e.g. 0.0.0.0:8443
-	SecureServe      bool   //Use TLS to serve the WebDAV request
-	PublicKeyPath    string
-	PrivateKeyPath   string
-}
-
 type Server struct {
 	LoadedWorkers sync.Map //Storing uuid to bokoworker pointer (*bokoworker.Worker)
 	RootRouter    FlowRouter
-	Options       *Options
+	prefix        string
 }
 
 /* NewWebdavInterfaceServer creates a new WebDAV server instance */
-func NewWebdavInterfaceServer(options Options) (*Server, error) {
+func NewWebdavInterfaceServer(pathPrfix string) (*Server, error) {
 	thisServer := Server{
 		LoadedWorkers: sync.Map{},
-		Options:       &options,
+		prefix:        pathPrfix,
 	}
 
-	//TODO: Load all the middlewares
-
 	//Initiate the root router file system
 	err := thisServer.InitiateRootRouter()
 	if err != nil {
@@ -51,15 +39,20 @@ func NewWebdavInterfaceServer(options Options) (*Server, error) {
 	return &thisServer, nil
 }
 
-func (s *Server) AddWorker(worker *bokoworker.Worker) {
+func (s *Server) AddWorker(worker *bokoworker.Worker) error {
+	//Check if the worker root path is already loaded
+	if _, ok := s.LoadedWorkers.Load(worker.RootPath); ok {
+		return os.ErrExist
+	}
 	s.LoadedWorkers.Store(worker.RootPath, worker)
+	return nil
 }
 
 func (s *Server) RemoveWorker(workerRootPath string) {
 	s.LoadedWorkers.Delete(workerRootPath)
 }
 
-func (s *Server) Start() error {
+func (s *Server) Handler() http.Handler {
 	srv := &webdav.Handler{
 		FileSystem: s.RootRouter,
 		LockSystem: webdav.NewMemLS(),
@@ -71,46 +64,5 @@ func (s *Server) Start() error {
 			}
 		},
 	}
-
-	http.Handle("/", srv)
-
-	if s.Options.SecureServe {
-		if _, err := os.Stat(s.Options.PublicKeyPath); err != nil {
-			fmt.Println("Public ket not found")
-			return err
-		}
-		if _, err := os.Stat(s.Options.PrivateKeyPath); err != nil {
-			fmt.Println("Private key not found")
-			return err
-		}
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-	defer cancel()
-	done := make(chan error)
-
-	go func() {
-		if s.Options.SecureServe {
-			if err := http.ListenAndServeTLS(s.Options.ListeningAddress, s.Options.PublicKeyPath, s.Options.PrivateKeyPath, nil); err != nil {
-				done <- err
-			}
-		} else {
-			if err := http.ListenAndServe(s.Options.ListeningAddress, nil); err != nil {
-				log.Fatalf("Error with WebDAV server: %v", err)
-				done <- err
-			}
-		}
-	}()
-
-	select {
-	case <-ctx.Done():
-		//No error in 3 seconds. Assume all green
-		return nil
-	case success := <-done:
-		if success != nil {
-			log.Fatalf("Error with WebDAV server")
-			return success
-		}
-	}
-	return nil
+	return srv
 }

mod/bokofs/bokoworker/bokoworker.go

@@ -1,12 +1,9 @@
 package bokoworker
 
 import (
-	"encoding/json"
-	"os"
 	"path/filepath"
 	"strings"
 
-	"github.com/google/uuid"
 	"imuslab.com/bokofs/bokofsd/mod/bokofs/bokofile"
 )
 
@@ -31,20 +28,20 @@ type Worker struct {
 	Filesystem *bokofile.RouterDir
 }
 
-// GetDefaultWorker Generate and return a default worker serving ./ (CWD)
-func GetDefaultWorker(rootdir string) (*Worker, error) {
-	if !strings.HasPrefix(rootdir, "/") {
-		rootdir = "/" + rootdir
+// NewWorker Generate and return a webdav node that mounts a given path
+func NewWorker(nodeName string, mountPath string) (*Worker, error) {
+	if !strings.HasPrefix(nodeName, "/") {
+		nodeName = "/" + nodeName
 	}
 
-	mountPath, _ := filepath.Abs("./")
-	fs, err := bokofile.CreateRouterFromDir(mountPath, rootdir, false)
+	mountPath, _ = filepath.Abs(mountPath)
+	fs, err := bokofile.CreateRouterFromDir(mountPath, nodeName, false)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Worker{
-		RootPath:  rootdir,
+		RootPath:  nodeName,
 		DiskUUID:  "",
 		DiskPath:  "",
 		Subpath:   mountPath,
@@ -55,9 +52,10 @@ func GetDefaultWorker(rootdir string) (*Worker, error) {
 	}, nil
 }
 
+/*
 func GetWorkerFromConfig(configFilePath string) (*Worker, error) {
 	randomRootPath := uuid.New().String()
-	thisWorker, _ := GetDefaultWorker("/" + randomRootPath)
+	thisWorker, _ := NewWorker("/" + randomRootPath)
 	configFile, err := os.ReadFile(configFilePath)
 	if err != nil {
 		return nil, err
@@ -72,3 +70,4 @@ func GetWorkerFromConfig(configFilePath string) (*Worker, error) {
 	//TODO: Start the worker
 	return thisWorker, nil
 }
+*/

mod/bokofs/router.go

@@ -13,28 +13,44 @@ import (
 )
 
 type RootRouter struct {
-	parent *Server
+	pathPrefix string
+	parent     *Server
 }
 
 // InitiateRootRouter create and prepare a virtual root file system for
 // this bokoFS instance
 func (s *Server) InitiateRootRouter() error {
 	s.RootRouter = &RootRouter{
-		parent: s,
+		pathPrefix: s.prefix,
+		parent:     s,
 	}
 	return nil
 }
 
+// fixpath fix the path to be relative to the root path of this router
+func (r *RootRouter) fixpath(name string) string {
+	if name == r.pathPrefix || name == "" {
+		return "/"
+	}
+	//Trim off the prefix path
+	name = strings.TrimPrefix(name, r.pathPrefix)
+	if !strings.HasPrefix(name, "/") {
+		name = "/" + name
+	}
+	return name
+}
+
 func (r *RootRouter) GetRootDir(name string) string {
-	if name == "" {
+	if name == "" || name == "/" {
 		return "/"
 	}
+
 	name = filepath.ToSlash(filepath.Clean(name))
 	pathChunks := strings.Split(name, "/")
 	reqRootPath := "/" + pathChunks[1]
 	fmt.Println("Requesting Root Path: ", reqRootPath)
-	reqRootPath = strings.TrimSuffix(reqRootPath, "/")
-	return reqRootPath
+	name = strings.TrimSuffix(reqRootPath, "/")
+	return name
 }
 
 func (r *RootRouter) GetWorkerByPath(name string) (*bokoworker.Worker, error) {
@@ -49,12 +65,14 @@ func (r *RootRouter) GetWorkerByPath(name string) (*bokoworker.Worker, error) {
 
 func (r *RootRouter) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
 	// Implement the Mkdir method
+	name = r.fixpath(name)
 	fmt.Println("Mkdir called to " + name)
 	return nil
 }
 
 func (r *RootRouter) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
 	// Implement the OpenFile method
+	name = r.fixpath(name)
 	fmt.Println("OpenFile called to " + name)
 	if filepath.ToSlash(filepath.Base(name)) == "/" {
 		//Request to the vObject base path
@@ -79,20 +97,25 @@ func (r *RootRouter) OpenFile(ctx context.Context, name string, flag int, perm o
 
 func (r *RootRouter) RemoveAll(ctx context.Context, name string) error {
 	// Implement the RemoveAll method
+	name = r.fixpath(name)
 	fmt.Println("RemoveAll called to " + name)
 	return nil
 }
 
 func (r *RootRouter) Rename(ctx context.Context, oldName, newName string) error {
 	// Implement the Rename method
+	oldName = r.fixpath(oldName)
+	newName = r.fixpath(newName)
 	fmt.Println("Rename called from " + oldName + " to " + newName)
 	return nil
 }
 
 func (r *RootRouter) Stat(ctx context.Context, name string) (os.FileInfo, error) {
 	// Implement the Stat method
+	name = r.fixpath(name)
 	fmt.Println("Stat called to " + name)
 	if filepath.ToSlash(filepath.Base(name)) == "/" {
+		//Create an emulated file system to serve the mounted workers
 		thisVirtualObject := r.newVirtualObject(&vObjectProperties{
 			name:    name,
 			size:    0,
@@ -106,7 +129,9 @@ func (r *RootRouter) Stat(ctx context.Context, name string) (os.FileInfo, error)
 		return thisVirtualObjectFileInfo, nil
 	}
 
+	//Load the target worker from the path
 	targetWorker, err := r.GetWorkerByPath(name)
+	fmt.Println("Target Worker: ", targetWorker, name)
 	if err != nil {
 		return nil, err
 	}

mod/diskinfo/blkid/blkid.go

@@ -0,0 +1,118 @@
+package blkid
+
+import (
+	"bufio"
+	"errors"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type BlockDevice struct {
+	Device    string
+	UUID      string
+	BlockSize int
+	Type      string
+	PartUUID  string
+	PartLabel string
+}
+
+// GetBlockDevices retrieves block devices using the `blkid` command.
+func GetPartitionIdInfo() ([]BlockDevice, error) {
+	//Check if the current user have superuser privileges
+	cmd := exec.Command("id", "-u")
+	userIDOutput, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	// Check if the user ID is 0 (root)
+	// If not, run blkid without sudo
+	if strings.TrimSpace(string(userIDOutput)) == "0" {
+		cmd = exec.Command("blkid")
+	} else {
+		cmd = exec.Command("sudo", "blkid")
+	}
+
+	output, err := cmd.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	scanner := bufio.NewScanner(strings.NewReader(string(output)))
+	devices := []BlockDevice{}
+	re := regexp.MustCompile(`(\S+):\s+(.*)`)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		matches := re.FindStringSubmatch(line)
+		if len(matches) != 3 {
+			continue
+		}
+
+		device := matches[1]
+		attributes := matches[2]
+		deviceInfo := BlockDevice{Device: device}
+
+		for _, attr := range strings.Split(attributes, " ") {
+			kv := strings.SplitN(attr, "=", 2)
+			if len(kv) != 2 {
+				continue
+			}
+			key := kv[0]
+			value := strings.Trim(kv[1], `"`)
+
+			switch key {
+			case "UUID":
+				deviceInfo.UUID = value
+			case "BLOCK_SIZE":
+				// Convert block size to int if possible
+				blockSize, err := strconv.Atoi(value)
+				if err == nil {
+					deviceInfo.BlockSize = blockSize
+				} else {
+					deviceInfo.BlockSize = 0
+				}
+
+			case "TYPE":
+				deviceInfo.Type = value
+			case "PARTUUID":
+				deviceInfo.PartUUID = value
+			case "PARTLABEL":
+				deviceInfo.PartLabel = value
+			}
+		}
+
+		devices = append(devices, deviceInfo)
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return devices, nil
+}
+
+// GetBlockDeviceIDFromDevicePath retrieves block device information for a given device path.
+func GetPartitionIDFromDevicePath(devpath string) (*BlockDevice, error) {
+	devpath = strings.TrimPrefix(devpath, "/dev/")
+	if strings.Contains(devpath, "/") {
+		return nil, errors.New("invalid device path")
+	}
+
+	devpath = "/dev/" + devpath
+
+	devices, err := GetPartitionIdInfo()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, device := range devices {
+		if device.Device == devpath {
+			return &device, nil
+		}
+	}
+
+	return nil, errors.New("device not found")
+}

mod/diskinfo/diskinfo.go

@@ -0,0 +1,74 @@
+package diskinfo
+
+import (
+	"errors"
+	"os"
+
+	"imuslab.com/bokofs/bokofsd/mod/diskinfo/blkid"
+	"imuslab.com/bokofs/bokofsd/mod/diskinfo/lsblk"
+)
+
+// Disk represents a disk device with its attributes.
+type Disk struct {
+	UUID       string `json:"uuid"`
+	Name       string `json:"name"`
+	Path       string `json:"path"`
+	Size       int64  `json:"size"`
+	BlockSize  int    `json:"blocksize"`
+	BlockType  string `json:"blocktype"`
+	FsType     string `json:"fstype"`
+	MountPoint string `json:"mountpoint,omitempty"`
+}
+
+// Get a disk by its device path
+func NewDiskFromDevicePath(devpath string) (*Disk, error) {
+	if _, err := os.Stat(devpath); errors.Is(err, os.ErrNotExist) {
+		return nil, errors.New("device path does not exist")
+	}
+
+	//Create a new disk object
+	thisDisk := &Disk{
+		Path: devpath,
+	}
+
+	//Try to get the block device info
+	err := thisDisk.UpdateProperties()
+	if err != nil {
+		return nil, err
+	}
+
+	return thisDisk, nil
+}
+
+// UpdateProperties updates the properties of the disk.
+func (d *Disk) UpdateProperties() error {
+	//Try to get the block device info
+	blockDeviceInfo, err := lsblk.GetBlockDeviceInfoFromDevicePath(d.Path)
+	if err != nil {
+		return err
+	}
+
+	// Update the disk properties
+	d.Name = blockDeviceInfo.Name
+	d.Size = blockDeviceInfo.Size
+	d.BlockType = blockDeviceInfo.Type
+	d.MountPoint = blockDeviceInfo.MountPoint
+
+	if d.BlockType == "disk" {
+		//This block is a disk not a partition. There is no partition ID info
+		//So we can skip the blkid call
+		return nil
+	}
+
+	// Get the partition ID
+	diskIdInfo, err := blkid.GetPartitionIDFromDevicePath(d.Path)
+	if err != nil {
+		return err
+	}
+
+	// Update the disk properties with ID info
+	d.UUID = diskIdInfo.UUID
+	d.FsType = diskIdInfo.Type
+	d.BlockSize = diskIdInfo.BlockSize
+	return nil
+}

mod/diskinfo/lsblk/lsblk.go

@@ -0,0 +1,74 @@
+package lsblk
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+// BlockDevice represents a block device and its attributes.
+type BlockDevice struct {
+	Name       string        `json:"name"`
+	Size       int64         `json:"size"`
+	Type       string        `json:"type"`
+	MountPoint string        `json:"mountpoint,omitempty"`
+	Children   []BlockDevice `json:"children,omitempty"`
+}
+
+// parseLSBLKJSONOutput parses the JSON output of the `lsblk` command into a slice of BlockDevice structs.
+func parseLSBLKJSONOutput(output string) ([]BlockDevice, error) {
+	var result struct {
+		BlockDevices []BlockDevice `json:"blockdevices"`
+	}
+
+	err := json.Unmarshal([]byte(output), &result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse lsblk JSON output: %w", err)
+	}
+
+	return result.BlockDevices, nil
+}
+
+// GetLSBLKOutput runs the `lsblk` command with JSON output and returns its output as a slice of BlockDevice structs.
+func GetLSBLKOutput() ([]BlockDevice, error) {
+	cmd := exec.Command("lsblk", "-o", "NAME,SIZE,TYPE,MOUNTPOINT", "-b", "-J")
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		return nil, err
+	}
+
+	return parseLSBLKJSONOutput(out.String())
+}
+
+// GetBlockDeviceInfoFromDevicePath retrieves block device information for a given device path.
+func GetBlockDeviceInfoFromDevicePath(devname string) (*BlockDevice, error) {
+	devname = strings.TrimPrefix(devname, "/dev/")
+	if strings.Contains(devname, "/") {
+		return nil, fmt.Errorf("invalid device name: %s", devname)
+	}
+
+	// Get the block device info using lsblk
+	// and filter for the specified device name.
+	devices, err := GetLSBLKOutput()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get block device info: %w", err)
+	}
+
+	for _, device := range devices {
+		if device.Name == devname {
+			return &device, nil
+		} else if device.Children != nil {
+			for _, child := range device.Children {
+				if child.Name == devname {
+					return &child, nil
+				}
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("device %s not found", devname)
+}

web/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Hello World</title>
+</head>
+<body>
+    <h1>Hello, World!</h1>
+</body>
+</html>