mirror of
https://github.com/danderson/netboot.git
synced 2025-08-09 16:17:11 +02:00
103 lines
3.4 KiB
Go
103 lines
3.4 KiB
Go
package cli
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/spf13/cobra"
|
|
"go.universe.tf/netboot/dhcp6"
|
|
"go.universe.tf/netboot/dhcp6/pool"
|
|
"go.universe.tf/netboot/pixiecore"
|
|
"net"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// pixiecore ipv6api --listen-addr=2001:db8:f00f:cafe::4 --api-request-url=http://[2001:db8:f00f:cafe::4]:8888
|
|
|
|
var ipv6ApiCmd = &cobra.Command{
|
|
Use: "ipv6api",
|
|
Short: "Boot a kernel and optional init ramdisks over IPv6 using api",
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
addr, err := cmd.Flags().GetString("listen-addr")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
apiURL, err := cmd.Flags().GetString("api-request-url")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
apiTimeout, err := cmd.Flags().GetDuration("api-request-timeout")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
|
|
s := pixiecore.NewServerV6()
|
|
s.Log = logWithStdFmt
|
|
debug, err := cmd.Flags().GetBool("debug")
|
|
if err != nil {
|
|
s.Debug = logWithStdFmt
|
|
}
|
|
if debug {
|
|
s.Debug = logWithStdFmt
|
|
}
|
|
|
|
if addr == "" {
|
|
fatalf("Please specify address to bind to")
|
|
} else {
|
|
}
|
|
if apiURL == "" {
|
|
fatalf("Please specify ipxe config file url")
|
|
}
|
|
s.Address = addr
|
|
preference, err := cmd.Flags().GetUint8("preference")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
dnsServers, err := cmd.Flags().GetString("dns-servers")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
dnsServerAddresses := make([]net.IP, 0)
|
|
if cmd.Flags().Changed("dns-servers") {
|
|
for _, dnsServerAddress := range strings.Split(dnsServers, ",") {
|
|
dnsServerAddresses = append(dnsServerAddresses, net.ParseIP(dnsServerAddress))
|
|
}
|
|
}
|
|
s.BootConfig = pixiecore.MakeAPIBootConfiguration(apiURL, apiTimeout, preference,
|
|
cmd.Flags().Changed("preference"), dnsServerAddresses)
|
|
|
|
addressPoolStart, err := cmd.Flags().GetString("address-pool-start")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
addressPoolSize, err := cmd.Flags().GetUint64("address-pool-size")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
addressPoolValidLifetime, err := cmd.Flags().GetUint32("address-pool-lifetime")
|
|
if err != nil {
|
|
fatalf("Error reading flag: %s", err)
|
|
}
|
|
s.AddressPool = pool.NewRandomAddressPool(net.ParseIP(addressPoolStart), addressPoolSize, addressPoolValidLifetime)
|
|
s.PacketBuilder = dhcp6.MakePacketBuilder(addressPoolValidLifetime-addressPoolValidLifetime*3/100, addressPoolValidLifetime)
|
|
|
|
fmt.Println(s.Serve())
|
|
},
|
|
}
|
|
|
|
func serverv6APIConfigFlags(cmd *cobra.Command) {
|
|
cmd.Flags().StringP("listen-addr", "", "", "IPv6 address to listen on")
|
|
cmd.Flags().StringP("api-request-url", "", "", "Ipv6-specific API server url")
|
|
cmd.Flags().Duration("api-request-timeout", 5*time.Second, "Timeout for request to the API server")
|
|
cmd.Flags().Bool("debug", false, "Enable debug-level logging")
|
|
cmd.Flags().Uint8("preference", 255, "Set dhcp server preference value")
|
|
cmd.Flags().StringP("address-pool-start", "", "2001:db8:f00f:cafe:ffff::100", "Starting ip of the address pool, e.g. 2001:db8:f00f:cafe:ffff::100")
|
|
cmd.Flags().Uint64("address-pool-size", 50, "Address pool size")
|
|
cmd.Flags().Uint32("address-pool-lifetime", 1850, "Address pool ip address valid lifetime in seconds")
|
|
cmd.Flags().StringP("dns-servers", "", "", "Comma separated list of one or more dns server addresses")
|
|
}
|
|
|
|
func init() {
|
|
rootCmd.AddCommand(ipv6ApiCmd)
|
|
serverv6APIConfigFlags(ipv6ApiCmd)
|
|
}
|