func DeleteNodebyData(path string, conn *zk.Conn, data []byte) error { children, _, err := conn.Children(path) if err != nil { glog.Warning("Could not list children") return err } for _, child := range children { child_path := path + "/" + child child_data, _, err := conn.Get(child_path) if err != nil { glog.Warning("Could not get data for %s", child_path) continue } if bytes.Compare(data, child_data) == 0 { for i := 0; i < 5; i++ { _, stats, _ := conn.Get(child_path) err = conn.Delete(child_path, stats.Version) if err == nil || err == zk.ErrNoNode { return nil } } glog.Error("Could not delete matched node %s", child_path) } } return nil }
func (p *ProcessInstance) ReadResponse(ns *socketio.NameSpace) { ns.On("stdout", func(n *socketio.NameSpace, stdout string) { glog.V(4).Infof("Process received stdout: %s", stdout) if p.closed { glog.Warning("connection closed; cannot write stdout: %s", stdout) } else { for _, b := range []byte(stdout) { p.Stdout <- b } } }) ns.On("stderr", func(n *socketio.NameSpace, stderr string) { glog.V(4).Infof("Process received stderr: %s", stderr) if p.closed { glog.Warning("connection closed; cannot write stderr: %s", stderr) } else { for _, b := range []byte(stderr) { p.Stderr <- b } } }) ns.On("result", func(n *socketio.NameSpace, result Result) { glog.V(0).Infof("Process received result: %s", result) p.Result <- result }) glog.V(0).Info("Hooked up outgoing events!") }
// this function takes a filter directory and creates a map // of filters by looking at the content in that directory. // it is assumed the filter name is the name of the file minus // the .conf part. So test.conf would be a filter named "test" func getFiltersFromDirectory(path string) (filters map[string]string, err error) { filters = make(map[string]string) subpaths, err := ioutil.ReadDir(path) if err != nil { return nil, err } for _, subpath := range subpaths { filterName := subpath.Name() // make sure it is a valid filter if !strings.HasSuffix(filterName, ".conf") { glog.Warning("Skipping %s because it doesn't have a .conf extension", filterName) continue } // read the contents and add it to our map contents, err := ioutil.ReadFile(path + "/" + filterName) if err != nil { glog.Errorf("Unable to read the file %s, skipping", path+"/"+filterName) continue } filterName = strings.TrimSuffix(filterName, ".conf") filters[filterName] = string(contents) } glog.V(2).Infof("Here are the filters %v from path %s", filters, path) return filters, nil }
func (p *ProcessInstance) ReadRequest(ns *socketio.NameSpace) { ns.On("signal", func(n *socketio.NameSpace, signal int) { glog.V(4).Infof("received signal %d", signal) if p.disconnected { glog.Warning("disconnected; cannot send signal: %s", signal) } }) ns.On("stdin", func(n *socketio.NameSpace, stdin string) { glog.V(4).Infof("Received stdin: %s", stdin) if p.disconnected { glog.Warning("disconnected; cannot send stdin: %s", stdin) } else { for _, b := range []byte(stdin) { p.Stdin <- b } } }) glog.V(0).Info("Hooked up incoming events!") }
func (c *Controller) checkPrereqs(prereqsPassed chan bool, rpcDead chan struct{}) error { if len(c.prereqs) == 0 { glog.Infof("No prereqs to pass.") prereqsPassed <- true return nil } healthCheckInterval := time.Tick(1 * time.Second) for { select { case <-rpcDead: glog.Fatalf("Exiting, RPC server has gone away") case <-healthCheckInterval: failedAny := false for _, script := range c.prereqs { glog.Infof("Running prereq command: %s", script.Script) cmd := exec.Command("sh", "-c", script.Script) err := cmd.Run() if err != nil { msg := fmt.Sprintf("Not starting service yet, waiting on prereq: %s", script.Name) glog.Warning(msg) fmt.Fprintln(os.Stderr, msg) failedAny = true break } else { glog.Infof("Passed prereq [%s].", script.Name) } } if !failedAny { glog.Infof("Passed all prereqs.") prereqsPassed <- true return nil } } } return nil }
// createVolumeDir() creates a directory on the running host using the user ids // found within the specified image. For example, it can create a directory owned // by the mysql user (as seen by the container) despite there being no mysql user // on the host system. // Assumes that the local docker image (imageSpec) exists and has been sync'd // with the registry. func createVolumeDir(hostPath, containerSpec, imageSpec, userSpec, permissionSpec string) error { createVolumeDirMutex.Lock() defer createVolumeDirMutex.Unlock() dotfileCompatibility := path.Join(hostPath, ".serviced.initialized") // for compatibility with previous versions of serviced dotfileHostPath := path.Join(filepath.Dir(hostPath), fmt.Sprintf(".%s.serviced.initialized", filepath.Base(hostPath))) dotfiles := []string{dotfileCompatibility, dotfileHostPath} for _, dotfileHostPath := range dotfiles { _, err := os.Stat(dotfileHostPath) if err == nil { glog.V(2).Infof("DFS volume initialized earlier for src:%s dst:%s image:%s user:%s perm:%s", hostPath, containerSpec, imageSpec, userSpec, permissionSpec) return nil } } starttime := time.Now() var err error var output []byte command := [...]string{ "docker", "run", "--rm", "-v", hostPath + ":/mnt/dfs", imageSpec, "/bin/bash", "-c", fmt.Sprintf(` set -e if [ ! -d "%s" ]; then echo "WARNING: DFS mount %s does not exist in image %s" else cp -rp %s/. /mnt/dfs/ fi chown %s /mnt/dfs chmod %s /mnt/dfs sync `, containerSpec, containerSpec, imageSpec, containerSpec, userSpec, permissionSpec), } for i := 0; i < 2; i++ { docker := exec.Command(command[0], command[1:]...) output, err = docker.CombinedOutput() if err == nil { duration := time.Now().Sub(starttime) if strings.Contains(string(output), "WARNING:") { glog.Warning(string(output)) } else { glog.Info(string(output)) } glog.Infof("DFS volume init #%d took %s for src:%s dst:%s image:%s user:%s perm:%s", i, duration, hostPath, containerSpec, imageSpec, userSpec, permissionSpec) if e := ioutil.WriteFile(dotfileHostPath, []byte(""), 0664); e != nil { glog.Errorf("unable to create DFS volume initialized dotfile %s: %s", dotfileHostPath, e) return e } return nil } time.Sleep(time.Second) glog.Warningf("retrying due to error creating DFS volume %+v: %s", hostPath, string(output)) } glog.Errorf("could not create DFS volume %+v: %s", hostPath, string(output)) return err }