Вступление
Данная статья является второй, в цикле по истории развития и изучению исходного кода Docker. В ней мы разберем, что представлял собой первый публичный релиз от 23 марта 2013 года.
Изначально я планировал уложить весь материал, посвященный этой версии, в одной статье, но в процессе стало ясно, что она получается слишком большой, поэтому я решил разделить ее на две. В текущей части (2.1) будет рассмотрена лишь общая структура и начальный код, а последующая часть (2.2) будет посвящена принципу работы и коду конкретных команд.
Некоторые части кода уже были разобраны в первой статье, так что для полноты восприятия, рекомендую начать с нее, а также пятиминутной презентации The Future of Linux Containers, на которой и была представлена первая версия Docker.
Docker v0.1.0
Все действия будут выполняться, как и ранее, на Windows 10 и Vagrant с Ubuntu 20.04. Начнем с установки требуемых пакетов:
sudo apt-get update && sudo apt-get -y install lxc libarchive-tools curl golang git debootstrap tree
Клонируем репозиторий и перейдем на версию v0.1.0:
cd /home/vagrant && git clone https://github.com/docker/engine.git && cd ./engine git checkout -f v0.1.0 && git log | head -n 5 && tree HEAD is now at 57e2126a02 Bumped version to 0.1.0 commit 57e2126a02f8b96b0542df7f6a573233d8419bb1 Author: Solomon Hykes <solomon@dotcloud.com> Date: Sat Mar 23 17:48:18 2013 -0700 Bumped version to 0.1.0 . ├── AUTHORS ├── LICENSE ├── NOTICE ├── README.md ├── Vagrantfile ├── archive.go ├── archive_test.go ├── auth │ ├── auth.go │ └── auth_test.go ├── changes.go ├── commands.go ├── container.go ├── container_test.go ├── contrib │ ├── README │ ├── install.sh │ └── mkimage-busybox.sh ├── deb │ ├── Makefile -> ../Makefile │ ├── Makefile.deb │ ├── README.md -> ../README.md │ ├── debian │ │ ├── changelog │ │ ├── compat │ │ ├── control │ │ ├── copyright │ │ ├── docs │ │ ├── rules │ │ └── source │ │ └── format │ └── etc │ ├── docker-dev.upstart │ └── docker.upstart ├── docker │ └── docker.go ├── docs │ ├── README.md │ └── images-repositories-push-pull.md ├── graph.go ├── graph_test.go ├── image.go ├── lxc_template.go ├── mount.go ├── mount_darwin.go ├── mount_linux.go ├── network.go ├── network_test.go ├── puppet │ ├── manifests │ │ └── quantal64.pp │ └── modules │ └── docker │ ├── manifests │ │ └── init.pp │ └── templates │ ├── dockerd.conf │ └── profile ├── rcli │ ├── http.go │ ├── tcp.go │ └── types.go ├── registry.go ├── runtime.go ├── runtime_test.go ├── state.go ├── sysinit.go ├── tags.go ├── term │ ├── term.go │ ├── termios_darwin.go │ └── termios_linux.go ├── utils.go └── utils_test.go 16 directories, 58 files
Как можно заметить, со времени первого коммита файлов заметно прибавилось. Директории deb и puppet мы опустим, так как они нас мало интересуют.
Для начала попробуем скомпилировать и запустить данную версию программы:
go mod init github.com/dotcloud/docker && cd docker && go build docker.go go: creating new go.mod: module github.com/dotcloud/docker go: finding github.com/kr/pty v1.1.8 go: downloading github.com/kr/pty v1.1.8 go: extracting github.com/kr/pty v1.1.8 go: downloading github.com/creack/pty v1.1.7 go: extracting github.com/creack/pty v1.1.7 go: finding github.com/creack/pty v1.1.7
vagrant@ubuntu-focal:/vagrant/engine/docker$ sudo ./docker version docker version Version:0.1.0 vagrant@ubuntu-focal:~/engine/docker$ sudo ./docker help Usage: docker COMMAND [arg...] A self-sufficient runtime for linux containers. Commands: run Run a command in a container ps Display a list of containers import Create a new filesystem image from the contents of a tarball attach Attach to a running container commit Create a new image from a container's changes history Show the history of an image diff Inspect changes on a container's filesystem images List images info Display system-wide information inspect Return low-level information on a container kill Kill a running container login Register or Login to the docker registry server logs Fetch the logs of a container port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT ps List containers pull Pull an image or a repository to the docker registry server push Push an image or a repository to the docker registry server restart Restart a running container rm Remove a container rmi Remove an image run Run a command in a new container start Start a stopped container stop Stop a running container export Stream the contents of a container as a tar archive version Show the docker version information wait Block until a container stops, then print its exit code
Уже в первой версии имеется знакомый нам функционал для работы с контейнерами, образами, историей, репозиторием, сетевыми портами и тп.
К сожалению, воспользоваться репозиторием для скачивания образа не получится, так как с тех пор формат и сам репозиторий поменялись, а для запуска контейнера нужно будет применить патч для lxc шаблона. Но во второй части, мы вручную создадим образ при помощи утилиты debootstrap, применим патч, после чего импортируем и запустим контейнер. А пока приступим к изучению кода.
Entry point
Главной точкой входа, является функция main в файле docker/docker.go:
func main() { if docker.SelfPath() == "/sbin/init" { // Running in init mode docker.SysInit() 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") flag.Parse() rcli.DEBUG_FLAG = *fl_debug if *fl_daemon { if flag.NArg() != 0 { flag.Usage() return } if err := daemon(); err != nil { log.Fatal(err) } } else { if err := runCommand(flag.Args()); err != nil { log.Fatal(err) } } }
В самом начале функции находится, как может показаться, довольно странная проверка. Запускаемый файл проверяется на соответствие с /sbin/init. В следующей части, когда мы перейдем к функции запуска контейнера, будет видно, что исполняемый файл docker, монтируется в точку /sbin/init, запускаемого lxc контейнера, а функция docker.SysInit() из файла sysinit.go производит настройку окружения и последующий запуск требуемого процесса в контейнере. На данном этапе мы пропустим эту часть.
// Sys Init code // This code is run INSIDE the container and is responsible for setting // up the environment before running the actual process func SysInit() { if len(os.Args) <= 1 { fmt.Println("You should not invoke docker-init manually") os.Exit(1) } var u = flag.String("u", "", "username or uid") var gw = flag.String("g", "", "gateway address") flag.Parse() setupNetworking(*gw) changeUser(*u) executeProgram(flag.Arg(0), flag.Args()) }
Далее в зависимости от флага -d, докер может запускаться в режиме демона работая по сетевому сокету или выполнять команды локально.
func daemon() error { service, err := docker.NewServer() if err != nil { return err } return rcli.ListenAndServe("tcp", "127.0.0.1:4242", service) }
Функция daemon стартует простой tcp сервер на порту 4242, принимает соединения, читает и выполняет команды переданные в json формате. Его код можно найти в файле rcli/tcp.go:
// Listen on `addr`, using protocol `proto`, for incoming rcli calls, // and pass them to `service`. func ListenAndServe(proto, addr string, service Service) error { listener, err := net.Listen(proto, addr) if err != nil { return err } log.Printf("Listening for RCLI/%s on %s\n", proto, addr) defer listener.Close() for { if conn, err := listener.Accept(); err != nil { return err } else { go func() { if DEBUG_FLAG { CLIENT_SOCKET = conn } if err := Serve(conn, service); err != nil { log.Printf("Error: " + err.Error() + "\n") fmt.Fprintf(conn, "Error: "+err.Error()+"\n") } conn.Close() }() } } return nil } // Parse an rcli call on a new connection, and pass it to `service` if it // is valid. func Serve(conn io.ReadWriter, service Service) error { r := bufio.NewReader(conn) var args []string if line, err := r.ReadString('\n'); err != nil { return err } else if err := json.Unmarshal([]byte(line), &args); err != nil { return err } else { return call(service, ioutil.NopCloser(r), conn, args...) } return nil } // FIXME: For reverse compatibility func call(service Service, stdin io.ReadCloser, stdout io.Writer, args ...string) error { return LocalCall(service, stdin, stdout, args...) }
В случае же запуска докера без флага -d выполнение переходит к функции runCommand:
func runCommand(args []string) error { var oldState *term.State var err error if term.IsTerminal(0) && os.Getenv("NORAW") == "" { oldState, err = term.MakeRaw(0) if err != nil { return err } defer term.Restore(0, oldState) } // FIXME: we want to use unix sockets here, but net.UnixConn doesn't expose // CloseWrite(), which we need to cleanly signal that stdin is closed without // 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 { _, err := io.Copy(os.Stdout, conn) return err }) send_stdin := 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 { return err } if !term.IsTerminal(0) { if err := <-send_stdin; err != nil { return err } } } else { service, err := docker.NewServer() if err != nil { return err } if err := rcli.LocalCall(service, os.Stdin, os.Stdout, args...); err != nil { return err } } if oldState != nil { term.Restore(0, oldState) } return nil }
В самом начале происходит перевод терминала в raw режим. Весь функционал, отвечающий за работу с терминалом, находится в папке term.
Далее идет попытка подключения и отправка команды демону функцией rcli.Call из файла rcli/tcp.go (демон должен быть запущен заранее с флагом -d):
// Connect to a remote endpoint using protocol `proto` and address `addr`, // issue a single call, and return the result. // `proto` may be "tcp", "unix", etc. See the `net` package for available protocols. func Call(proto, addr string, args ...string) (*net.TCPConn, error) { cmd, err := json.Marshal(args) if err != nil { return nil, err } conn, err := net.Dial(proto, addr) if err != nil { return nil, err } if _, err := fmt.Fprintln(conn, string(cmd)); err != nil { return nil, err } return conn.(*net.TCPConn), nil }
В случае, если попытка не удалась, команда выполняется локально при помощи вызова LocalCall и структуры возвращаемой функцией docker.NewServer, которая находится в файле commands.go:
func NewServer() (*Server, error) { rand.Seed(time.Now().UTC().UnixNano()) if runtime.GOARCH != "amd64" { log.Fatalf("The docker runtime currently only supports amd64 (not %s). This will change in the future. Aborting.", runtime.GOARCH) } runtime, err := NewRuntime() if err != nil { return nil, err } srv := &Server{ runtime: runtime, } return srv, nil } type Server struct { runtime *Runtime }
Мы вернемся к структуре Server и Runtime немного позже, а сперва посмотрим на функцию LocalCall из файла rcli/types.go:
func LocalCall(service Service, stdin io.ReadCloser, stdout io.Writer, args ...string) error { if len(args) == 0 { args = []string{"help"} } flags := flag.NewFlagSet("main", flag.ContinueOnError) flags.SetOutput(stdout) flags.Usage = func() { stdout.Write([]byte(service.Help())) } if err := flags.Parse(args); err != nil { return err } cmd := flags.Arg(0) log.Printf("%s\n", strings.Join(append(append([]string{service.Name()}, cmd), flags.Args()[1:]...), " ")) if cmd == "" { cmd = "help" } method := getMethod(service, cmd) if method != nil { return method(stdin, stdout, flags.Args()[1:]...) } return errors.New("No such command: " + cmd) }
В ней происходит разбор аргументов и выполнение команды, полученной из getMethod, который использует рефлексию структуры Server для вычисления метода соответствующего переданной команде по шаблону "Cmd" + MethodName:
func getMethod(service Service, name string) Cmd { if name == "help" { return func(stdin io.ReadCloser, stdout io.Writer, args ...string) error { if len(args) == 0 { stdout.Write([]byte(service.Help())) } else { if method := getMethod(service, args[0]); method == nil { return errors.New("No such command: " + args[0]) } else { method(stdin, stdout, "--help") } } return nil } } methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:]) method, exists := reflect.TypeOf(service).MethodByName(methodName) if !exists { return nil } return func(stdin io.ReadCloser, stdout io.Writer, args ...string) error { ret := method.Func.CallSlice([]reflect.Value{ reflect.ValueOf(service), reflect.ValueOf(stdin), reflect.ValueOf(stdout), reflect.ValueOf(args), })[0].Interface() if ret == nil { return nil } return ret.(error) } }
Все доступные методы лежат в файле commands.go, их разбором мы займемся во второй части, а пока вернемся к функции NewRuntime вызываемой в функции docker.NewServer. Она содержится в файле runtime.go и которая возвращает структуру Runtime сохраняемую в структуре Server:
func NewRuntime() (*Runtime, error) { return NewRuntimeFromDirectory("/var/lib/docker") } func NewRuntimeFromDirectory(root string) (*Runtime, error) { runtime_repo := path.Join(root, "containers") if err := os.MkdirAll(runtime_repo, 0700); err != nil && !os.IsExist(err) { return nil, err } g, err := NewGraph(path.Join(root, "graph")) if err != nil { return nil, err } repositories, err := NewTagStore(path.Join(root, "repositories"), g) if err != nil { return nil, fmt.Errorf("Couldn't create Tag store: %s", err) } netManager, err := newNetworkManager(networkBridgeIface) if err != nil { return nil, err } authConfig, err := auth.LoadConfig(root) if err != nil && authConfig == nil { // If the auth file does not exist, keep going return nil, err } runtime := &Runtime{ root: root, repository: runtime_repo, containers: list.New(), networkManager: netManager, graph: g, repositories: repositories, authConfig: authConfig, } if err := runtime.restore(); err != nil { return nil, err } return runtime, nil }
Как можно заметить, часть этого функционала раньше находилась в файле docker.go, который мы разобрали в первой статье. Теперь же сюда добавлены и новые структуры:
graph (NewGraph) - отвечает за работу со слоями и зависимостями образа. Файл graph.go
networkManager (newNetworkManager) - отвечает за весь сетевой стек. Файл network.go
repositories (NewTagStore) - отвечает за локальный репозиторий и работу с метками (tags) образов. Файл tags.go
authConfig (auth.LoadConfig) - отвечает за хранение данных для авторизации на удаленном репозитории образов. Файл auth/auth.go
Работу метода restore мы также разбирали в первой части. Принцип остался прежним, изменения коснулись лишь процедуры инициализации существующих контейнеров:
func (runtime *Runtime) restore() error { dir, err := ioutil.ReadDir(runtime.repository) if err != nil { return err } for _, v := range dir { id := v.Name() container, err := runtime.Load(id) if err != nil { Debugf("Failed to load container %v: %v", id, err) continue } Debugf("Loaded container %v", container.Id) } return nil } func (runtime *Runtime) Load(id string) (*Container, error) { container := &Container{root: runtime.containerRoot(id)} if err := container.FromDisk(); err != nil { return nil, err } if container.Id != id { return container, fmt.Errorf("Container %s is stored at %s", container.Id, id) } if err := runtime.Register(container); err != nil { return nil, err } return container, nil } func (container *Container) FromDisk() error { data, err := ioutil.ReadFile(container.jsonPath()) if err != nil { return err } // Load container settings if err := json.Unmarshal(data, container); err != nil { return err } return nil }
В первой части мне пришлось делать небольшой патч, теперь же метод Register осуществляет полную инициализацию контейнера:
// Register makes a container object usable by the runtime as <container.Id> func (runtime *Runtime) Register(container *Container) error { if container.runtime != nil || runtime.Exists(container.Id) { return fmt.Errorf("Container is already loaded") } if err := validateId(container.Id); err != nil { return err } container.runtime = runtime // Setup state lock (formerly in newState() lock := new(sync.Mutex) container.State.stateChangeLock = lock container.State.stateChangeCond = sync.NewCond(lock) // Attach to stdout and stderr container.stderr = newWriteBroadcaster() container.stdout = newWriteBroadcaster() // Attach to stdin if container.Config.OpenStdin { container.stdin, container.stdinPipe = io.Pipe() } else { container.stdinPipe = NopWriteCloser(ioutil.Discard) // Silently drop stdin } // Setup logging of stdout and stderr to disk if err := runtime.LogToDisk(container.stdout, container.logPath("stdout")); err != nil { return err } if err := runtime.LogToDisk(container.stderr, container.logPath("stderr")); err != nil { return err } // done runtime.containers.PushBack(container) return nil }
Функционал writeBroadcaster, State знакомый нам из первой части, остался без изменения, добавилась лишь заглушка для stdin:
type nopWriteCloser struct { io.Writer } func (w *nopWriteCloser) Close() error { return nil } func NopWriteCloser(w io.Writer) io.WriteCloser { return &nopWriteCloser{w} }
и логирование потоков stdout stderr в файл на диск:
func (container *Container) logPath(name string) string { return path.Join(container.root, fmt.Sprintf("%s-%s.log", container.Id, name)) } func (runtime *Runtime) LogToDisk(src *writeBroadcaster, dst string) error { log, err := os.OpenFile(dst, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600) if err != nil { return err } src.AddWriter(NopWriteCloser(log)) return nil }
На этом, думаю, можно завершить общую частью и перейти непосредственно к разбору кода команд.
Заключение
В следующей части мы подробно рассмотрим код отвечающий за работу с контейнерами, образами, репозиторием, сетевым стеком, а также создадим образ вручную и запустим контейнер на его основе.
