76 lines
3.1 KiB
Go
76 lines
3.1 KiB
Go
package lcow
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
// "os"
|
|
|
|
"github.com/Microsoft/hcsshim/internal/uvm"
|
|
// specs "github.com/opencontainers/runtime-spec/specs-go"
|
|
// "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// VhdToTar does what is says - it exports a VHD in a specified
|
|
// folder (either a read-only layer.vhd, or a read-write scratch vhdx) to a
|
|
// ReadCloser containing a tar-stream of the layers contents.
|
|
func VhdToTar(lcowUVM *uvm.UtilityVM, vhdFile string, uvmMountPath string, isContainerScratch bool, vhdSize int64) (io.ReadCloser, error) {
|
|
return nil, fmt.Errorf("not implemented yet")
|
|
// logrus.Debugf("hcsshim: VhdToTar: %s isScratch: %t", vhdFile, isContainerScratch)
|
|
|
|
// if lcowUVM == nil {
|
|
// return nil, fmt.Errorf("cannot VhdToTar as no utility VM is in configuration")
|
|
// }
|
|
|
|
// //defer uvm.DebugLCOWGCS()
|
|
|
|
// vhdHandle, err := os.Open(vhdFile)
|
|
// if err != nil {
|
|
// return nil, fmt.Errorf("hcsshim: VhdToTar: failed to open %s: %s", vhdFile, err)
|
|
// }
|
|
// defer vhdHandle.Close()
|
|
// logrus.Debugf("hcsshim: VhdToTar: exporting %s, size %d, isScratch %t", vhdHandle.Name(), vhdSize, isContainerScratch)
|
|
|
|
// // Different binary depending on whether a RO layer or a RW scratch
|
|
// command := "vhd2tar"
|
|
// if isContainerScratch {
|
|
// command = fmt.Sprintf("exportSandbox -path %s", uvmMountPath)
|
|
// }
|
|
|
|
// // tar2vhd, byteCounts, err := lcowUVM.CreateProcess(&uvm.ProcessOptions{
|
|
// // Process: &specs.Process{Args: []string{"tar2vhd"}},
|
|
// // Stdin: reader,
|
|
// // Stdout: outFile,
|
|
// // })
|
|
|
|
// // Start the binary in the utility VM
|
|
// proc, stdin, stdout, _, err := config.createLCOWUVMProcess(command)
|
|
// if err != nil {
|
|
// return nil, fmt.Errorf("hcsshim: VhdToTar: %s: failed to create utils process %s: %s", vhdHandle.Name(), command, err)
|
|
// }
|
|
|
|
// if !isContainerScratch {
|
|
// // Send the VHD contents to the utility VM processes stdin handle if not a container scratch
|
|
// logrus.Debugf("hcsshim: VhdToTar: copying the layer VHD into the utility VM")
|
|
// if _, err = copyWithTimeout(stdin, vhdHandle, vhdSize, processOperationTimeoutSeconds, fmt.Sprintf("vhdtotarstream: sending %s to %s", vhdHandle.Name(), command)); err != nil {
|
|
// proc.Close()
|
|
// return nil, fmt.Errorf("hcsshim: VhdToTar: %s: failed to copyWithTimeout on the stdin pipe (to utility VM): %s", vhdHandle.Name(), err)
|
|
// }
|
|
// }
|
|
|
|
// // Start a goroutine which copies the stdout (ie the tar stream)
|
|
// reader, writer := io.Pipe()
|
|
// go func() {
|
|
// defer writer.Close()
|
|
// defer proc.Close()
|
|
// logrus.Debugf("hcsshim: VhdToTar: copying tar stream back from the utility VM")
|
|
// bytes, err := copyWithTimeout(writer, stdout, vhdSize, processOperationTimeoutSeconds, fmt.Sprintf("vhdtotarstream: copy tarstream from %s", command))
|
|
// if err != nil {
|
|
// logrus.Errorf("hcsshim: VhdToTar: %s: copyWithTimeout on the stdout pipe (from utility VM) failed: %s", vhdHandle.Name(), err)
|
|
// }
|
|
// logrus.Debugf("hcsshim: VhdToTar: copied %d bytes of the tarstream of %s from the utility VM", bytes, vhdHandle.Name())
|
|
// }()
|
|
|
|
// // Return the read-side of the pipe connected to the goroutine which is reading from the stdout of the process in the utility VM
|
|
// return reader, nil
|
|
}
|