func splitTypeHostId(value string) (res ResourceType, host string, id containers.Identifier, err error) { if value == "" { err = errors.New("The identifier must be specified as <host>/<id> or <id>") return } locatorParts := strings.SplitN(value, "://", 2) if len(locatorParts) == 2 { res = ResourceType(locatorParts[0]) value = locatorParts[1] } sections := strings.SplitN(value, "/", 2) if len(sections) == 1 { id, err = containers.NewIdentifier(sections[0]) return } id, err = containers.NewIdentifier(sections[1]) if err != nil { return } if strings.TrimSpace(sections[0]) == "" { err = errors.New("You must specify <host>/<id> or <id>") return } host = sections[0] return }
func (s *IntegrationTestSuite) TestSamePortRejected(c *chk.C) { id, err := containers.NewIdentifier("TestSamePortRejected") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:39485") data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) active, _ := s.unitState(id) c.Assert(active, chk.Equals, "inactive") s.assertFilePresent(c, id.UnitPathFor(), 0664, true) paths, err := filepath.Glob(id.VersionedUnitPathFor("*")) c.Assert(err, chk.IsNil) for _, p := range paths { s.assertFilePresent(c, p, 0664, true) } id2, _ := containers.NewIdentifier("TestSamePortRejected2") cmd = exec.Command("/usr/bin/gear", "install", TestImage, fmt.Sprintf("%v/%v", s.daemonURI, id2), "--ports=8080:39485") data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.ErrorMatches, "exit status 1") state, substate := s.unitState(id2) c.Assert(state, chk.Equals, "inactive") c.Assert(substate, chk.Equals, "dead") }
func GetDockerContainerPacketCounts(d *docker.DockerClient) (map[containers.Identifier]int, error) { serviceFiles, err := filepath.Glob(filepath.Join(gearconfig.ContainerBasePath(), "units", "**", containers.IdentifierPrefix+"*.service")) if err != nil { return nil, err } ids := make([]string, 0) packetCount := make(map[containers.Identifier]int) for _, s := range serviceFiles { id := filepath.Base(s) if strings.HasPrefix(id, containers.IdentifierPrefix) && strings.HasSuffix(id, ".service") { id = id[len(containers.IdentifierPrefix):(len(id) - len(".service"))] if id, err := containers.NewIdentifier(id); err == nil { ids = append(ids, string(id)) packetCount[id] = 0 } } } containerIPs, err := d.GetContainerIPs(ids) if err != nil { return nil, err } cmd := exec.Command("/sbin/iptables-save", "-c") output, err := cmd.Output() if err != nil { return nil, err } scan := bufio.NewScanner(bytes.NewBuffer(output)) for scan.Scan() { line := scan.Text() if strings.Contains(line, "-A DOCKER ! -i docker0") && strings.Contains(line, "-j DNAT") { //Example: [0:0] -A DOCKER ! -i docker0 -p tcp -m tcp --dport 4000 -j DNAT --to-destination 172.17.0.3:8080 items := strings.Fields(line) packets, _ := strconv.Atoi(strings.Split(items[0], ":")[0][1:]) destIp := strings.Split(items[15], ":")[0] id, _ := containers.NewIdentifier(containerIPs[destIp]) packetCount[id] = packetCount[id] + packets } if strings.Contains(line, "-A OUTPUT -d 127.0.0.1/32 -p tcp -m tcp --dport") && strings.Contains(line, "-m comment --comment ") { //Example: [5850:394136] -A OUTPUT -d 127.0.0.1/32 -p tcp -m tcp --dport 4000 -m comment --comment 0001 -j ACCEPT items := strings.Fields(line) packets, _ := strconv.Atoi(strings.Split(items[0], ":")[0][1:]) if id, err := containers.NewIdentifier(items[14]); err == nil { packetCount[id] = packetCount[id] + packets } } } return packetCount, nil }
func (s *IntegrationTestSuite) TestInstallEnvFile(c *chk.C) { id, err := containers.NewIdentifier("TestInstallEnvFile") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) // get the full path to this .go file so we can get the correct path to the // simple.env file _, filename, _, _ := runtime.Caller(0) envFile := path.Join(path.Dir(filename), "..", "deployment", "fixtures", "simple.env") cmd := exec.Command("/usr/bin/gear", "install", EnvImage, hostContainerId, "--env-file="+envFile, "--start") data, err := cmd.CombinedOutput() c.Log(cmd.Args) c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerStarts(c, id) cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "TEST=value"), chk.Equals, true) c.Assert(strings.Contains(string(data), "QUOTED=\\\"foo\\\""), chk.Equals, true) c.Assert(strings.Contains(string(data), "IGNORED"), chk.Equals, false) }
func (p Port) IdentifierFor() (containers.Identifier, error) { _, portPath := p.PortPathsFor() r, err := os.Open(portPath) if err != nil { return "", err } defer r.Close() scan := bufio.NewScanner(r) for scan.Scan() { line := scan.Text() if strings.HasPrefix(line, "X-ContainerId=") { id, err := containers.NewIdentifier(strings.TrimPrefix(line, "X-ContainerId=")) if err != nil { return "", err } return id, nil } } if scan.Err() != nil { return "", scan.Err() } return "", fmt.Errorf("Container ID not found") }
func TestShouldSendRemoteJob(t *testing.T) { trans := &testTransport{} localhost := &testLocator{"localhost"} initCalled := false locator := &ResourceLocator{"ctr", "foobar", localhost} Executor{ On: Locators{locator}, Serial: func(on Locator) JobRequest { if on != locator { t.Fatalf("Expected locator passed to Serial() to be identical to %+v", locator) } id, _ := containers.NewIdentifier(on.(*ResourceLocator).Id) return &cjobs.StoppedContainerStateRequest{ Id: id, } }, Transport: trans, }.Gather() if initCalled { t.Errorf("Local initialization should be bypassed for remote transports") } if _, ok := trans.Translated["localhost"]; !ok { t.Errorf("Job for localhost was not enqueued in %+v", trans.Invoked) } if _, ok := trans.Invoked["localhost"]; !ok { t.Errorf("Job for localhost was not enqueued in %+v", trans.Invoked) } }
func HandleDeleteContainerRequest(conf *http.HttpConfiguration, context *http.HttpContext, r *rest.Request) (interface{}, error) { id, errg := containers.NewIdentifier(r.PathParam("id")) if errg != nil { return nil, errg } return &cjobs.DeleteContainerRequest{Id: id}, nil }
func (s *IntegrationTestSuite) TestInstallEnv(c *chk.C) { id, err := containers.NewIdentifier("TestInstallEnv") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) hostEnvId := fmt.Sprintf("%v/%v", s.daemonURI, "foobar") cmd := exec.Command("/usr/bin/gear", "install", EnvImage, hostContainerId, "--env-id=foobar", "A=B", "C=D", "--start") data, err := cmd.CombinedOutput() c.Log(cmd.Args) c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerStarts(c, id) cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "A=B"), chk.Equals, true) c.Assert(strings.Contains(string(data), "C=D"), chk.Equals, true) cmd = exec.Command("/usr/bin/gear", "env", hostEnvId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(string(data), chk.Equals, "A=B\nC=D\n") }
func (s *IntegrationTestSuite) TestStartStopContainer(c *chk.C) { id, err := containers.NewIdentifier("IntTest003") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:4001", "--isolate") data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) cmd = exec.Command("/usr/bin/gear", "start", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerState(c, id, CONTAINER_STARTED) s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false) ports, err := containers.GetExistingPorts(id) c.Assert(err, chk.IsNil) c.Assert(len(ports), chk.Equals, 1) resp, err := http.Get(fmt.Sprintf("http://0.0.0.0:%v", ports[0].External)) c.Assert(err, chk.IsNil) c.Assert(resp.StatusCode, chk.Equals, 200) cmd = exec.Command("/usr/bin/gear", "stop", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerState(c, id, CONTAINER_STOPPED) }
func (s *IntegrationTestSuite) TestSimpleInstallWithEnv(c *chk.C) { if !*hasEnvFile { c.Skip("-env-file not specified") } id, err := containers.NewIdentifier("IntTest008") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", EnvImage, hostContainerId, "--env-file=deployment/fixtures/simple.env", "--start") data, err := cmd.CombinedOutput() c.Log(cmd.Args) c.Log(string(data)) c.Assert(err, chk.IsNil) time.Sleep(time.Second * 5) // startup time is indeterminate unfortunately because gear init --post continues to run cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "TEST=\"value\""), chk.Equals, true) c.Assert(strings.Contains(string(data), "QUOTED=\"foo\""), chk.Equals, true) }
func (r repositoryPermission) CreatePermission(locator ssh.KeyLocator, value *utils.RawMessage) error { p := RepositoryPermission{} if value != nil { if err := json.Unmarshal(*value, &p); err != nil { return err } } id, err := containers.NewIdentifier(p.Id) if err != nil { return err } repoId := RepoIdentifier(id) if _, err := os.Stat(repoId.RepositoryPathFor()); err != nil { return err } accessPath := repoId.GitAccessPathFor(locator.NameForKey(), p.Write) if err := os.Symlink(locator.PathToKey(), accessPath); err != nil && !os.IsExist(err) { return err } negAccessPath := repoId.GitAccessPathFor(locator.NameForKey(), !p.Write) if err := os.Remove(negAccessPath); err != nil && !os.IsNotExist(err) { return err } if _, err := os.Stat(repoId.AuthKeysPathFor()); err == nil { if err := os.Remove(repoId.AuthKeysPathFor()); err != nil && !os.IsNotExist(err) { return err } } return nil }
func (s *IntegrationTestSuite) TestLongContainerName(c *chk.C) { id, err := containers.NewIdentifier("IntTest006xxxxxxxxxxxxxx") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--start", "--ports=8080:4003", "--isolate") data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerState(c, id, CONTAINER_STARTED) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false) ports, err := containers.GetExistingPorts(id) c.Assert(err, chk.IsNil) c.Assert(len(ports), chk.Equals, 1) t := time.NewTicker(time.Second / 10) defer t.Stop() select { case <-t.C: resp, err := http.Get(fmt.Sprintf("http://0.0.0.0:%v", ports[0].External)) if err == nil { c.Assert(resp.StatusCode, chk.Equals, 200) } case <-time.After(time.Second * 15): c.Fail() } }
func (s *IntegrationTestSuite) TestSimpleInstallAndStartImage(c *chk.C) { id, err := containers.NewIdentifier("IntTest000") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId) data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerState(c, id, CONTAINER_STOPPED) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) paths, err := filepath.Glob(id.VersionedUnitPathFor("*")) c.Assert(err, chk.IsNil) for _, p := range paths { s.assertFilePresent(c, p, 0664, true) } s.assertFileAbsent(c, filepath.Join(id.HomePath(), "container-init.sh")) ports, err := containers.GetExistingPorts(id) c.Assert(err, chk.IsNil) c.Assert(len(ports), chk.Equals, 0) cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "Loaded: loaded (/var/lib/containers/units/In/ctr-IntTest000.service; enabled)"), chk.Equals, true) s.assertContainerState(c, id, CONTAINER_STOPPED) }
func (s *IntegrationTestSuite) TestContainerNetLinks(c *chk.C) { id, err := containers.NewIdentifier("IntTest007") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:4004", "--isolate") data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) cmd = exec.Command("/usr/bin/gear", "link", "-n", "127.0.0.1:8081:74.125.239.114:80", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) cmd = exec.Command("/usr/bin/gear", "start", hostContainerId) data, err = cmd.CombinedOutput() s.assertContainerState(c, id, CONTAINER_STARTED) s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false) cmd = exec.Command("/usr/bin/switchns", "--container="+id.ContainerFor(), "--", "/sbin/iptables", "-t", "nat", "-L") data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(strings.Contains(string(data), "tcp dpt:tproxy to:74.125.239.114"), chk.Equals, true) cmd = exec.Command("/usr/bin/gear", "stop", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerState(c, id, CONTAINER_STOPPED) }
func (c containerPermission) CreatePermission(locator KeyLocator, value *utils.RawMessage) error { var idString string if value != nil { if err := json.Unmarshal(*value, &idString); err != nil { return err } } id, err := containers.NewIdentifier(idString) if err != nil { return err } if _, err := os.Stat(id.UnitPathFor()); err != nil { return err } if err := os.Symlink(locator.PathToKey(), SshAccessPathFor(id, locator.NameForKey())); err != nil && !os.IsExist(err) { return err } if _, err := os.Stat(id.AuthKeysPathFor()); err == nil { if err := os.Remove(id.AuthKeysPathFor()); err != nil { return err } } return nil }
func (d *Deployment) createInstances(c *Container) error { for i := len(c.instances); i < c.Count; i++ { var id containers.Identifier var err error if d.RandomizeIds { id, err = containers.NewRandomIdentifier(d.IdPrefix) } else { id, err = containers.NewIdentifier(d.IdPrefix + c.Name + "-" + strconv.Itoa(i+1)) } if err != nil { return err } instance := &Instance{ Id: id, From: c.Name, Image: c.Image, Ports: newPortMappings(c.PublicPorts), container: c, add: true, } c.AddInstance(instance) } return nil }
func (s *IntegrationTestSuite) TestLongContainerName(c *chk.C) { id, err := containers.NewIdentifier("IntTest006xxxxxxxxxxxxxx") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--start", "--ports=8080:0", "--isolate") data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerStarts(c, id) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) s.assertFilePresent(c, filepath.Join(id.RunPathFor(), "container-init.sh"), 0700, false) ports, err := containers.GetExistingPorts(id) c.Assert(err, chk.IsNil) c.Assert(len(ports), chk.Equals, 1) httpAlive := func() bool { resp, err := http.Get(fmt.Sprintf("http://0.0.0.0:%v", ports[0].External)) if err == nil { c.Assert(resp.StatusCode, chk.Equals, 200) return true } return false } if !until(TimeoutContainerStateChange, IntervalHttpCheck, httpAlive) { c.Errorf("Unable to retrieve a 200 status code from port %d", ports[0].External) c.FailNow() } }
func (s *IntegrationTestSuite) TestRestartContainer(c *chk.C) { id, err := containers.NewIdentifier("IntTest004") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId, "--ports=8080:4002", "--start", "--isolate") data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) s.assertContainerState(c, id, CONTAINER_STARTED) s.assertFilePresent(c, filepath.Join(id.HomePath(), "container-init.sh"), 0700, false) oldPid := s.getContainerPid(id) cmd = exec.Command("/usr/bin/gear", "restart", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerState(c, id, CONTAINER_RESTARTED) newPid := s.getContainerPid(id) c.Assert(oldPid, chk.Not(chk.Equals), newPid) }
func (s *IntegrationTestSuite) TestSimpleInstallWithEnv(c *chk.C) { if !*hasEnvFile { c.Skip("-env-file not specified") } id, err := containers.NewIdentifier("IntTest008") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", EnvImage, hostContainerId, "--env-file=deployment/fixtures/simple.env", "--start") data, err := cmd.CombinedOutput() c.Log(cmd.Args) c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerStarts(c, id) cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "TEST=\"value\""), chk.Equals, true) c.Assert(strings.Contains(string(data), "QUOTED=\"\\\"foo\\\"\""), chk.Equals, true) c.Assert(strings.Contains(string(data), "IGNORED"), chk.Equals, false) cmd = exec.Command("/usr/bin/gear", "stop", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertContainerStops(c, id, true) }
func (h *HttpRestartContainerRequest) Handler(conf *http.HttpConfiguration) http.JobHandler { return func(context *jobs.JobContext, r *rest.Request) (interface{}, error) { id, errg := containers.NewIdentifier(r.PathParam("id")) if errg != nil { return nil, errg } return &cjobs.RestartContainerRequest{id}, nil } }
func (h *HttpDeleteContainerRequest) Handler(conf *HttpConfiguration) JobHandler { return func(context *jobs.JobContext, r *rest.Request) (jobs.Job, error) { id, errg := containers.NewIdentifier(r.PathParam("id")) if errg != nil { return nil, errg } return &jobs.DeleteContainerRequest{id}, nil } }
func NewIdentifierFromUser(u *user.User) (RepoIdentifier, error) { if !strings.HasPrefix(u.Username, RepoIdentifierPrefix) || u.Name != "Repository user" { return "", errors.New("Not a repository user") } id := strings.TrimLeft(u.Username, RepoIdentifierPrefix) containerId, err := containers.NewIdentifier(id) if err != nil { return "", err } return RepoIdentifier(containerId), nil }
func HandleCreateRepositoryRequest(conf *http.HttpConfiguration, context *http.HttpContext, r *rest.Request) (interface{}, error) { repositoryId, errg := containers.NewIdentifier(r.PathParam("id")) if errg != nil { return nil, errg } // TODO: convert token into a safe clone spec and commit hash return &gitjobs.CreateRepositoryRequest{ git.RepoIdentifier(repositoryId), r.URL.Query().Get("source"), context.Id, }, nil }
func HandlePatchEnvironmentRequest(conf *http.HttpConfiguration, context *http.HttpContext, r *rest.Request) (interface{}, error) { id, errg := containers.NewIdentifier(r.PathParam("id")) if errg != nil { return nil, errg } data := containers.EnvironmentDescription{} if err := decodeAndCheck(r, &data); err != nil { return nil, err } data.Id = id return &cjobs.PatchEnvironmentRequest{data}, nil }
func HandleStopContainerRequest(conf *http.HttpConfiguration, context *http.HttpContext, r *rest.Request) (interface{}, error) { id, errg := containers.NewIdentifier(r.PathParam("id")) if errg != nil { return nil, errg } data := &cjobs.StoppedContainerStateRequest{} if err := decodeAndCheck(r, data); err != nil { return nil, err } data.Id = id return data, nil }
func NewContainerLocators(t transport.Transport, values ...string) (Locators, error) { locators, err := NewResourceLocators(t, ResourceTypeContainer, values...) if err != nil { return Locators{}, err } for i := range locators { _, err := containers.NewIdentifier(locators[i].(*ResourceLocator).Id) if err != nil { return Locators{}, err } } return locators, nil }
func GetIdlerRules(lookupId containers.Identifier, active bool) (map[string]bool, error) { cmd := exec.Command("/sbin/iptables-save", "-c") output, err := cmd.Output() if err != nil { return nil, err } scan := bufio.NewScanner(bytes.NewBuffer(output)) ports := make(map[string]bool) for scan.Scan() { line := scan.Text() items := strings.Fields(line) var ( port string id string ) if config.UsePreroutingIdler { if !active && strings.Contains(line, "-A PREROUTING") && strings.Contains(line, "-j NFQUEUE --queue-num 0") { port = items[10] id = items[14] } else if active && strings.Contains(line, "-A OUTPUT") && strings.Contains(line, "-j ACCEPT") && strings.Contains(line, "-m comment --comment ") { port = items[10] id = items[14] } else { continue } } else { if active && strings.Contains(line, "-A INPUT") && strings.Contains(line, "-j NFQUEUE --queue-num 0") { port = items[10] id = items[14] } else { continue } } ruleId, err := containers.NewIdentifier(id) if err != nil { return nil, err } if ruleId != lookupId { continue } ports[port] = true } return ports, nil }
func (link *ContainerLink) Check() error { if link.Id == "" { return errors.New("Container identifier may not be empty") } if _, err := containers.NewIdentifier(string(link.Id)); err != nil { return err } for i := range link.NetworkLinks { if err := link.NetworkLinks[i].Check(); err != nil { return err } } return nil }
func HandleGitArchiveContentRequest(conf *http.HttpConfiguration, context *http.HttpContext, r *rest.Request) (interface{}, error) { repoId, errr := containers.NewIdentifier(r.PathParam("id")) if errr != nil { return nil, jobs.SimpleError{jobs.ResponseInvalidRequest, fmt.Sprintf("Invalid repository identifier: %s", errr.Error())} } ref, errc := gitjobs.NewGitCommitRef(r.PathParam("ref")) if errc != nil { return nil, jobs.SimpleError{jobs.ResponseInvalidRequest, fmt.Sprintf("Invalid commit ref: %s", errc.Error())} } return &gitjobs.GitArchiveContentRequest{ git.RepoIdentifier(repoId), ref, }, nil }
func (s *IntegrationTestSuite) TestStatus(c *chk.C) { id, err := containers.NewIdentifier("IntTest005") c.Assert(err, chk.IsNil) s.containerIds = append(s.containerIds, id) hostContainerId := fmt.Sprintf("%v/%v", s.daemonURI, id) cmd := exec.Command("/usr/bin/gear", "install", TestImage, hostContainerId) data, err := cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) s.assertFilePresent(c, id.UnitPathFor(), 0664, true) active, _ := s.unitState(id) if active == "failed" { c.Logf("Container %s has previous recorded 'failed' state, convert to 'inactive'", id) active = "inactive" } c.Assert(active, chk.Equals, "inactive") cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "Loaded: loaded (/var/lib/containers/units/In/ctr-IntTest005.service; enabled)"), chk.Equals, true) cmd = exec.Command("/usr/bin/gear", "start", hostContainerId) _, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) s.assertContainerStarts(c, id) cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Log(string(data)) c.Assert(err, chk.IsNil) c.Assert(strings.Contains(string(data), "Loaded: loaded (/var/lib/containers/units/In/ctr-IntTest005.service; enabled)"), chk.Equals, true) c.Assert(strings.Contains(string(data), "Active: active (running)"), chk.Equals, true) cmd = exec.Command("/usr/bin/gear", "stop", hostContainerId) _, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) s.assertContainerStops(c, id, true) cmd = exec.Command("/usr/bin/gear", "status", hostContainerId) data, err = cmd.CombinedOutput() c.Assert(err, chk.IsNil) c.Log(string(data)) c.Assert(strings.Contains(string(data), "Loaded: loaded (/var/lib/containers/units/In/ctr-IntTest005.service; enabled)"), chk.Equals, true) }