From a6da7f138c0b260d560c63e234c87db0f5c72bb1 Mon Sep 17 00:00:00 2001 From: Jonathan Rudenberg Date: Thu, 28 Mar 2013 20:12:23 -0400 Subject: [PATCH] Camelize some snake_case variable names --- auth/auth.go | 8 ++--- commands.go | 78 ++++++++++++++++++++++++------------------------ container.go | 60 ++++++++++++++++++------------------- docker/docker.go | 16 +++++----- runtime.go | 6 ++-- utils.go | 24 +++++++-------- 6 files changed, 96 insertions(+), 96 deletions(-) diff --git a/auth/auth.go b/auth/auth.go index bbc9e32640..045176ed48 100644 --- a/auth/auth.go +++ b/auth/auth.go @@ -76,13 +76,13 @@ func LoadConfig(rootPath string) (*AuthConfig, error) { return nil, err } arr := strings.Split(string(b), "\n") - orig_auth := strings.Split(arr[0], " = ") - orig_email := strings.Split(arr[1], " = ") - authConfig, err := DecodeAuth(orig_auth[1]) + origAuth := strings.Split(arr[0], " = ") + origEmail := strings.Split(arr[1], " = ") + authConfig, err := DecodeAuth(origAuth[1]) if err != nil { return nil, err } - authConfig.Email = orig_email[1] + authConfig.Email = origEmail[1] authConfig.rootPath = rootPath return authConfig, nil } diff --git a/commands.go b/commands.go index c769568536..99d0c341e5 100644 --- a/commands.go +++ b/commands.go @@ -493,7 +493,7 @@ func (srv *Server) CmdImages(stdin io.ReadCloser, stdout io.Writer, args ...stri cmd := rcli.Subcmd(stdout, "images", "[OPTIONS] [NAME]", "List images") //limit := cmd.Int("l", 0, "Only show the N most recent versions of each image") quiet := cmd.Bool("q", false, "only show numeric IDs") - fl_a := cmd.Bool("a", false, "show all images") + flAll := cmd.Bool("a", false, "show all images") if err := cmd.Parse(args); err != nil { return nil } @@ -511,7 +511,7 @@ func (srv *Server) CmdImages(stdin io.ReadCloser, stdout io.Writer, args ...stri } var allImages map[string]*Image var err error - if *fl_a { + if *flAll { allImages, err = srv.runtime.graph.Map() } else { allImages, err = srv.runtime.graph.Heads() @@ -583,8 +583,8 @@ func (srv *Server) CmdPs(stdin io.ReadCloser, stdout io.Writer, args ...string) cmd := rcli.Subcmd(stdout, "ps", "[OPTIONS]", "List containers") quiet := cmd.Bool("q", false, "Only display numeric IDs") - fl_all := cmd.Bool("a", false, "Show all containers. Only running containers are shown by default.") - fl_full := cmd.Bool("notrunc", false, "Don't truncate output") + flAll := cmd.Bool("a", false, "Show all containers. Only running containers are shown by default.") + flFull := cmd.Bool("notrunc", false, "Don't truncate output") if err := cmd.Parse(args); err != nil { return nil } @@ -593,12 +593,12 @@ func (srv *Server) CmdPs(stdin io.ReadCloser, stdout io.Writer, args ...string) fmt.Fprintf(w, "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tCOMMENT\n") } for _, container := range srv.runtime.List() { - if !container.State.Running && !*fl_all { + if !container.State.Running && !*flAll { continue } if !*quiet { command := fmt.Sprintf("%s %s", container.Path, strings.Join(container.Args, " ")) - if !*fl_full { + if !*flFull { command = Trunc(command, 20) } for idx, field := range []string{ @@ -630,7 +630,7 @@ func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...stri cmd := rcli.Subcmd(stdout, "commit", "[OPTIONS] CONTAINER [REPOSITORY [TAG]]", "Create a new image from a container's changes") - fl_comment := cmd.String("m", "", "Commit message") + flComment := cmd.String("m", "", "Commit message") if err := cmd.Parse(args); err != nil { return nil } @@ -639,7 +639,7 @@ func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...stri cmd.Usage() return nil } - img, err := srv.runtime.Commit(containerName, repository, tag, *fl_comment) + img, err := srv.runtime.Commit(containerName, repository, tag, *flComment) if err != nil { return err } @@ -704,20 +704,20 @@ func (srv *Server) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string } name := cmd.Arg(0) if container := srv.runtime.Get(name); container != nil { - log_stdout, err := container.ReadLog("stdout") + logStdout, err := container.ReadLog("stdout") if err != nil { return err } - log_stderr, err := container.ReadLog("stderr") + logStderr, err := container.ReadLog("stderr") if err != nil { return err } // FIXME: Interpolate stdout and stderr instead of concatenating them // FIXME: Differentiate stdout and stderr in the remote protocol - if _, err := io.Copy(stdout, log_stdout); err != nil { + if _, err := io.Copy(stdout, logStdout); err != nil { return err } - if _, err := io.Copy(stdout, log_stderr); err != nil { + if _, err := io.Copy(stdout, logStderr); err != nil { return err } return nil @@ -727,9 +727,9 @@ func (srv *Server) CmdLogs(stdin io.ReadCloser, stdout io.Writer, args ...string func (srv *Server) CmdAttach(stdin io.ReadCloser, stdout io.Writer, args ...string) error { cmd := rcli.Subcmd(stdout, "attach", "[OPTIONS]", "Attach to a running container") - fl_i := cmd.Bool("i", false, "Attach to stdin") - fl_o := cmd.Bool("o", true, "Attach to stdout") - fl_e := cmd.Bool("e", true, "Attach to stderr") + flStdin := cmd.Bool("i", false, "Attach to stdin") + flStdout := cmd.Bool("o", true, "Attach to stdout") + flStderr := cmd.Bool("e", true, "Attach to stderr") if err := cmd.Parse(args); err != nil { return nil } @@ -743,29 +743,29 @@ func (srv *Server) CmdAttach(stdin io.ReadCloser, stdout io.Writer, args ...stri return errors.New("No such container: " + name) } var wg sync.WaitGroup - if *fl_i { - c_stdin, err := container.StdinPipe() + if *flStdin { + cStdin, err := container.StdinPipe() if err != nil { return err } wg.Add(1) - go func() { io.Copy(c_stdin, stdin); wg.Add(-1) }() + go func() { io.Copy(cStdin, stdin); wg.Add(-1) }() } - if *fl_o { - c_stdout, err := container.StdoutPipe() + if *flStdout { + cStdout, err := container.StdoutPipe() if err != nil { return err } wg.Add(1) - go func() { io.Copy(stdout, c_stdout); wg.Add(-1) }() + go func() { io.Copy(stdout, cStdout); wg.Add(-1) }() } - if *fl_e { - c_stderr, err := container.StderrPipe() + if *flStderr { + cStderr, err := container.StderrPipe() if err != nil { return err } wg.Add(1) - go func() { io.Copy(stdout, c_stderr); wg.Add(-1) }() + go func() { io.Copy(stdout, cStderr); wg.Add(-1) }() } wg.Wait() return nil @@ -843,46 +843,46 @@ func (srv *Server) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) } } if config.OpenStdin { - cmd_stdin, err := container.StdinPipe() + cmdStdin, err := container.StdinPipe() if err != nil { return err } if !config.Detach { Go(func() error { - _, err := io.Copy(cmd_stdin, stdin) - cmd_stdin.Close() + _, err := io.Copy(cmdStdin, stdin) + cmdStdin.Close() return err }) } } // Run the container if !config.Detach { - cmd_stderr, err := container.StderrPipe() + cmdStderr, err := container.StderrPipe() if err != nil { return err } - cmd_stdout, err := container.StdoutPipe() + cmdStdout, err := container.StdoutPipe() if err != nil { return err } if err := container.Start(); err != nil { return err } - sending_stdout := Go(func() error { - _, err := io.Copy(stdout, cmd_stdout) + sendingStdout := Go(func() error { + _, err := io.Copy(stdout, cmdStdout) return err }) - sending_stderr := Go(func() error { - _, err := io.Copy(stdout, cmd_stderr) + sendingStderr := Go(func() error { + _, err := io.Copy(stdout, cmdStderr) return err }) - err_sending_stdout := <-sending_stdout - err_sending_stderr := <-sending_stderr - if err_sending_stdout != nil { - return err_sending_stdout + errSendingStdout := <-sendingStdout + errSendingStderr := <-sendingStderr + if errSendingStdout != nil { + return errSendingStdout } - if err_sending_stderr != nil { - return err_sending_stderr + if errSendingStderr != nil { + return errSendingStderr } container.Wait() } else { diff --git a/container.go b/container.go index 77d16c786b..6769f6b66b 100644 --- a/container.go +++ b/container.go @@ -66,16 +66,16 @@ func ParseRun(args []string, stdout io.Writer) (*Config, error) { cmd.SetOutput(ioutil.Discard) } - fl_user := cmd.String("u", "", "Username or UID") - fl_detach := cmd.Bool("d", false, "Detached mode: leave the container running in the background") - fl_stdin := cmd.Bool("i", false, "Keep stdin open even if not attached") - fl_tty := cmd.Bool("t", false, "Allocate a pseudo-tty") - fl_memory := cmd.Int64("m", 0, "Memory limit (in bytes)") - var fl_ports ports + flUser := cmd.String("u", "", "Username or UID") + flDetach := cmd.Bool("d", false, "Detached mode: leave the container running in the background") + flStdin := cmd.Bool("i", false, "Keep stdin open even if not attached") + flTty := cmd.Bool("t", false, "Allocate a pseudo-tty") + flMemory := cmd.Int64("m", 0, "Memory limit (in bytes)") + var flPorts ports - cmd.Var(&fl_ports, "p", "Map a network port to the container") - var fl_env ListOpts - cmd.Var(&fl_env, "e", "Set environment variables") + cmd.Var(&flPorts, "p", "Map a network port to the container") + var flEnv ListOpts + cmd.Var(&flEnv, "e", "Set environment variables") if err := cmd.Parse(args); err != nil { return nil, err } @@ -89,13 +89,13 @@ func ParseRun(args []string, stdout io.Writer) (*Config, error) { runCmd = parsedArgs[1:] } config := &Config{ - Ports: fl_ports, - User: *fl_user, - Tty: *fl_tty, - OpenStdin: *fl_stdin, - Memory: *fl_memory, - Detach: *fl_detach, - Env: fl_env, + Ports: flPorts, + User: *flUser, + Tty: *flTty, + OpenStdin: *flStdin, + Memory: *flMemory, + Detach: *flDetach, + Env: flEnv, Cmd: runCmd, Image: image, } @@ -150,52 +150,52 @@ func (container *Container) generateLXCConfig() error { } func (container *Container) startPty() error { - stdout_master, stdout_slave, err := pty.Open() + stdoutMaster, stdoutSlave, err := pty.Open() if err != nil { return err } - container.cmd.Stdout = stdout_slave + container.cmd.Stdout = stdoutSlave - stderr_master, stderr_slave, err := pty.Open() + stderrMaster, stderrSlave, err := pty.Open() if err != nil { return err } - container.cmd.Stderr = stderr_slave + container.cmd.Stderr = stderrSlave // Copy the PTYs to our broadcasters go func() { defer container.stdout.Close() - io.Copy(container.stdout, stdout_master) + io.Copy(container.stdout, stdoutMaster) }() go func() { defer container.stderr.Close() - io.Copy(container.stderr, stderr_master) + io.Copy(container.stderr, stderrMaster) }() // stdin - var stdin_slave io.ReadCloser + var stdinSlave io.ReadCloser if container.Config.OpenStdin { - stdin_master, stdin_slave, err := pty.Open() + stdinMaster, stdinSlave, err := pty.Open() if err != nil { return err } - container.cmd.Stdin = stdin_slave + container.cmd.Stdin = stdinSlave // FIXME: The following appears to be broken. // "cannot set terminal process group (-1): Inappropriate ioctl for device" // container.cmd.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true} go func() { defer container.stdin.Close() - io.Copy(stdin_master, container.stdin) + io.Copy(stdinMaster, container.stdin) }() } if err := container.cmd.Start(); err != nil { return err } - stdout_slave.Close() - stderr_slave.Close() - if stdin_slave != nil { - stdin_slave.Close() + stdoutSlave.Close() + stderrSlave.Close() + if stdinSlave != nil { + stdinSlave.Close() } return nil } diff --git a/docker/docker.go b/docker/docker.go index 686cd2181a..1b7e322a4f 100644 --- a/docker/docker.go +++ b/docker/docker.go @@ -17,11 +17,11 @@ func main() { return } // FIXME: Switch d and D ? (to be more sshd like) - fl_daemon := flag.Bool("d", false, "Daemon mode") - fl_debug := flag.Bool("D", false, "Debug mode") + flDaemon := flag.Bool("d", false, "Daemon mode") + flDebug := flag.Bool("D", false, "Debug mode") flag.Parse() - rcli.DEBUG_FLAG = *fl_debug - if *fl_daemon { + rcli.DEBUG_FLAG = *flDebug + if *flDaemon { if flag.NArg() != 0 { flag.Usage() return @@ -59,22 +59,22 @@ func runCommand(args []string) error { // closing the connection. // See http://code.google.com/p/go/issues/detail?id=3345 if conn, err := rcli.Call("tcp", "127.0.0.1:4242", args...); err == nil { - receive_stdout := docker.Go(func() error { + receiveStdout := docker.Go(func() error { _, err := io.Copy(os.Stdout, conn) return err }) - send_stdin := docker.Go(func() error { + sendStdin := docker.Go(func() error { _, err := io.Copy(conn, os.Stdin) if err := conn.CloseWrite(); err != nil { log.Printf("Couldn't send EOF: " + err.Error()) } return err }) - if err := <-receive_stdout; err != nil { + if err := <-receiveStdout; err != nil { return err } if !term.IsTerminal(0) { - if err := <-send_stdin; err != nil { + if err := <-sendStdin; err != nil { return err } } diff --git a/runtime.go b/runtime.go index 8c56f9acd9..c719fdd602 100644 --- a/runtime.go +++ b/runtime.go @@ -234,9 +234,9 @@ func NewRuntime() (*Runtime, error) { } func NewRuntimeFromDirectory(root string) (*Runtime, error) { - runtime_repo := path.Join(root, "containers") + runtimeRepo := path.Join(root, "containers") - if err := os.MkdirAll(runtime_repo, 0700); err != nil && !os.IsExist(err) { + if err := os.MkdirAll(runtimeRepo, 0700); err != nil && !os.IsExist(err) { return nil, err } @@ -260,7 +260,7 @@ func NewRuntimeFromDirectory(root string) (*Runtime, error) { runtime := &Runtime{ root: root, - repository: runtime_repo, + repository: runtimeRepo, containers: list.New(), networkManager: netManager, graph: g, diff --git a/utils.go b/utils.go index b9b230305f..e479f472bd 100644 --- a/utils.go +++ b/utils.go @@ -63,25 +63,25 @@ func Debugf(format string, a ...interface{}) { // Reader with progress bar type progressReader struct { - reader io.ReadCloser // Stream to read from - output io.Writer // Where to send progress bar to - read_total int // Expected stream length (bytes) - read_progress int // How much has been read so far (bytes) - last_update int // How many bytes read at least update + reader io.ReadCloser // Stream to read from + output io.Writer // Where to send progress bar to + readTotal int // Expected stream length (bytes) + readProgress int // How much has been read so far (bytes) + lastUpdate int // How many bytes read at least update } func (r *progressReader) Read(p []byte) (n int, err error) { read, err := io.ReadCloser(r.reader).Read(p) - r.read_progress += read + r.readProgress += read // Only update progress for every 1% read - update_every := int(0.01 * float64(r.read_total)) - if r.read_progress-r.last_update > update_every || r.read_progress == r.read_total { + updateEvery := int(0.01 * float64(r.readTotal)) + if r.readProgress-r.lastUpdate > updateEvery || r.readProgress == r.readTotal { fmt.Fprintf(r.output, "%d/%d (%.0f%%)\r", - r.read_progress, - r.read_total, - float64(r.read_progress)/float64(r.read_total)*100) - r.last_update = r.read_progress + r.readProgress, + r.readTotal, + float64(r.readProgress)/float64(r.readTotal)*100) + r.lastUpdate = r.readProgress } // Send newline when complete if err == io.EOF {