// ReadComposeVolumes reads a docker-compose.yml and return a slice of
// directories to sync into the Docker Host
//
// "." and "./." is converted to the current directory parity is running from.
// Any volume starting with "/" will be treated as an absolute path.
// All other volumes (e.g. starting with "./" or without a prefix "/") will be treated as
// relative paths.
func ReadComposeVolumes() []string {
var volumes []string
files := FindDockerComposeFiles()
for i, file := range files {
if _, err := os.Stat(file); err == nil {
project, err := docker.NewProject(&docker.Context{
Context: project.Context{
ComposeFiles: []string{file},
ProjectName: fmt.Sprintf("parity-%d", i),
},
})
if err != nil {
log.Info("Could not parse compose file")
}
for _, c := range project.Configs {
for _, v := range c.Volumes {
v = strings.SplitN(v, ":", 2)[0]
if v == "." || v == "./." {
v, _ = os.Getwd()
} else if strings.Index(v, "/") != 0 {
cwd, _ := os.Getwd()
v = fmt.Sprintf("%s/%s", cwd, v)
}
volumes = append(volumes, mutils.LinuxPath(v))
}
}
}
}
return volumes
}
// Converts a FileInfo -> StdFile
func FromFileInfo(dir string, i os.FileInfo) filesystem.File {
path := utils.LinuxPath(fmt.Sprintf("%s/%s", dir, i.Name()))
file := filesystem.File{
FileName: i.Name(),
FilePath: path,
FileMode: i.Mode(),
FileSize: i.Size(),
FileModTime: i.ModTime(),
}
return file
}
func (fs StdFileSystem) Dir(dir string) ([]filesystem.File, error) {
readFiles, err := ioutil.ReadDir(utils.LinuxPath(fmt.Sprintf("%v/", dir)))
if err == nil {
files := make([]filesystem.File, len(readFiles))
for i, file := range readFiles {
files[i] = FromFileInfo(dir, file)
}
return files, nil
} else {
return nil, err
}
}
func (p *Mirror) Sync() error {
log.Stage("Synchronising source/dest folders")
pkiMgr, err := pki.New()
pkiMgr.Config.Insecure = true
if err != nil {
p.pluginConfig.Ui.Error(fmt.Sprintf("Unable to setup public key infrastructure: %s", err.Error()))
}
Config, err := pkiMgr.GetClientTLSConfig()
if err != nil {
p.pluginConfig.Ui.Error(fmt.Sprintf("%v", err))
}
// Removing shared folders
if utils.CheckSharedFolders() {
utils.UnmountSharedFolders()
}
// Read volumes for share/watching
var volumes []string
// Exclude non-local volumes (e.g. might want to mount a dir on the VM guest)
for _, v := range utils.ReadComposeVolumes() {
if _, err := os.Stat(v); err == nil {
volumes = append(volumes, v)
}
}
// Add PWD if nothing in compose
dir, _ := os.Getwd()
if len(volumes) == 0 {
volumes = append(volumes, mutils.LinuxPath(dir))
}
pki.MirrorConfig.ClientTlsConfig = Config
excludes := make([]regexp.Regexp, len(p.Exclude))
for i, v := range p.Exclude {
r, err := regexp.CompilePOSIX(v)
if err == nil {
excludes[i] = *r
} else {
log.Error("Error parsing Regex:", err.Error())
}
}
options := &sync.Options{Exclude: excludes, Verbose: p.Verbose}
// Sync and watch all volumes
for _, v := range volumes {
log.Step("Syncing contents of '%s' -> '%s'", v, fmt.Sprintf("mirror://%s%s", utils.MirrorHost(), v))
err = sync.Sync(v, fmt.Sprintf("mirror://%s%s", utils.MirrorHost(), v), options)
if err != nil {
log.Error("Error during initial file sync: %v", err)
}
log.Step("Monitoring '%s' for changes", v)
go sync.Watch(v, fmt.Sprintf("mirror://%s%s", utils.MirrorHost(), v), options)
}
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, os.Interrupt, os.Kill)
<-sigChan
log.Debug("Interrupt received, shutting down")
return nil
}