134 lines
3.9 KiB
Go
134 lines
3.9 KiB
Go
package main
|
|
|
|
import (
|
|
_ "embed"
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
var log = logrus.New()
|
|
|
|
func usage() {
|
|
fmt.Printf("Usage: %s [OPTIONS] version\n", path.Base(os.Args[0]))
|
|
fmt.Printf("version can be a specific version or '%s' (default) for the latest UniFi Controller version\n", LatestVersionMarker)
|
|
flag.PrintDefaults()
|
|
}
|
|
|
|
func setupLogging(debugEnabled, traceEnabled bool) {
|
|
log.SetFormatter(&logrus.TextFormatter{
|
|
DisableTimestamp: true,
|
|
DisableLevelTruncation: true,
|
|
ForceColors: true,
|
|
FullTimestamp: false,
|
|
})
|
|
if traceEnabled {
|
|
log.SetLevel(logrus.TraceLevel)
|
|
} else if debugEnabled {
|
|
log.SetLevel(logrus.DebugLevel)
|
|
} else {
|
|
log.SetLevel(logrus.InfoLevel)
|
|
}
|
|
}
|
|
|
|
type options struct {
|
|
versionBaseDir string
|
|
outputDir string
|
|
downloadOnly bool
|
|
version string
|
|
firmwareUpdateApi string
|
|
}
|
|
|
|
func main() {
|
|
flag.Usage = usage
|
|
|
|
versionBaseDirFlag := flag.String("version-base-dir", ".", "The base directory for version JSON files")
|
|
outputDirFlag := flag.String("output-dir", ".", "The output directory of the generated Go code")
|
|
downloadOnly := flag.Bool("download-only", false, "Only download and build the API structures JSON directory, do not generate")
|
|
debugFlag := flag.Bool("debug", false, "Enable debug logging")
|
|
traceFlag := flag.Bool("trace", false, "Enable trace logging")
|
|
|
|
flag.CommandLine.Init(os.Args[0], flag.PanicOnError) // set error handling to panic if parse ends with error
|
|
flag.Parse()
|
|
setupLogging(*debugFlag, *traceFlag)
|
|
specifiedVersion := strings.TrimSpace(flag.Arg(0))
|
|
if specifiedVersion == "" {
|
|
specifiedVersion = LatestVersionMarker // default to latest version
|
|
}
|
|
err := generate(options{
|
|
versionBaseDir: *versionBaseDirFlag,
|
|
outputDir: *outputDirFlag,
|
|
downloadOnly: *downloadOnly,
|
|
version: specifiedVersion,
|
|
firmwareUpdateApi: defaultFirmwareUpdateApi,
|
|
})
|
|
if err != nil {
|
|
log.Error(err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func generate(opts options) error {
|
|
p := NewUnifiVersionProvider(opts.firmwareUpdateApi)
|
|
unifiVersion, err := p.ByVersionMarker(opts.version)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to determine version and download URL for Unifi version %s: %w", opts.version, err)
|
|
}
|
|
|
|
log.Infof("UniFi Controller version: %s", unifiVersion.Version)
|
|
log.Infof("UniFi Controller download URL: %s", unifiVersion.DownloadUrl.String())
|
|
|
|
wd, err := os.Getwd()
|
|
if err != nil {
|
|
return fmt.Errorf("unable to determine working directory: %w", err)
|
|
}
|
|
var structuresDir string
|
|
if path.IsAbs(opts.versionBaseDir) {
|
|
structuresDir = opts.versionBaseDir
|
|
} else {
|
|
structuresDir = filepath.Join(wd, opts.versionBaseDir)
|
|
}
|
|
structuresDir = filepath.Join(structuresDir, fmt.Sprintf("v%s", unifiVersion.Version))
|
|
log.Infoln("Downloading UniFi Controller API structures definitions...")
|
|
err = DownloadAndExtract(*unifiVersion.DownloadUrl, structuresDir)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to download and extract UniFi Controller API structures definitions: %w", err)
|
|
}
|
|
log.Infof("Downloaded UniFi Controller API structures definitions in %s", structuresDir)
|
|
|
|
if opts.downloadOnly {
|
|
log.Infoln("Structure JSONs ready!")
|
|
return nil
|
|
}
|
|
|
|
log.Infoln("Generating resources code...")
|
|
|
|
var outDir string
|
|
if path.IsAbs(opts.outputDir) {
|
|
outDir = opts.outputDir
|
|
} else {
|
|
outDir = filepath.Join(wd, opts.outputDir)
|
|
}
|
|
if err = generateCode(structuresDir, outDir); err != nil {
|
|
return fmt.Errorf("unable to generate resources code: %w", err)
|
|
}
|
|
|
|
log.Infof("Writing version file...")
|
|
if err = writeVersionFile(unifiVersion.Version, outDir); err != nil {
|
|
return fmt.Errorf("failed to write version file to %s: %w", outDir, err)
|
|
}
|
|
|
|
basepath := filepath.Dir(wd)
|
|
if err = writeVersionRepoMarkerFile(unifiVersion.Version, basepath); err != nil {
|
|
return fmt.Errorf("failed to write version file to %s: %w", basepath, err)
|
|
}
|
|
|
|
log.Infof("Generated resources in %s", outDir)
|
|
return nil
|
|
}
|