// REST: /pipelines func (s *HttpServer) CreatePipeline(resp http.ResponseWriter, req *http.Request) { body, err := ioutil.ReadAll(req.Body) if err != nil { log.Warnf("Failed to read request body : %v", err) http.Error(resp, err.Error(), http.StatusInternalServerError) return } log.Println(string(body[:])) var pipeline structs.Pipeline if err := yaml.Unmarshal(body, &pipeline); err != nil { log.Warnf("Failed to unmarshal request : %v", err) http.Error(resp, err.Error(), http.StatusBadRequest) return } if err := req.ParseForm(); err != nil { log.Warnf("Failed to parse form: %v", err) http.Error(resp, err.Error(), http.StatusInternalServerError) return } err1 := s.db.Update(func(tx *bolt.Tx) error { b := tx.Bucket([]byte("pipelines")) log.Printf("Creating pipeline: %s", pipeline.Name) return b.Put([]byte(pipeline.Name), body) }) if err1 != nil { log.Warnf("Failed to create pipeline: %v", err1) http.Error(resp, err1.Error(), http.StatusInternalServerError) return } }
func (m DefaultManager) uploadUsage() { id := "anon" ifaces, err := net.Interfaces() if err == nil { for _, iface := range ifaces { if iface.Name != "lo" { hw := iface.HardwareAddr.String() id = strings.Replace(hw, ":", "", -1) break } } } usage := &shipyard.Usage{ ID: id, Version: version.Version, } b, err := json.Marshal(usage) if err != nil { log.Warnf("error serializing usage info: %s", err) } buf := bytes.NewBuffer(b) if _, err := http.Post(fmt.Sprintf("%s/update", trackerHost), "application/json", buf); err != nil { log.Warnf("error sending usage info: %s", err) } }
func (c *controller) cleanupLocalEndpoints() { nl, err := c.getNetworksForScope(datastore.LocalScope) if err != nil { log.Warnf("Could not get list of networks during endpoint cleanup: %v", err) return } for _, n := range nl { epl, err := n.getEndpointsFromStore() if err != nil { log.Warnf("Could not get list of endpoints in network %s during endpoint cleanup: %v", n.name, err) continue } for _, ep := range epl { log.Infof("Removing stale endpoint %s (%s)", ep.name, ep.id) if err := ep.Delete(true); err != nil { log.Warnf("Could not delete local endpoint %s during endpoint cleanup: %v", ep.name, err) } } epl, err = n.getEndpointsFromStore() if err != nil { log.Warnf("Could not get list of endpoints in network %s for count update: %v", n.name, err) continue } epCnt := n.getEpCnt().EndpointCnt() if epCnt != uint64(len(epl)) { log.Infof("Fixing inconsistent endpoint_cnt for network %s. Expected=%d, Actual=%d", n.name, len(epl), epCnt) n.getEpCnt().setCnt(uint64(len(epl))) } } }
func getRootUserDetails(readPasswdCmd []string) (uid, gid, shell string) { uid = "0" gid = "0" shell = "/bin/sh" cmd := exec.Command(readPasswdCmd[0], readPasswdCmd[1:]...) cmdBuffer := &bytes.Buffer{} cmd.Stdout = cmdBuffer if err := cmd.Run(); err != nil { log.Warnf( "getRootUserDetails(): error running read passwd command %q: %s", strings.Join(readPasswdCmd, " "), err, ) return } entries, err := passwd.ParseReader(cmdBuffer) if err != nil { log.Warnf("getRootUserDetails(): error parsing passwd: %s", err) return } entry, ok := entries["root"] if !ok { log.Warnf("getRootUserDetails(): no root entry in passwd") return } return entry.Uid, entry.Gid, entry.Shell }
func (l *Layer0) Remove(id string) error { if !l.isLayer0(id) { return l.Driver.Remove(l.realID(id)) } l.Lock() defer l.Unlock() var err error v, ok := l.volumes[id] if ok { atomic.AddInt32(&v.ref, -1) if v.ref == 0 { // Save the upper dir and blow away the rest. upperDir := path.Join(path.Join(l.home, l.realID(id)), "upper") err := os.Rename(upperDir, path.Join(v.path, "upper")) if err != nil { log.Warnf("Failed in rename(%v): %v", id, err) } l.Driver.Remove(l.realID(id)) err = l.volDriver.Unmount(v.volumeID, v.path) if l.volDriver.Type()&api.Block != 0 { _ = l.volDriver.Detach(v.volumeID) } err = os.RemoveAll(v.path) delete(l.volumes, v.id) } } else { log.Warnf("Failed to find layer0 vol for id %v", id) } return err }
// adaptContainerSettings is called during container creation to modify any // settings necessary in the HostConfig structure. func (daemon *Daemon) adaptContainerSettings(hostConfig *containertypes.HostConfig, adjustCPUShares bool) error { if adjustCPUShares && hostConfig.CPUShares > 0 { // Handle unsupported CPUShares if hostConfig.CPUShares < linuxMinCPUShares { logrus.Warnf("Changing requested CPUShares of %d to minimum allowed of %d", hostConfig.CPUShares, linuxMinCPUShares) hostConfig.CPUShares = linuxMinCPUShares } else if hostConfig.CPUShares > linuxMaxCPUShares { logrus.Warnf("Changing requested CPUShares of %d to maximum allowed of %d", hostConfig.CPUShares, linuxMaxCPUShares) hostConfig.CPUShares = linuxMaxCPUShares } } if hostConfig.Memory > 0 && hostConfig.MemorySwap == 0 { // By default, MemorySwap is set to twice the size of Memory. hostConfig.MemorySwap = hostConfig.Memory * 2 } if hostConfig.ShmSize == 0 { hostConfig.ShmSize = container.DefaultSHMSize } var err error opts, err := daemon.generateSecurityOpt(hostConfig.IpcMode, hostConfig.PidMode, hostConfig.Privileged) if err != nil { return err } hostConfig.SecurityOpt = append(hostConfig.SecurityOpt, opts...) if hostConfig.MemorySwappiness == nil { defaultSwappiness := int64(-1) hostConfig.MemorySwappiness = &defaultSwappiness } if hostConfig.OomKillDisable == nil { defaultOomKillDisable := false hostConfig.OomKillDisable = &defaultOomKillDisable } return nil }
// New returns a new SysInfo, using the filesystem to detect which features the kernel supports. func New(quiet bool) *SysInfo { sysInfo := &SysInfo{} if cgroupMemoryMountpoint, err := cgroups.FindCgroupMountpoint("memory"); err != nil { if !quiet { logrus.Warnf("Your kernel does not support cgroup memory limit: %v", err) } } else { // If memory cgroup is mounted, MemoryLimit is always enabled. sysInfo.MemoryLimit = true _, err1 := ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.memsw.limit_in_bytes")) sysInfo.SwapLimit = err1 == nil if !sysInfo.SwapLimit && !quiet { logrus.Warn("Your kernel does not support swap memory limit.") } _, err = ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.oom_control")) sysInfo.OomKillDisable = err == nil if !sysInfo.OomKillDisable && !quiet { logrus.Warnf("Your kernel does not support oom control.") } } if cgroupCpuMountpoint, err := cgroups.FindCgroupMountpoint("cpu"); err != nil { if !quiet { logrus.Warnf("%v", err) } } else { _, err1 := ioutil.ReadFile(path.Join(cgroupCpuMountpoint, "cpu.cfs_quota_us")) sysInfo.CpuCfsQuota = err1 == nil if !sysInfo.CpuCfsQuota && !quiet { logrus.Warn("Your kernel does not support cgroup cfs quotas") } } // Checek if ipv4_forward is disabled. if data, err := ioutil.ReadFile("/proc/sys/net/ipv4/ip_forward"); os.IsNotExist(err) { sysInfo.IPv4ForwardingDisabled = true } else { if enabled, _ := strconv.Atoi(strings.TrimSpace(string(data))); enabled == 0 { sysInfo.IPv4ForwardingDisabled = true } else { sysInfo.IPv4ForwardingDisabled = false } } // Check if AppArmor is supported. if _, err := os.Stat("/sys/kernel/security/apparmor"); os.IsNotExist(err) { sysInfo.AppArmor = false } else { sysInfo.AppArmor = true } // Check if Devices cgroup is mounted, it is hard requirement for container security. if _, err := cgroups.FindCgroupMountpoint("devices"); err != nil { logrus.Fatalf("Error mounting devices cgroup: %v", err) } return sysInfo }
func setupIPv6Forwarding(config *networkConfiguration, i *bridgeInterface) error { // Get current IPv6 default forwarding setup ipv6ForwardDataDefault, err := ioutil.ReadFile(ipv6ForwardConfDefault) if err != nil { return fmt.Errorf("Cannot read IPv6 default forwarding setup: %v", err) } // Enable IPv6 default forwarding only if it is not already enabled if ipv6ForwardDataDefault[0] != '1' { if err := ioutil.WriteFile(ipv6ForwardConfDefault, []byte{'1', '\n'}, ipv6ForwardConfPerm); err != nil { logrus.Warnf("Unable to enable IPv6 default forwarding: %v", err) } } // Get current IPv6 all forwarding setup ipv6ForwardDataAll, err := ioutil.ReadFile(ipv6ForwardConfAll) if err != nil { return fmt.Errorf("Cannot read IPv6 all forwarding setup: %v", err) } // Enable IPv6 all forwarding only if it is not already enabled if ipv6ForwardDataAll[0] != '1' { if err := ioutil.WriteFile(ipv6ForwardConfAll, []byte{'1', '\n'}, ipv6ForwardConfPerm); err != nil { logrus.Warnf("Unable to enable IPv6 all forwarding: %v", err) } } return nil }
// New creates a new instance of network controller. func New(configFile string) (NetworkController, error) { c := &controller{ networks: networkTable{}, sandboxes: sandboxTable{}, drivers: driverTable{}} if err := initDrivers(c); err != nil { return nil, err } if err := c.initConfig(configFile); err == nil { if err := c.initDataStore(); err != nil { // Failing to initalize datastore is a bad situation to be in. // But it cannot fail creating the Controller log.Warnf("Failed to Initialize Datastore due to %v. Operating in non-clustered mode", err) } if err := c.initDiscovery(); err != nil { // Failing to initalize discovery is a bad situation to be in. // But it cannot fail creating the Controller log.Warnf("Failed to Initialize Discovery : %v", err) } } else { // Missing Configuration file is not a failure scenario // But without that, datastore cannot be initialized. log.Debugf("Unable to Parse LibNetwork Config file : %v", err) } return c, nil }
func UpdateGitHub(gh *github.Client, cache *Cache) { for { logrus.Infof("Fetching GitHub...") for cache.Manifest == nil || len(cache.Manifest.Images) == 0 { time.Sleep(time.Second) } changes := 0 for _, image := range cache.Manifest.Images { if _, found := cache.GithubRepos[image.RepoPath()]; !found { repo, err := image.GithubGetRepo(gh) if err != nil { logrus.Warnf("Failed to fetch repo %q: %v", image.RepoPath(), err) } else { cache.GithubRepos[image.RepoPath()] = repo changes++ } } if _, found := cache.GithubLastRefs[image.RepoPath()]; !found { ref, err := image.GithubGetLastRef(gh) if err != nil { logrus.Warnf("Failed to fetch repo last reference %q: %v", image.RepoPath(), err) } else { cache.GithubLastRefs[image.RepoPath()] = ref changes++ } } } if changes > 0 { cache.MapImages() } time.Sleep(5 * time.Minute) } }
//Write a set of annotations associated with a piece of content. Any annotations //already there will be removed func (s service) Write(contentUUID string, thing interface{}) (err error) { annotationsToWrite := thing.(annotations) if contentUUID == "" { return errors.New("Content uuid is required") } if err := validateAnnotations(&annotationsToWrite); err != nil { log.Warnf("Validation of supplied annotations failed") return err } if len(annotationsToWrite) == 0 { log.Warnf("No new annotations supplied for content uuid: %s", contentUUID) } queries := append([]*neoism.CypherQuery{}, dropAllAnnotationsQuery(contentUUID, s.platformVersion)) var statements = []string{} for _, annotationToWrite := range annotationsToWrite { query, err := createAnnotationQuery(contentUUID, annotationToWrite, s.platformVersion) if err != nil { return err } statements = append(statements, query.Statement) queries = append(queries, query) } log.Infof("Updated Annotations for content uuid: %s", contentUUID) log.Debugf("For update, ran statements: %+v", statements) return s.conn.CypherBatch(queries) }
func bridgeCleanup(config *networkConfiguration, logErr bool) { var err error bridgeName := config.BridgeName tableName := "bridge_nw_subnets" gwName := fmt.Sprintf("%s_gw0", bridgeName) gwIP := config.AddressIPv4.String() pfAnchor := fmt.Sprintf("_auto/docker/%s", bridgeName) tableAnchor := fmt.Sprintf("_auto/docker/%s", tableName) err = exec.Command("/usr/sbin/pfctl", "-a", pfAnchor, "-F", "all").Run() if err != nil && logErr { logrus.Warnf("cannot flush firewall rules") } err = exec.Command("/usr/sbin/ifconfig", gwName, "unplumb").Run() if err != nil && logErr { logrus.Warnf("cannot remove gateway interface") } err = exec.Command("/usr/sbin/dladm", "delete-vnic", "-t", gwName).Run() if err != nil && logErr { logrus.Warnf("cannot delete vnic") } err = exec.Command("/usr/sbin/dladm", "delete-etherstub", "-t", config.BridgeNameInternal).Run() if err != nil && logErr { logrus.Warnf("cannot delete etherstub") } err = exec.Command("/usr/sbin/pfctl", "-a", tableAnchor, "-t", tableName, "-T", "delete", gwIP).Run() if err != nil && logErr { logrus.Warnf("cannot remove bridge network '%s' from PF table", bridgeName) } }
func (r *remote) getLastEventTimestamp() time.Time { t := time.Now() fi, err := os.Stat(r.eventTsPath) if os.IsNotExist(err) || fi.Size() == 0 { return t } f, err := os.Open(r.eventTsPath) if err != nil { logrus.Warnf("libcontainerd: Unable to access last event ts: %v", err) return t } defer f.Close() b := make([]byte, fi.Size()) n, err := f.Read(b) if err != nil || n != len(b) { logrus.Warnf("libcontainerd: Unable to read last event ts: %v", err) return t } t.UnmarshalText(b) return t }
// adaptContainerSettings is called during container creation to modify any // settings necessary in the HostConfig structure. func (daemon *Daemon) adaptContainerSettings(hostConfig *runconfig.HostConfig, adjustCPUShares bool) error { if adjustCPUShares && hostConfig.CPUShares > 0 { // Handle unsupported CPUShares if hostConfig.CPUShares < linuxMinCPUShares { logrus.Warnf("Changing requested CPUShares of %d to minimum allowed of %d", hostConfig.CPUShares, linuxMinCPUShares) hostConfig.CPUShares = linuxMinCPUShares } else if hostConfig.CPUShares > linuxMaxCPUShares { logrus.Warnf("Changing requested CPUShares of %d to maximum allowed of %d", hostConfig.CPUShares, linuxMaxCPUShares) hostConfig.CPUShares = linuxMaxCPUShares } } if hostConfig.Memory > 0 && hostConfig.MemorySwap == 0 { // By default, MemorySwap is set to twice the size of Memory. hostConfig.MemorySwap = hostConfig.Memory * 2 } if hostConfig.ShmSize == nil { shmSize := container.DefaultSHMSize hostConfig.ShmSize = &shmSize } var err error if hostConfig.SecurityOpt == nil { hostConfig.SecurityOpt, err = daemon.generateSecurityOpt(hostConfig.IpcMode, hostConfig.PidMode) if err != nil { return err } } if hostConfig.MemorySwappiness == nil { defaultSwappiness := int64(-1) hostConfig.MemorySwappiness = &defaultSwappiness } return nil }
func (p peer) handleIncoming() { defer p.isRunning.Done() for { var msg map[string]interface{} err := p.conn.ReadJSON(&msg) if err != nil { logrus.Warnf("%s|%s (%s) disconnected: %s", p.remote, p.component.Name, p.component.Type, err) p.conn.Close() p.component.StateSink <- fmt.Errorf("Connection lost") return } logrus.Infof("%s|%s (%s) sent: %s", p.remote, p.component.Name, p.component.Type, msg) switch msg["topic"] { case "state_changed": p.component.StateSink <- msg["state"] case "register_service": err = p.handleServiceRegistration(msg) if err != nil { logrus.Warnf("Component: %s failed to register a service call: %s", p.component.URN(), err) } default: logrus.Warnf("%s|%s (%s) sent bogus topic: %s", p.remote, p.component.Name, p.component.Type, msg["topic"]) } } }
func byteArrayToSubnets(ba []byte) map[subnetKey]*SubnetInfo { m := map[subnetKey]*SubnetInfo{} if ba == nil || len(ba) == 0 { return m } var mm map[string]string err := json.Unmarshal(ba, &mm) if err != nil { log.Warnf("Failed to decode subnets byte array: %v", err) return m } for ks, vs := range mm { sk := subnetKey{} if err := sk.FromString(ks); err != nil { log.Warnf("Failed to decode subnets map entry: (%s, %s)", ks, vs) continue } si := &SubnetInfo{} _, nw, err := net.ParseCIDR(vs) if err != nil { log.Warnf("Failed to decode subnets map entry value: (%s, %s)", ks, vs) continue } si.Subnet = nw m[sk] = si } return m }
// init compiles checks and sanatizes the conditon before returning itself func (c *Condition) init(groupBy *event.TagSet) { c.checks = c.compileChecks() c.eventTrackers = make(map[string]*eventTracker) // fixes issue where occurences are hit, even when the event doesn't satisify the condition if c.Occurences < 1 { logrus.Warnf("Occurences must be > 1. %d given. Occurences for this condition will be set to 1.", c.Occurences) c.Occurences = 1 } // if we have no trackers already, make an empty map of them if c.eventTrackers == nil { c.eventTrackers = make(map[string]*eventTracker) } // WindowSize must be above 2. At least one piece of data is needed for historical checks. if c.WindowSize < 2 { logrus.Warnf("WindowSize must be >= 1. %d given. Window size for this condition will be set to %d", c.WindowSize, DEFAULT_WINDOW_SIZE) c.WindowSize = DEFAULT_WINDOW_SIZE } // decide which tracking method we will use c.trackFunc = getTrackingFunc(c) c.ready = true }
func (c *containerBase) kill(ctx context.Context) error { // make sure we have vm if c.vm == nil { return NotYetExistError{c.ExecConfig.ID} } wait := 10 * time.Second // default sig := string(ssh.SIGKILL) log.Infof("sending kill -%s %s", sig, c.ExecConfig.ID) err := c.startGuestProgram(ctx, "kill", sig) if err == nil { log.Infof("waiting %s for %s to power off", wait, c.ExecConfig.ID) timeout, err := c.waitForPowerState(ctx, wait, types.VirtualMachinePowerStatePoweredOff) if err == nil { return nil // VM has powered off } if timeout { log.Warnf("timeout (%s) waiting for %s to power off via SIG%s", wait, c.ExecConfig.ID, sig) } } if err != nil { log.Warnf("killing %s attempt resulted in: %s", c.ExecConfig.ID, err) } log.Warnf("killing %s via hard power off", c.ExecConfig.ID) return c.poweroff(ctx) }
// RealAPIContext returns a CommandContext with a configured API func RealAPIContext() *CommandContext { if os.Getenv("TEST_WITH_REAL_API") == "0" { return nil } config, err := config.GetConfig() if err != nil { logrus.Warnf("RealAPIContext: failed to call config.GetConfig(): %v", err) return nil } apiClient, err := api.NewScalewayAPI(config.Organization, config.Token, scwversion.UserAgent(), "par1") if err != nil { logrus.Warnf("RealAPIContext: failed to call api.NewScalewayAPI(): %v", err) return nil } stdout := bytes.Buffer{} stderr := bytes.Buffer{} ctx := CommandContext{ Streams: Streams{ Stdin: os.Stdin, Stdout: &stdout, Stderr: &stderr, }, Env: []string{ "HOME" + os.Getenv("HOME"), }, RawArgs: []string{}, API: apiClient, } return &ctx }
func procesImage(path string, f os.FileInfo, err error) error { if f.IsDir() { return nil } log.Debugf("Processing %s", path) extension := filepath.Ext(f.Name()) if !isSupportPhotoType(strings.ToLower(extension)) { log.Warnf("%s's file type %s is unsupported", path, extension) return nil } reader := exif.New() err = reader.Open(path) if err != nil { log.Fatal(err) } str := fmt.Sprintf("%s", reader.Tags["Date and Time"]) t := f.ModTime() if len(str) == 0 { log.Warnf("Date and Time EXIF tag missing for %s", path) } else { layout := "2006:01:02 15:04:05" t, err = time.Parse(layout, str) if err != nil { log.Fatal(err) } } newDir := fmt.Sprintf("%s/%4d/%02d/%02d", destPath, t.Year(), t.Month(), t.Day()) err = os.MkdirAll(newDir, 0777) if err != nil { log.Fatal(err) } newFile := fmt.Sprintf("%s/%s", newDir, f.Name()) if mode == "move" { log.Debugf("Moving %s %s", path, newFile) err = os.Rename(path, newFile) } else { if _, err := os.Stat(newFile); err == nil { log.Warnf("Photo %s already exists", newFile) } else { log.Debugf("Copying %s %s", path, newFile) err = copyFile(path, newFile) } } if err != nil { log.Fatal(err) } return nil }
func doWithRetry(reqS requestSupplier, retries int) (*http.Response, error) { req, err := reqS() if err != nil { return nil, err } resp, err := http.DefaultClient.Do(req) if err == nil && resp.StatusCode == 429 { if retries < maxRetries { // too many requests, retry if we can after a timeout // the timeout is in the Retry-After and it is in number of seconds timeout, err := strconv.Atoi(resp.Header.Get("Retry-After")) if err != nil { return nil, err } resp.Body.Close() if timeout > 60 { log.Warnf("Long timeout of %d seconds for url %s. Giving up.", timeout, req.URL.String()) return resp, err } time.Sleep(time.Duration(timeout) * time.Second) return doWithRetry(reqS, retries+1) } else { log.Warnf("Too many retries. Giving up %s", req.URL.String()) return resp, err } } return resp, err }
// IsAciConfigured returns true if aci is configured on netmaster. func IsAciConfigured() (res bool, err error) { // Get the state driver stateDriver, uErr := utils.GetStateDriver() if uErr != nil { log.Warnf("Couldn't read global config %v", uErr) return false, uErr } // read global config masterGc := &mastercfg.GlobConfig{} masterGc.StateDriver = stateDriver uErr = masterGc.Read("config") if core.ErrIfKeyExists(uErr) != nil { log.Errorf("Couldn't read global config %v", uErr) return false, uErr } if uErr != nil { log.Warnf("Couldn't read global config %v", uErr) return false, nil } if masterGc.NwInfraType != "aci" { log.Debugf("NwInfra type is %v, no ACI", masterGc.NwInfraType) return false, nil } return true, nil }
func (a *volumeDriverAdapter) getCapabilities() volume.Capability { if a.capabilities != nil { return *a.capabilities } cap, err := a.proxy.Capabilities() if err != nil { // `GetCapabilities` is a not a required endpoint. // On error assume it's a local-only driver logrus.Warnf("Volume driver %s returned an error while trying to query its capabilities, using default capabilties: %v", a.name, err) return volume.Capability{Scope: volume.LocalScope} } // don't spam the warn log below just because the plugin didn't provide a scope if len(cap.Scope) == 0 { cap.Scope = volume.LocalScope } cap.Scope = strings.ToLower(cap.Scope) if cap.Scope != volume.LocalScope && cap.Scope != volume.GlobalScope { logrus.Warnf("Volume driver %q returned an invalid scope: %q", a.Name(), cap.Scope) cap.Scope = volume.LocalScope } a.capabilities = &cap return cap }
func parseQuery(queryStr string) (readFilters, error) { manager := GetQPManager() keys, parsers := manager.GetActiveParsers() for idx, parser := range parsers { if parser.CanParseString(queryStr) { log.Debugf("parser.CanParseString(%s) true for %s\n", queryStr, keys[idx]) rf, err := parser.ParseString(queryStr) if err != nil { log.Warnf("Parser.ParseString(%s) failed with:%s", queryStr, err.Error()) return rf, queryParseError{ StatusCode: http.StatusBadRequest, Message: err.Error(), } } return rf, nil } log.Debugf("parser.CanParseString(%s) false for %s\n", queryStr, keys[idx]) } log.Warnf("parseQuery - Failed to find parser for:%s. Tried %s\n", queryStr, keys) return newReadFilters(), queryParseError{ StatusCode: http.StatusBadRequest, Message: "No QueryFormats can parse input", } }
// waitProcessExitCode will wait for the given process to exit and return its error code. func (ctr *container) waitProcessExitCode(process *process) int { // Block indefinitely for the process to exit. err := process.hcsProcess.Wait() if err != nil { if herr, ok := err.(*hcsshim.ProcessError); ok && herr.Err != syscall.ERROR_BROKEN_PIPE { logrus.Warnf("Wait failed (container may have been killed): %s", err) } // Fall through here, do not return. This ensures we attempt to continue the // shutdown in HCS and tell the docker engine that the process/container // has exited to avoid a container being dropped on the floor. } exitCode, err := process.hcsProcess.ExitCode() if err != nil { if herr, ok := err.(*hcsshim.ProcessError); ok && herr.Err != syscall.ERROR_BROKEN_PIPE { logrus.Warnf("Unable to get exit code from container %s", ctr.containerID) } // Since we got an error retrieving the exit code, make sure that the code we return // doesn't incorrectly indicate success. exitCode = -1 // Fall through here, do not return. This ensures we attempt to continue the // shutdown in HCS and tell the docker engine that the process/container // has exited to avoid a container being dropped on the floor. } if err := process.hcsProcess.Close(); err != nil { logrus.Error(err) } return exitCode }
// Init registers a new instance of bridge driver func Init(dc driverapi.DriverCallback, config map[string]interface{}) error { if _, err := os.Stat("/proc/sys/net/bridge"); err != nil { if out, err := exec.Command("modprobe", "-va", "bridge", "br_netfilter").CombinedOutput(); err != nil { logrus.Warnf("Running modprobe bridge br_netfilter failed with message: %s, error: %v", out, err) } } if out, err := exec.Command("modprobe", "-va", "nf_nat").CombinedOutput(); err != nil { logrus.Warnf("Running modprobe nf_nat failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err) } if out, err := exec.Command("modprobe", "-va", "xt_conntrack").CombinedOutput(); err != nil { logrus.Warnf("Running modprobe xt_conntrack failed with message: `%s`, error: %v", strings.TrimSpace(string(out)), err) } if err := iptables.FirewalldInit(); err != nil { logrus.Debugf("Fail to initialize firewalld: %v, using raw iptables instead", err) } d := newDriver() if err := d.configure(config); err != nil { return err } c := driverapi.Capability{ DataScope: datastore.LocalScope, } return dc.RegisterDriver(networkType, d, c) }
func (sb *sandbox) Refresh(options ...SandboxOption) error { // Store connected endpoints epList := sb.getConnectedEndpoints() // Detach from all endpoints for _, ep := range epList { if err := ep.Leave(sb); err != nil { log.Warnf("Failed detaching sandbox %s from endpoint %s: %v\n", sb.ID(), ep.ID(), err) } } // Re-apply options sb.config = containerConfig{} sb.processOptions(options...) // Setup discovery files if err := sb.setupResolutionFiles(); err != nil { return err } // Re -connect to all endpoints for _, ep := range epList { if err := ep.Join(sb); err != nil { log.Warnf("Failed attach sandbox %s to endpoint %s: %v\n", sb.ID(), ep.ID(), err) } } return nil }
func runPs(cmd *Command, rawArgs []string) error { if psHelp { return cmd.PrintUsage() } if len(rawArgs) != 0 { return cmd.PrintShortUsage() } args := commands.PsArgs{ All: psA, Latest: psL, Quiet: psQ, NoTrunc: psNoTrunc, NLast: psN, Filters: make(map[string]string, 0), } if psFilters != "" { for _, filter := range strings.Split(psFilters, " ") { parts := strings.SplitN(filter, "=", 2) if len(parts) != 2 { logrus.Warnf("Invalid filter '%s', should be in the form 'key=value'", filter) continue } if _, ok := args.Filters[parts[0]]; ok { logrus.Warnf("Duplicated filter: %q", parts[0]) } else { args.Filters[parts[0]] = parts[1] } } } ctx := cmd.GetContext(rawArgs) return commands.RunPs(ctx, args) }
func (ep *endpoint) releaseAddress() { n := ep.getNetwork() if n.hasSpecialDriver() { return } log.Debugf("Releasing addresses for endpoint %s's interface on network %s", ep.Name(), n.Name()) ipam, _, err := n.getController().getIPAMDriver(n.ipamType) if err != nil { log.Warnf("Failed to retrieve ipam driver to release interface address on delete of endpoint %s (%s): %v", ep.Name(), ep.ID(), err) return } if ep.iface.addr != nil { if err := ipam.ReleaseAddress(ep.iface.v4PoolID, ep.iface.addr.IP); err != nil { log.Warnf("Failed to release ip address %s on delete of endpoint %s (%s): %v", ep.iface.addr.IP, ep.Name(), ep.ID(), err) } } if ep.iface.addrv6 != nil && ep.iface.addrv6.IP.IsGlobalUnicast() { if err := ipam.ReleaseAddress(ep.iface.v6PoolID, ep.iface.addrv6.IP); err != nil { log.Warnf("Failed to release ip address %s on delete of endpoint %s (%s): %v", ep.iface.addrv6.IP, ep.Name(), ep.ID(), err) } } }
// CreateService creates a new service in a managed swarm cluster. func (c *Cluster) CreateService(s types.ServiceSpec, encodedAuth string) (*apitypes.ServiceCreateResponse, error) { c.RLock() defer c.RUnlock() if !c.isActiveManager() { return nil, c.errNoManager() } ctx, cancel := c.getRequestContext() defer cancel() err := c.populateNetworkID(ctx, c.client, &s) if err != nil { return nil, err } serviceSpec, err := convert.ServiceSpecToGRPC(s) if err != nil { return nil, err } ctnr := serviceSpec.Task.GetContainer() if ctnr == nil { return nil, fmt.Errorf("service does not use container tasks") } if encodedAuth != "" { ctnr.PullOptions = &swarmapi.ContainerSpec_PullOptions{RegistryAuth: encodedAuth} } // retrieve auth config from encoded auth authConfig := &apitypes.AuthConfig{} if encodedAuth != "" { if err := json.NewDecoder(base64.NewDecoder(base64.URLEncoding, strings.NewReader(encodedAuth))).Decode(authConfig); err != nil { logrus.Warnf("invalid authconfig: %v", err) } } resp := &apitypes.ServiceCreateResponse{} // pin image by digest if os.Getenv("DOCKER_SERVICE_PREFER_OFFLINE_IMAGE") != "1" { digestImage, err := c.imageWithDigestString(ctx, ctnr.Image, authConfig) if err != nil { logrus.Warnf("unable to pin image %s to digest: %s", ctnr.Image, err.Error()) resp.Warnings = append(resp.Warnings, fmt.Sprintf("unable to pin image %s to digest: %s", ctnr.Image, err.Error())) } else { logrus.Debugf("pinning image %s by digest: %s", ctnr.Image, digestImage) ctnr.Image = digestImage } } r, err := c.client.CreateService(ctx, &swarmapi.CreateServiceRequest{Spec: &serviceSpec}) if err != nil { return nil, err } resp.ID = r.Service.ID return resp, nil }