func processInjectFiles(container *pod.UserContainer, files map[string]pod.UserFile,
id, storageDriver, devPrefix, rootPath, sharedDir string) error {
for _, f := range container.Files {
targetPath := f.Path
if strings.HasSuffix(targetPath, "/") {
targetPath = targetPath + f.Filename
}
file, ok := files[f.Filename]
if !ok {
continue
}
var src io.Reader
if file.Uri != "" {
urisrc, err := utils.UriReader(file.Uri)
if err != nil {
return err
}
defer urisrc.Close()
src = urisrc
} else {
src = strings.NewReader(file.Contents)
}
switch file.Encoding {
case "base64":
src = base64.NewDecoder(base64.StdEncoding, src)
default:
}
if storageDriver == "devicemapper" {
err := dm.InjectFile(src, id, devPrefix, targetPath, rootPath,
utils.PermInt(f.Perm), utils.UidInt(f.User), utils.UidInt(f.Group))
if err != nil {
glog.Error("got error when inject files ", err.Error())
return err
}
} else if storageDriver == "aufs" || storageDriver == "overlay" {
err := storage.FsInjectFile(src, id, targetPath, sharedDir,
utils.PermInt(f.Perm), utils.UidInt(f.User), utils.UidInt(f.Group))
if err != nil {
glog.Error("got error when inject files ", err.Error())
return err
}
}
}
return nil
}
func (o *OverlayFsStorage) InjectFile(src io.Reader, containerId, target, rootDir string, perm, uid, gid int) error {
return storage.FsInjectFile(src, containerId, target, rootDir, perm, uid, gid)
}
func (daemon *Daemon) PrepareContainer(mypod *hypervisor.Pod, userPod *pod.UserPod,
vmId string) ([]*hypervisor.ContainerInfo, error) {
var (
fstype string
poolName string
volPoolName string
devPrefix string
rootPath string
devFullName string
rootfs string
err error
sharedDir = path.Join(hypervisor.BaseDir, vmId, hypervisor.ShareDirTag)
containerInfoList = []*hypervisor.ContainerInfo{}
storageDriver = daemon.Storage.StorageType
cli = daemon.DockerCli
)
if storageDriver == "devicemapper" {
poolName = daemon.Storage.PoolName
fstype = daemon.Storage.Fstype
volPoolName = "hyper-volume-pool"
devPrefix = poolName[:strings.Index(poolName, "-pool")]
rootPath = path.Join(utils.HYPER_ROOT, "devicemapper")
rootfs = "/rootfs"
} else if storageDriver == "aufs" {
rootPath = daemon.Storage.RootPath
fstype = daemon.Storage.Fstype
rootfs = ""
} else if storageDriver == "overlay" {
rootPath = daemon.Storage.RootPath
fstype = daemon.Storage.Fstype
rootfs = ""
} else if storageDriver == "vbox" {
fstype = daemon.Storage.Fstype
rootPath = daemon.Storage.RootPath
rootfs = "/rootfs"
_ = devPrefix
_ = volPoolName
_ = poolName
}
// Process the 'Files' section
files := make(map[string](pod.UserFile))
for _, v := range userPod.Files {
files[v.Name] = v
}
for i, c := range mypod.Containers {
var jsonResponse *dockertypes.ContainerJSONRaw
if jsonResponse, err = cli.GetContainerInfo(c.Id); err != nil {
glog.Error("got error when get container Info ", err.Error())
return nil, err
}
if c.Name == "" {
c.Name = jsonResponse.Name
}
if c.Image == "" {
c.Image = jsonResponse.Config.Image
}
if storageDriver == "devicemapper" {
if err := dm.CreateNewDevice(c.Id, devPrefix, rootPath); err != nil {
return nil, err
}
devFullName, err = dm.MountContainerToSharedDir(c.Id, sharedDir, devPrefix)
if err != nil {
glog.Error("got error when mount container to share dir ", err.Error())
return nil, err
}
fstype, err = dm.ProbeFsType(devFullName)
if err != nil {
fstype = "ext4"
}
} else if storageDriver == "aufs" {
devFullName, err = aufs.MountContainerToSharedDir(c.Id, rootPath, sharedDir, "")
if err != nil {
glog.Error("got error when mount container to share dir ", err.Error())
return nil, err
}
devFullName = "/" + c.Id + "/rootfs"
} else if storageDriver == "overlay" {
devFullName, err = overlay.MountContainerToSharedDir(c.Id, rootPath, sharedDir, "")
if err != nil {
glog.Error("got error when mount container to share dir ", err.Error())
return nil, err
}
devFullName = "/" + c.Id + "/rootfs"
} else if storageDriver == "vbox" {
devFullName, err = vbox.MountContainerToSharedDir(c.Id, rootPath, "")
if err != nil {
glog.Error("got error when mount container to share dir ", err.Error())
return nil, err
}
fstype = "ext4"
}
for _, f := range userPod.Containers[i].Files {
targetPath := f.Path
if strings.HasSuffix(targetPath, "/") {
targetPath = targetPath + f.Filename
}
file, ok := files[f.Filename]
if !ok {
continue
}
var src io.Reader
if file.Uri != "" {
urisrc, err := utils.UriReader(file.Uri)
if err != nil {
return nil, err
}
defer urisrc.Close()
src = urisrc
} else {
src = strings.NewReader(file.Contents)
}
switch file.Encoding {
case "base64":
src = base64.NewDecoder(base64.StdEncoding, src)
default:
}
if storageDriver == "devicemapper" {
err := dm.InjectFile(src, c.Id, devPrefix, targetPath, rootPath,
utils.PermInt(f.Perm), utils.UidInt(f.User), utils.UidInt(f.Group))
if err != nil {
glog.Error("got error when inject files ", err.Error())
return nil, err
}
} else if storageDriver == "aufs" || storageDriver == "overlay" {
err := storage.FsInjectFile(src, c.Id, targetPath, sharedDir,
utils.PermInt(f.Perm), utils.UidInt(f.User), utils.UidInt(f.Group))
if err != nil {
glog.Error("got error when inject files ", err.Error())
return nil, err
}
}
}
env := make(map[string]string)
for _, v := range jsonResponse.Config.Env {
env[v[:strings.Index(v, "=")]] = v[strings.Index(v, "=")+1:]
}
for _, e := range userPod.Containers[i].Envs {
env[e.Env] = e.Value
}
glog.V(1).Infof("Parsing envs for container %d: %d Evs", i, len(env))
glog.V(1).Infof("The fs type is %s", fstype)
glog.V(1).Infof("WorkingDir is %s", string(jsonResponse.Config.WorkingDir))
glog.V(1).Infof("Image is %s", string(devFullName))
containerInfo := &hypervisor.ContainerInfo{
Id: c.Id,
Rootfs: rootfs,
Image: devFullName,
Fstype: fstype,
Workdir: jsonResponse.Config.WorkingDir,
Entrypoint: jsonResponse.Config.Entrypoint.Slice(),
Cmd: jsonResponse.Config.Cmd.Slice(),
Envs: env,
}
glog.V(1).Infof("Container Info is \n%v", containerInfo)
containerInfoList = append(containerInfoList, containerInfo)
glog.V(1).Infof("container %d created %s, workdir %s, env: %v", i, c.Id, jsonResponse.Config.WorkingDir, env)
}
return containerInfoList, nil
}