cmd: Unify the coding style somewhat

There is no need to prefix local variables and try to name variables which refer to the same/simialr thing the same across runners. Signed-off-by: Rolf Neugebauer <rolf.neugebauer@docker.com>
2025-07-18 17:01:07 +00:00 · 2017-05-14 15:12:31 +01:00 · 2017-05-14 15:12:31 +01:00 · 243967db6f
commit 243967db6f
parent 5231e06dec
5 changed files with 84 additions and 84 deletions
--- a/src/cmd/linuxkit/run_gcp.go
+++ b/src/cmd/linuxkit/run_gcp.go
@ -27,31 +27,31 @@ const (

 // Process the run arguments and execute run
 func runGcp(args []string) {
-	gcpCmd := flag.NewFlagSet("gcp", flag.ExitOnError)
+	flags := flag.NewFlagSet("gcp", flag.ExitOnError)
 	invoked := filepath.Base(os.Args[0])
-	gcpCmd.Usage = func() {
+	flags.Usage = func() {
 		fmt.Printf("USAGE: %s run gcp [options] [name]\n\n", invoked)
 		fmt.Printf("'name' specifies either the name of an already uploaded\n")
 		fmt.Printf("GCP image or the full path to a image file which will be\n")
 		fmt.Printf("uploaded before it is run.\n\n")
 		fmt.Printf("Options:\n\n")
-		gcpCmd.PrintDefaults()
+		flags.PrintDefaults()
 	}
-	zoneFlag := gcpCmd.String("zone", defaultZone, "GCP Zone")
-	machineFlag := gcpCmd.String("machine", defaultMachine, "GCP Machine Type")
-	keysFlag := gcpCmd.String("keys", "", "Path to Service Account JSON key file")
-	projectFlag := gcpCmd.String("project", "", "GCP Project Name")
-	diskSizeFlag := gcpCmd.Int("disk-size", 0, "Size of system disk in GB")
-	skipCleanup := gcpCmd.Bool("skip-cleanup", false, "Don't remove images or VMs")
+	zoneFlag := flags.String("zone", defaultZone, "GCP Zone")
+	machineFlag := flags.String("machine", defaultMachine, "GCP Machine Type")
+	keysFlag := flags.String("keys", "", "Path to Service Account JSON key file")
+	projectFlag := flags.String("project", "", "GCP Project Name")
+	diskSizeFlag := flags.Int("disk-size", 0, "Size of system disk in GB")
+	skipCleanup := flags.Bool("skip-cleanup", false, "Don't remove images or VMs")

-	if err := gcpCmd.Parse(args); err != nil {
+	if err := flags.Parse(args); err != nil {
 		log.Fatal("Unable to parse args")
 	}

-	remArgs := gcpCmd.Args()
+	remArgs := flags.Args()
 	if len(remArgs) == 0 {
 		fmt.Printf("Please specify the name of the image to boot\n")
-		gcpCmd.Usage()
+		flags.Usage()
 		os.Exit(1)
 	}
 	name := remArgs[0]
--- a/src/cmd/linuxkit/run_hyperkit.go
+++ b/src/cmd/linuxkit/run_hyperkit.go
@ -15,31 +15,31 @@ import (

 // Process the run arguments and execute run
 func runHyperKit(args []string) {
-	hyperkitCmd := flag.NewFlagSet("hyperkit", flag.ExitOnError)
+	flags := flag.NewFlagSet("hyperkit", flag.ExitOnError)
 	invoked := filepath.Base(os.Args[0])
-	hyperkitCmd.Usage = func() {
+	flags.Usage = func() {
 		fmt.Printf("USAGE: %s run hyperkit [options] prefix\n\n", invoked)
 		fmt.Printf("'prefix' specifies the path to the VM image.\n")
 		fmt.Printf("\n")
 		fmt.Printf("Options:\n")
-		hyperkitCmd.PrintDefaults()
+		flags.PrintDefaults()
 	}
-	hyperkitPath := hyperkitCmd.String("hyperkit", "", "Path to hyperkit binary (if not in default location)")
-	cpus := hyperkitCmd.Int("cpus", 1, "Number of CPUs")
-	mem := hyperkitCmd.Int("mem", 1024, "Amount of memory in MB")
-	diskSz := hyperkitCmd.Int("disk-size", 0, "Size of Disk in MB")
-	disk := hyperkitCmd.String("disk", "", "Path to disk image to used")
-	data := hyperkitCmd.String("data", "", "Metadata to pass to VM (either a path to a file or a string)")
-	ipStr := hyperkitCmd.String("ip", "", "IP address for the VM")
-	state := hyperkitCmd.String("state", "", "Path to directory to keep VM state in")
+	hyperkitPath := flags.String("hyperkit", "", "Path to hyperkit binary (if not in default location)")
+	cpus := flags.Int("cpus", 1, "Number of CPUs")
+	mem := flags.Int("mem", 1024, "Amount of memory in MB")
+	diskSz := flags.Int("disk-size", 0, "Size of Disk in MB")
+	disk := flags.String("disk", "", "Path to disk image to used")
+	data := flags.String("data", "", "Metadata to pass to VM (either a path to a file or a string)")
+	ipStr := flags.String("ip", "", "IP address for the VM")
+	state := flags.String("state", "", "Path to directory to keep VM state in")

-	if err := hyperkitCmd.Parse(args); err != nil {
+	if err := flags.Parse(args); err != nil {
 		log.Fatal("Unable to parse args")
 	}
-	remArgs := hyperkitCmd.Args()
+	remArgs := flags.Args()
 	if len(remArgs) == 0 {
 		fmt.Println("Please specify the prefix to the image to boot\n")
-		hyperkitCmd.Usage()
+		flags.Usage()
 		os.Exit(1)
 	}
 	prefix := remArgs[0]
--- a/src/cmd/linuxkit/run_packet.go
+++ b/src/cmd/linuxkit/run_packet.go
@ -40,25 +40,25 @@ func ValidateHTTPURL(url string) {

 // Process the run arguments and execute run
 func runPacket(args []string) {
-	packetCmd := flag.NewFlagSet("packet", flag.ExitOnError)
+	flags := flag.NewFlagSet("packet", flag.ExitOnError)
 	invoked := filepath.Base(os.Args[0])
-	packetCmd.Usage = func() {
+	flags.Usage = func() {
 		fmt.Printf("USAGE: %s run packet [options] [name]\n\n", invoked)
 		fmt.Printf("Options:\n\n")
-		packetCmd.PrintDefaults()
+		flags.PrintDefaults()
 	}
-	baseURLFlag := packetCmd.String("base-url", "", "Base URL that the kernel and initrd are served from.")
-	zoneFlag := packetCmd.String("zone", packetDefaultZone, "Packet Zone")
-	machineFlag := packetCmd.String("machine", packetDefaultMachine, "Packet Machine Type")
-	apiKeyFlag := packetCmd.String("api-key", "", "Packet API key")
-	projectFlag := packetCmd.String("project-id", "", "Packet Project ID")
-	hostNameFlag := packetCmd.String("hostname", packetDefaultHostname, "Hostname of new instance")
-	nameFlag := packetCmd.String("img-name", "", "Overrides the prefix used to identify the files. Defaults to [name]")
-	if err := packetCmd.Parse(args); err != nil {
+	baseURLFlag := flags.String("base-url", "", "Base URL that the kernel and initrd are served from.")
+	zoneFlag := flags.String("zone", packetDefaultZone, "Packet Zone")
+	machineFlag := flags.String("machine", packetDefaultMachine, "Packet Machine Type")
+	apiKeyFlag := flags.String("api-key", "", "Packet API key")
+	projectFlag := flags.String("project-id", "", "Packet Project ID")
+	hostNameFlag := flags.String("hostname", packetDefaultHostname, "Hostname of new instance")
+	nameFlag := flags.String("img-name", "", "Overrides the prefix used to identify the files. Defaults to [name]")
+	if err := flags.Parse(args); err != nil {
 		log.Fatal("Unable to parse args")
 	}

-	remArgs := packetCmd.Args()
+	remArgs := flags.Args()
 	prefix := "packet"
 	if len(remArgs) > 0 {
 		prefix = remArgs[0]
--- a/src/cmd/linuxkit/run_qemu.go
+++ b/src/cmd/linuxkit/run_qemu.go
@ -38,63 +38,63 @@ type QemuConfig struct {

 func runQemu(args []string) {
 	invoked := filepath.Base(os.Args[0])
-	qemuFlags := flag.NewFlagSet("qemu", flag.ExitOnError)
-	qemuFlags.Usage = func() {
+	flags := flag.NewFlagSet("qemu", flag.ExitOnError)
+	flags.Usage = func() {
 		fmt.Printf("USAGE: %s run qemu [options] prefix\n\n", invoked)
 		fmt.Printf("'prefix' specifies the path to the VM image.\n")
 		fmt.Printf("\n")
 		fmt.Printf("Options:\n")
-		qemuFlags.PrintDefaults()
+		flags.PrintDefaults()
 	}

 	// Determine Flags
-	qemuGUI := qemuFlags.Bool("gui", false, "Set qemu to use video output instead of stdio")
-	qemuUEFI := qemuFlags.Bool("uefi", false, "Set UEFI boot from 'prefix'-efi.iso")
-	qemuIso := qemuFlags.Bool("iso", false, "Set Legacy BIOS boot from 'prefix'.iso")
-	qemuKernel := qemuFlags.Bool("kernel", true, "Set boot using 'prefix'-kernel/-initrd/-cmdline")
+	enableGUI := flags.Bool("gui", false, "Set qemu to use video output instead of stdio")
+	uefiBoot := flags.Bool("uefi", false, "Set UEFI boot from 'prefix'-efi.iso")
+	isoBoot := flags.Bool("iso", false, "Set Legacy BIOS boot from 'prefix'.iso")
+	kernelBoot := flags.Bool("kernel", true, "Set boot using 'prefix'-kernel/-initrd/-cmdline")

 	// Paths and settings for Disks and UEFI firware
-	qemuDiskPath := qemuFlags.String("disk", "", "Path to disk image to use")
-	qemuDiskSize := qemuFlags.String("disk-size", "", "Size of disk to create, only created if it doesn't exist")
-	qemuFWPath := qemuFlags.String("fw", "/usr/share/ovmf/bios.bin", "Path to OVMF firmware for UEFI boot")
+	disk := flags.String("disk", "", "Path to disk image to use")
+	diskSz := flags.String("disk-size", "", "Size of disk to create, only created if it doesn't exist")
+	fw := flags.String("fw", "/usr/share/ovmf/bios.bin", "Path to OVMF firmware for UEFI boot")

 	// VM configuration
-	qemuArch := qemuFlags.String("arch", "x86_64", "Type of architecture to use, e.g. x86_64, aarch64")
-	qemuCPUs := qemuFlags.String("cpus", "1", "Number of CPUs")
-	qemuMem := qemuFlags.String("mem", "1024", "Amount of memory in MB")
+	arch := flags.String("arch", "x86_64", "Type of architecture to use, e.g. x86_64, aarch64")
+	cpus := flags.String("cpus", "1", "Number of CPUs")
+	mem := flags.String("mem", "1024", "Amount of memory in MB")

 	publishFlags := multipleFlag{}
-	qemuFlags.Var(&publishFlags, "publish", "Publish a vm's port(s) to the host (default [])")
+	flags.Var(&publishFlags, "publish", "Publish a vm's port(s) to the host (default [])")

-	if err := qemuFlags.Parse(args); err != nil {
+	if err := flags.Parse(args); err != nil {
 		log.Fatal("Unable to parse args")
 	}
-	remArgs := qemuFlags.Args()
+	remArgs := flags.Args()

 	if len(remArgs) == 0 {
 		fmt.Println("Please specify the prefix to the image to boot")
-		qemuFlags.Usage()
+		flags.Usage()
 		os.Exit(1)
 	}
 	prefix := remArgs[0]

 	// Print warning if conflicting UEFI and ISO flags are set
-	if *qemuUEFI && *qemuIso {
+	if *uefiBoot && *isoBoot {
 		log.Warnf("Both -iso and -uefi have been used")
 	}

 	config := QemuConfig{
 		Prefix:         prefix,
-		ISO:            *qemuIso,
-		UEFI:           *qemuUEFI,
-		Kernel:         *qemuKernel,
-		GUI:            *qemuGUI,
-		DiskPath:       *qemuDiskPath,
-		DiskSize:       *qemuDiskSize,
-		FWPath:         *qemuFWPath,
-		Arch:           *qemuArch,
-		CPUs:           *qemuCPUs,
-		Memory:         *qemuMem,
+		ISO:            *isoBoot,
+		UEFI:           *uefiBoot,
+		Kernel:         *kernelBoot,
+		GUI:            *enableGUI,
+		DiskPath:       *disk,
+		DiskSize:       *diskSz,
+		FWPath:         *fw,
+		Arch:           *arch,
+		CPUs:           *cpus,
+		Memory:         *mem,
 		PublishedPorts: publishFlags,
 	}

--- a/src/cmd/linuxkit/run_vmware.go
+++ b/src/cmd/linuxkit/run_vmware.go
@ -66,27 +66,27 @@ guestOS = "other3xlinux-64"

 func runVMware(args []string) {
 	invoked := filepath.Base(os.Args[0])
-	vmwareArgs := flag.NewFlagSet("vmware", flag.ExitOnError)
-	vmwareArgs.Usage = func() {
+	flags := flag.NewFlagSet("vmware", flag.ExitOnError)
+	flags.Usage = func() {
 		fmt.Printf("USAGE: %s run vmware [options] prefix\n\n", invoked)
 		fmt.Printf("'prefix' specifies the path to the VM image.\n")
 		fmt.Printf("\n")
 		fmt.Printf("Options:\n")
-		vmwareArgs.PrintDefaults()
+		flags.PrintDefaults()
 	}
-	vmwareCPUs := vmwareArgs.Int("cpus", 1, "Number of CPUs")
-	vmwareMem := vmwareArgs.Int("mem", 1024, "Amount of memory in MB")
-	vmwareDisk := vmwareArgs.String("disk", "", "Path to disk image to use")
-	vmwareDiskSize := vmwareArgs.String("disk-size", "", "Size of the disk to create, only created if it doesn't exist")
+	cpus := flags.Int("cpus", 1, "Number of CPUs")
+	mem := flags.Int("mem", 1024, "Amount of memory in MB")
+	disk := flags.String("disk", "", "Path to disk image to use")
+	diskSz := flags.String("disk-size", "", "Size of the disk to create, only created if it doesn't exist")

-	if err := vmwareArgs.Parse(args); err != nil {
+	if err := flags.Parse(args); err != nil {
 		log.Fatal("Unable to parse args")
 	}
-	remArgs := vmwareArgs.Args()
+	remArgs := flags.Args()

 	if len(remArgs) == 0 {
 		fmt.Println("Please specify the prefix to the image to boot")
-		vmwareArgs.Usage()
+		flags.Usage()
 		os.Exit(1)
 	}
 	prefix := remArgs[0]
@ -123,31 +123,31 @@ func runVMware(args []string) {
 		log.Fatalf("ERROR VMware executables can not be found, ensure software is installed")
 	}

-	if *vmwareDisk != "" {
+	if *disk != "" {
 		// Check vmDiskManagerPath exist before attempting to execute
 		if _, err := os.Stat(vmDiskManagerPath); os.IsNotExist(err) {
 			log.Fatalf("ERROR VMware Disk Manager executables can not be found, ensure software is installed")
 		}

 		// If disk doesn't exist then create one, error if disk is unreadable
-		if _, err := os.Stat(*vmwareDisk); err != nil {
+		if _, err := os.Stat(*disk); err != nil {
 			if os.IsPermission(err) {
-				log.Fatalf("Unable to read file [%s], please check permissions", *vmwareDisk)
+				log.Fatalf("Unable to read file [%s], please check permissions", *disk)
 			}
 			if os.IsNotExist(err) {
-				log.Infof("Creating new VMware disk [%s]", *vmwareDisk)
-				vmDiskCmd := exec.Command(vmDiskManagerPath, "-c", "-s", *vmwareDiskSize, "-a", "lsilogic", "-t", "0", *vmwareDisk)
+				log.Infof("Creating new VMware disk [%s]", *disk)
+				vmDiskCmd := exec.Command(vmDiskManagerPath, "-c", "-s", *diskSz, "-a", "lsilogic", "-t", "0", *disk)
 				if err = vmDiskCmd.Run(); err != nil {
-					log.Fatalf("Error creating disk [%s]:  %s", *vmwareDisk, err.Error())
+					log.Fatalf("Error creating disk [%s]:  %s", *disk, err.Error())
 				}
 			}
 		} else {
-			log.Infof("Using existing disk [%s]", *vmwareDisk)
+			log.Infof("Using existing disk [%s]", *disk)
 		}
 	}

 	// Build the contents of the VMWare .vmx file
-	vmx := buildVMX(*vmwareCPUs, *vmwareMem, *vmwareDisk, prefix)
+	vmx := buildVMX(*cpus, *mem, *disk, prefix)

 	if vmx == "" {
 		log.Fatalf("VMware .vmx file could not be generated, please confirm inputs")