// Run Parity - the main application entrypoint
func (p *Parity) Run() {
log.Banner(banner)
log.Debug("Loading plugins...")
p.LoadPlugins()
// Execute all plugins in parallel?
// TODO: Initial Sync may need to be blocking so that Run
// can work?
for _, pl := range p.SyncPlugins {
p.runAsync(pl.Sync)
}
// Run all Runners
for _, pl := range p.RunPlugins {
p.runAsync(pl.Run)
}
// Interrupt handler
sigChan := make(chan os.Signal, 1)
p.errorChan = make(chan error)
signal.Notify(sigChan, os.Interrupt, os.Kill)
select {
case e := <-p.errorChan:
log.Error(e.Error())
case <-sigChan:
log.Debug("Received interrupt, shutting down.")
p.Teardown()
}
}
// XServerProxy creates a TCP proxy on port 6000 to a the Unix
// socket that XQuartz is listening on.
//
// NOTE: this function does not start/install the XQuartz service
func XServerProxy(port int) {
if runtime.GOOS != "darwin" {
log.Debug("Not running an OSX environment, skip run X Server Proxy")
return
}
l, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
if err != nil {
log.Fatal(err)
}
defer l.Close()
// Send all traffic back to unix $DISPLAY socket on a running XQuartz server
addr, err := net.ResolveUnixAddr("unix", os.Getenv("DISPLAY"))
if err != nil {
log.Error("Error: ", err.Error())
}
log.Info("X Service Proxy available on all network interfaces on port %d", port)
if host, err := utils.DockerVMHost(); err == nil {
log.Info("Parity has detected your Docker environment and recommends running 'export DISPLAY=%s:0' in your container to forward the X display", host)
}
for {
xServerClient, err := net.DialUnix("unix", nil, addr)
if err != nil {
log.Error("Error: ", err.Error())
}
defer xServerClient.Close()
conn, err := l.Accept()
log.Debug("X Service Proxy connected to client on: %s (remote: %s)", conn.LocalAddr(), conn.RemoteAddr())
if err != nil {
log.Fatal(err)
}
go func(c net.Conn, s *net.UnixConn) {
buf := make([]byte, 8092)
io.CopyBuffer(s, c, buf)
s.CloseWrite()
}(conn, xServerClient)
go func(c net.Conn, s *net.UnixConn) {
buf := make([]byte, 8092)
io.CopyBuffer(c, s, buf)
c.Close()
}(conn, xServerClient)
}
}
// Attach attaches to the specified service in the running container
func (c *DockerCompose) Attach(config parity.ShellConfig) (err error) {
log.Stage("Interactive Shell")
log.Debug("Compose - starting docker compose services")
mergedConfig := *parity.DEFAULT_INTERACTIVE_SHELL_OPTIONS
mergo.MergeWithOverwrite(&mergedConfig, &config)
client := utils.DockerClient()
container := fmt.Sprintf("parity-%s_%s_1", c.pluginConfig.ProjectNameSafe, mergedConfig.Service)
opts := dockerclient.AttachToContainerOptions{
Stdin: true,
Stdout: true,
Stderr: true,
InputStream: os.Stdin,
OutputStream: os.Stdout,
ErrorStream: os.Stderr,
RawTerminal: true,
Container: container,
Stream: true,
Logs: true,
}
if c.project.Configs[config.Service] == nil {
return fmt.Errorf("Service %s does not exist", config.Service)
}
log.Step("Attaching to container '%s'", container)
if err := client.AttachToContainer(opts); err == nil {
err = c.project.Up(config.Service)
if err != nil {
log.Error("error: %s", err.Error())
return err
}
} else {
return err
}
_, err = client.WaitContainer(container)
log.Error("wc error: %s", err.Error())
log.Debug("Docker Compose Run() finished")
return err
}
func (e *Excludes) Set(value string) error {
r, err := regexp.CompilePOSIX(value)
if err == nil {
*e = append(*e, *r)
} else {
log.Error("Error:", err.Error())
}
return nil
}
// GetProject returns the Docker project from the configuration
func (c *DockerCompose) GetProject() (p *project.Project, err error) {
if _, err = os.Stat(c.ComposeFile); err == nil {
p, err = docker.NewProject(&docker.Context{
Context: project.Context{
ComposeFiles: []string{c.ComposeFile},
ProjectName: fmt.Sprintf("parity-%s", c.pluginConfig.ProjectNameSafe),
},
})
if err != nil {
log.Error("Could not create Compose project %s", err.Error())
return p, err
}
} else {
log.Error("Could not parse compose file: %s", err.Error())
return p, err
}
return p, nil
}
// Shell creates an interactive Docker session to the specified service
// starting it if not currently running
func (c *DockerCompose) Shell(config parity.ShellConfig) (err error) {
log.Stage("Interactive Shell")
log.Debug("Compose - starting docker compose services")
mergedConfig := *parity.DEFAULT_INTERACTIVE_SHELL_OPTIONS
mergo.MergeWithOverwrite(&mergedConfig, &config)
// Check if services running
// TODO: if running, attach to running container
// if NOT running, start services and attach
if c.project != nil {
log.Step("Starting compose services")
injectDisplayEnvironmentVariables(c.project)
}
container := fmt.Sprintf("parity-%s_%s_1", c.pluginConfig.ProjectNameSafe, mergedConfig.Service)
client := utils.DockerClient()
createExecOptions := dockerclient.CreateExecOptions{
AttachStdin: true,
AttachStdout: true,
AttachStderr: true,
Tty: true,
Cmd: mergedConfig.Command,
User: mergedConfig.User,
Container: container,
}
startExecOptions := dockerclient.StartExecOptions{
Detach: false,
Tty: true,
InputStream: os.Stdin,
OutputStream: os.Stdout,
ErrorStream: os.Stderr,
RawTerminal: true,
}
log.Step("Attaching to container '%s'", container)
if id, err := client.CreateExec(createExecOptions); err == nil {
client.StartExec(id.ID, startExecOptions)
} else {
log.Error("error: %v", err.Error())
}
log.Debug("Docker Compose Run() finished")
return 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
}
func SetupParityProject(config *Config) error {
log.Stage("Setup Parity Project")
// 1. Merge Config with Defaults -> need to create Base, Ci and Production image names
if err := expandAndValidateConfig(config); err != nil {
return err
}
var parityTemplate []string
// Scan template index file
if config.templateIndex != "" {
log.Step("Downloading template index: %s", config.templateIndex)
resp, err := http.Get(config.templateIndex)
if err != nil {
return err
}
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
parityTemplate = append(parityTemplate, scanner.Text())
}
}
// Make .parity dir if not exists
if _, err := os.Stat(".parity"); err == nil {
os.Mkdir(".parity", 0755)
}
errors := make(chan error)
done := make(chan bool)
defer close(done)
// Download and install templates in parallel
go func() {
wg := sync.WaitGroup{}
wg.Add(len(parityTemplate))
dir, _ := os.Getwd()
for _, f := range parityTemplate {
go func(f string, errorChan chan error) {
// 1. Check presence of local File - overwrite? TODO: config
targetFile := filepath.Join(dir, f)
if _, err := os.Stat(targetFile); err == nil {
if !config.Overwrite {
errorChan <- fmt.Errorf("File '%s' already exists. Please specify --force to overwrite files.", targetFile)
wg.Done()
return
}
}
// 2. Download resources
// 2a. TODO: Check/store local cache?
// 2b. Pull from remote
url := fmt.Sprintf(`%s/%s`, config.TemplateSourceURL, f)
log.Step("Downloading template file: %s", url)
resp, err := http.Get(url)
var file *os.File
if err == nil {
// 3. Interpolate template with Setup data
if file, err = tempFile(resp.Body, config); err != nil {
errorChan <- err
wg.Done()
return
}
} else {
log.Error("Error downloading template: %s", err.Error())
errorChan <- fmt.Errorf("Error downloading template: %s", err.Error())
wg.Done()
return
}
// 4. Move to local folder.
log.Debug("Moving %s -> %s", file.Name(), targetFile)
log.Debug("Ensuring parent dir exists: %s", filepath.Dir(targetFile))
os.MkdirAll(filepath.Dir(targetFile), 0755)
os.Rename(file.Name(), targetFile)
wg.Done()
}(f, errors)
}
wg.Wait()
done <- true
}()
select {
case e := <-errors:
log.Error(e.Error())
return e
case <-done:
log.Debug("Finished installing template")
}
log.Stage("Setup Parity Project : Complete")
return nil
}
// InstallParity installs Parity into the running Docker Machine
func InstallParity(config InstallConfig) {
log.Stage("Install Parity")
if config.DevHost == "" {
config.DevHost = "parity.local"
}
// Create DNS entry
if config.Dns {
hostname := strings.Split(utils.DockerHost(), ":")[0]
log.Step("Creating host entry: %s -> %s", hostname, config.DevHost)
var hosts goodhosts.Hosts
var err error
if hosts, err = goodhosts.NewHosts(); err == nil {
hosts.Add(hostname, config.DevHost)
} else {
log.Error("Unable to create DNS Entry: %s", err.Error())
}
if err = hosts.Flush(); err != nil {
log.Error("Unable to create DNS Entry: %s", err.Error())
}
}
// Check - is there a Docker Machine created?
// -> If so, use the currently selected machine
// -> If not, create another machine
// -> Persist these settings in ~/.parityrc?
// Wrap the local Docker command so that we don't have to use Docker Machine all of the time!
type FileTemplate struct {
Version string
}
templateData := FileTemplate{Version: version.Version}
// Create the install mirror daemon template
file := utils.CreateTemplateTempFile(templatesBootlocalShBytes, 0655, templateData)
session, err := utils.SSHSession(utils.DockerHost())
if err != nil {
log.Fatalf("Unable to connect to Docker utils.DockerHost(). Is Docker running? (%v)", err.Error())
}
log.Step("Installing bootlocal.sh on Docker Host")
remoteTmpFile := fmt.Sprintf("/tmp/%s", filepath.Base(file.Name()))
err = scp.CopyPath(file.Name(), remoteTmpFile, session)
utils.RunCommandWithDefaults(utils.DockerHost(), fmt.Sprintf("sudo cp %s %s", remoteTmpFile, "/var/lib/boot2docker/bootlocal.sh"))
session.Close()
file = utils.CreateTemplateTempFile(templatesMirrorDaemonShBytes, 0655, templateData)
session, err = utils.SSHSession(utils.DockerHost())
if err != nil {
log.Fatalf("Unable to connect to Docker utils.DockerHost(). Is Docker running? (%v)", err.Error())
}
log.Step("Installing mirror-daemon.sh on Docker Host")
remoteTmpFile = fmt.Sprintf("/tmp/%s", filepath.Base(file.Name()))
err = scp.CopyPath(file.Name(), remoteTmpFile, session)
utils.RunCommandWithDefaults(utils.DockerHost(), fmt.Sprintf("sudo cp %s %s", remoteTmpFile, "/var/lib/boot2docker/mirror-daemon.sh"))
session.Close()
log.Step("Downloading file sync utility (mirror)")
utils.RunCommandWithDefaults(utils.DockerHost(), fmt.Sprintf("sudo chmod +x /var/lib/boot2docker/*.sh"))
utils.RunCommandWithDefaults(utils.DockerHost(), fmt.Sprintf(" /var/lib/boot2docker/*.sh"))
utils.RunCommandWithDefaults(utils.DockerHost(), fmt.Sprintf("sudo /var/lib/boot2docker/bootlocal.sh start"))
log.Step("Restarting Docker")
utils.RunCommandWithDefaults(utils.DockerHost(), "sudo shutdown -r now")
utils.WaitForNetwork("docker", utils.DockerHost())
utils.WaitForNetwork("mirror", utils.MirrorHost())
// Removing shared folders
if utils.CheckSharedFolders() {
log.Step("Unmounting Virtualbox shared folders")
utils.UnmountSharedFolders()
}
log.Stage("Install Parity : Complete")
}
// Build will build all images in the Parity setup
func (c *DockerCompose) Build() error {
log.Stage("Bulding containers")
base := "Dockerfile"
cwd, _ := os.Getwd()
baseVersion := c.generateContainerVersion(cwd, base)
imageName := fmt.Sprintf("%s:%s", c.ImageName, baseVersion)
client, _ := dockerclient2.NewEnvClient()
log.Step("Checking if image %s exists locally", imageName)
if images, err := client.ImageList(context.Background(), types.ImageListOptions{MatchName: imageName}); err == nil {
for _, i := range images {
log.Info("Found image: %s", i.ID)
return nil
}
}
log.Step("Image %s not found locally, pulling", imageName)
client.ImagePull(context.Background(), types.ImagePullOptions{ImageID: imageName}, nil)
log.Step("Image %s not found anywhere, building", imageName)
ctx, err := c.CreateTar(".", "Dockerfile")
if err != nil {
return err
}
defer ctx.Close()
var progBuff io.Writer = os.Stdout
var buildBuff io.Writer = os.Stdout
// Setup an upload progress bar
progressOutput := streamformatter.NewStreamFormatter().NewProgressOutput(progBuff, true)
var body io.Reader = progress.NewProgressReader(ctx, progressOutput, 0, "", "Sending build context to Docker daemon")
logrus.Infof("Building %s...", imageName)
outFd, isTerminalOut := term.GetFdInfo(os.Stdout)
// Publish latest and specific version
response, err := client.ImageBuild(context.Background(), types.ImageBuildOptions{
Context: body,
Tags: []string{imageName, fmt.Sprintf("%s:latest", c.ImageName)},
NoCache: false,
Remove: true,
Dockerfile: "Dockerfile",
})
if err != nil {
log.Error(err.Error())
return err
}
err = jsonmessage.DisplayJSONMessagesStream(response.Body, buildBuff, outFd, isTerminalOut, nil)
if err != nil {
if jerr, ok := err.(*jsonmessage.JSONError); ok {
// If no error code is set, default to 1
if jerr.Code == 0 {
jerr.Code = 1
}
fmt.Fprintf(os.Stderr, "%s%s", progBuff, buildBuff)
return fmt.Errorf("Status: %s, Code: %d", jerr.Message, jerr.Code)
}
}
return err
}
