本文整理匯總了Golang中github.com/cloudfoundry-incubator/garden/client.New函數的典型用法代碼示例。如果您正苦於以下問題:Golang New函數的具體用法?Golang New怎麽用?Golang New使用的例子?那麽, 這裏精選的函數代碼示例或許可以為您提供幫助。
在下文中一共展示了New函數的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Golang代碼示例。
示例1: main
func main() {
flag.Parse()
gclient := client.New(connection.New("tcp", "localhost:7777"))
var container garden.Container
containers, err := gclient.Containers(garden.Properties{})
must(err)
for _, c := range containers {
if c.Handle() == *containerHandle {
container = c
break
}
}
if container == nil {
panic("Container not found!")
}
process, err := container.Attach(uint32(*processId), garden.ProcessIO{})
must(err)
switch *signalType {
case "term":
fmt.Println("Signalling term")
must(process.Signal(garden.SignalTerminate))
break
case "kill":
fmt.Println("Signalling kill")
must(process.Signal(garden.SignalKill))
break
}
}
示例2: Workers
func (provider *dbProvider) Workers() ([]Worker, error) {
workerInfos, err := provider.db.Workers()
if err != nil {
return nil, err
}
tikTok := clock.NewClock()
workers := make([]Worker, len(workerInfos))
for i, info := range workerInfos {
workerLog := provider.logger.Session("worker-connection", lager.Data{
"addr": info.Addr,
})
gardenConn := RetryableConnection{
Logger: workerLog,
Connection: gconn.NewWithLogger("tcp", info.Addr, workerLog.Session("garden-connection")),
Sleeper: tikTok,
RetryPolicy: ExponentialRetryPolicy{
Timeout: 5 * time.Minute,
},
}
workers[i] = NewGardenWorker(
gclient.New(gardenConn),
tikTok,
info.ActiveContainers,
info.ResourceTypes,
info.Platform,
info.Tags,
)
}
return workers, nil
}
示例3: start
func start(creator RunnerCreator, network, addr string, argv ...string) *RunningGarden {
tmpDir := filepath.Join(
os.TempDir(),
fmt.Sprintf("test-garden-%d", ginkgo.GinkgoParallelNode()),
)
if GraphRoot == "" {
GraphRoot = filepath.Join(tmpDir, "graph")
}
graphPath := filepath.Join(GraphRoot, fmt.Sprintf("node-%d", ginkgo.GinkgoParallelNode()))
r := &RunningGarden{
GraphRoot: GraphRoot,
GraphPath: graphPath,
tmpdir: tmpDir,
logger: lagertest.NewTestLogger("garden-runner"),
Client: client.New(connection.New(network, addr)),
}
c := cmd(tmpDir, graphPath, network, addr, GardenBin, BinPath, RootFSPath, argv...)
r.process = ifrit.Invoke(creator.Create(c))
r.Pid = c.Process.Pid
return r
}
示例4: ContainerCheck
func ContainerCheck(gardenAddr string, processes []ps.Process) error {
var errMsg string
stdout, _, err := RunCommand(`
$proc = Get-CimInstance Win32_Process -Filter "name = 'containerizer.exe'"
$result = Invoke-CimMethod -InputObject $proc -MethodName GetOwner
$result.User
`)
if err != nil {
return err
}
if strings.HasPrefix(stdout, "SYSTEM") {
errMsg = batchLogonMessage
} else {
errMsg = localLogonMessage
}
client := gclient.New(gconnection.New("tcp", gardenAddr))
container, err := client.Create(garden.ContainerSpec{})
if container != nil {
defer client.Destroy(container.Handle())
}
if err != nil {
if err.Error() == logonFailure {
return errors.New("Failed to create container\n" + errMsg)
} else {
return errors.New("Failed to create container\n" + err.Error())
}
}
return nil
}
示例5: NewGardenClient
func NewGardenClient() *FakeGardenClient {
connection := new(fakes.FakeConnection)
return &FakeGardenClient{
Connection: connection,
Client: client.New(connection),
}
}
示例6: start
func start(network, addr string, argv ...string) *RunningGarden {
tmpDir := filepath.Join(
os.TempDir(),
fmt.Sprintf("test-garden-%d", ginkgo.GinkgoParallelNode()),
)
Expect(os.MkdirAll(tmpDir, 0755)).To(Succeed())
if GraphRoot == "" {
GraphRoot = filepath.Join(tmpDir, "graph")
}
graphPath := filepath.Join(GraphRoot, fmt.Sprintf("node-%d", ginkgo.GinkgoParallelNode()))
stateDirPath := filepath.Join(tmpDir, "state")
depotPath := filepath.Join(tmpDir, "containers")
snapshotsPath := filepath.Join(tmpDir, "snapshots")
if err := os.MkdirAll(stateDirPath, 0755); err != nil {
Expect(err).ToNot(HaveOccurred())
}
if err := os.MkdirAll(depotPath, 0755); err != nil {
Expect(err).ToNot(HaveOccurred())
}
if err := os.MkdirAll(snapshotsPath, 0755); err != nil {
Expect(err).ToNot(HaveOccurred())
}
MustMountTmpfs(graphPath)
r := &RunningGarden{
GraphRoot: GraphRoot,
GraphPath: graphPath,
StateDirPath: stateDirPath,
DepotPath: depotPath,
SnapshotsPath: snapshotsPath,
tmpdir: tmpDir,
logger: lagertest.NewTestLogger("garden-runner"),
Client: client.New(connection.New(network, addr)),
}
c := cmd(stateDirPath, depotPath, snapshotsPath, graphPath, network, addr, GardenBin, BinPath, RootFSPath, argv...)
r.runner = ginkgomon.New(ginkgomon.Config{
Name: "garden-linux",
Command: c,
AnsiColorCode: "31m",
StartCheck: "garden-linux.started",
StartCheckTimeout: 30 * time.Second,
})
r.process = ifrit.Invoke(r.runner)
r.Pid = c.Process.Pid
return r
}
示例7: heartbeatWorker
func (server *registrarSSHServer) heartbeatWorker(logger lager.Logger, worker atc.Worker, channel ssh.Channel) ifrit.Process {
return ifrit.Background(tsa.NewHeartbeater(
logger,
server.heartbeatInterval,
gclient.New(gconn.New("tcp", worker.Addr)),
server.atcEndpoint,
worker,
channel,
))
}
示例8: New
func New() *FakeClient {
connection := fake_connection.New()
return &FakeClient{
Connection: connection,
Client: client.New(&FakeConnectionProvider{
Connection: connection,
}),
}
}
示例9: main
func main() {
gardenClient := client.New(connection.New("tcp", "127.0.0.1:7777"))
_ = gardenClient.Destroy("foo")
foo, err := gardenClient.Create(garden.ContainerSpec{Handle: "foo"})
failIf(err, "Create")
err = foo.NetOut(garden.NetOutRule{
Protocol: garden.ProtocolICMP,
Networks: []garden.IPRange{garden.IPRangeFromIP(net.ParseIP("8.8.8.8"))},
})
failIf(err, "NetOut")
restartGarden()
}
示例10: newGardenWorker
func (provider *dbProvider) newGardenWorker(tikTok clock.Clock, info db.WorkerInfo) Worker {
workerLog := provider.logger.Session("worker-connection", lager.Data{
"addr": info.GardenAddr,
})
gardenConn := NewRetryableConnection(
workerLog,
tikTok,
provider.retryPolicy,
NewGardenConnectionFactory(
provider.db,
provider.dialer,
provider.logger.Session("garden-connection"),
info.Name,
info.GardenAddr,
),
)
var bClient baggageclaim.Client
if info.BaggageclaimURL != "" {
bClient = bclient.New(info.BaggageclaimURL)
}
volumeFactory := NewVolumeFactory(
provider.logger.Session("volume-factory"),
provider.db,
tikTok,
)
return NewGardenWorker(
gclient.New(gardenConn),
bClient,
volumeFactory,
provider.db,
provider,
tikTok,
info.ActiveContainers,
info.ResourceTypes,
info.Platform,
info.Tags,
info.Name,
)
}
示例11: newGardenWorker
func (provider *dbProvider) newGardenWorker(tikTok clock.Clock, savedWorker db.SavedWorker) Worker {
workerLog := provider.logger.Session("worker-connection", lager.Data{
"addr": savedWorker.GardenAddr,
})
gardenConn := NewRetryableConnection(
workerLog,
tikTok,
provider.retryPolicy,
NewGardenConnectionFactory(
provider.db,
provider.dialer,
provider.logger.Session("garden-connection"),
savedWorker.Name,
savedWorker.GardenAddr,
),
)
var bClient baggageclaim.Client
if savedWorker.BaggageclaimURL != "" {
bClient = bclient.New(savedWorker.BaggageclaimURL)
}
volumeFactory := NewVolumeFactory(
provider.db,
tikTok,
)
return NewGardenWorker(
gclient.New(gardenConn),
bClient,
volumeFactory,
provider.imageFetcher,
provider.db,
provider,
tikTok,
savedWorker.ActiveContainers,
savedWorker.ResourceTypes,
savedWorker.Platform,
savedWorker.Tags,
savedWorker.Name,
)
}
示例12: main
func main() {
gardenClient := client.New(connection.New("tcp", "127.0.0.1:7777"))
_ = gardenClient.Destroy("foo")
container, err := gardenClient.Create(garden.ContainerSpec{
Handle: "foo",
Env: []string{"LANG=en_GB.iso885915"},
RootFSPath: "docker:///debian#8",
})
failIf(err, "Create")
var output bytes.Buffer
process, err := container.Run(garden.ProcessSpec{
Path: "sh",
Args: []string{"-c", "echo $LANG"},
}, garden.ProcessIO{Stdout: &output})
failIf(err, "Run")
process.Wait()
fmt.Println(output.String())
}
示例13: Start
func Start(bin, iodaemonBin, nstarBin string, argv ...string) *RunningGarden {
network := "unix"
addr := fmt.Sprintf("/tmp/garden_%d.sock", GinkgoParallelNode())
tmpDir := filepath.Join(
os.TempDir(),
fmt.Sprintf("test-garden-%d", ginkgo.GinkgoParallelNode()),
)
if GraphRoot == "" {
GraphRoot = filepath.Join(tmpDir, "graph")
}
graphPath := filepath.Join(GraphRoot, fmt.Sprintf("node-%d", ginkgo.GinkgoParallelNode()))
depotDir := filepath.Join(tmpDir, "containers")
MustMountTmpfs(graphPath)
r := &RunningGarden{
DepotDir: depotDir,
GraphRoot: GraphRoot,
GraphPath: graphPath,
tmpdir: tmpDir,
logger: lagertest.NewTestLogger("garden-runner"),
Client: client.New(connection.New(network, addr)),
}
c := cmd(tmpDir, depotDir, graphPath, network, addr, bin, iodaemonBin, nstarBin, TarPath, RootFSPath, argv...)
r.process = ifrit.Invoke(&ginkgomon.Runner{
Name: "guardian",
Command: c,
AnsiColorCode: "31m",
StartCheck: "guardian.started",
StartCheckTimeout: 30 * time.Second,
})
r.Pid = c.Process.Pid
return r
}
示例14:
fakeBackend.ContainersStub = func(garden.Properties) ([]garden.Container, error) {
return (<-stubs)()
}
})
JustBeforeEach(func() {
err := json.NewEncoder(sshStdin).Encode(workerPayload)
Ω(err).ShouldNot(HaveOccurred())
})
It("forwards garden API calls through the tunnel", func() {
registration := <-registered
addr := registration.worker.Addr
client := gclient.New(gconn.New("tcp", addr))
fakeBackend.CreateReturns(new(gfakes.FakeContainer), nil)
_, err := client.Create(garden.ContainerSpec{})
Ω(err).ShouldNot(HaveOccurred())
Ω(fakeBackend.CreateCallCount()).Should(Equal(1))
})
It("continuously registers it with the ATC as long as it works", func() {
a := time.Now()
registration := <-registered
Ω(registration.ttl).Should(Equal(2 * heartbeatInterval))
// shortcut for equality w/out checking addr
示例15: GardenContainers
func GardenContainers(gardenAddr string, gardenNetwork string, raw bool, out io.Writer) error {
client := client.New(connection.New(gardenNetwork, gardenAddr))
containers, err := client.Containers(nil)
if err != nil {
return err
}
workPool, err := workpool.NewWorkPool(32)
if err != nil {
return err
}
lock := &sync.Mutex{}
wg := &sync.WaitGroup{}
wg.Add(len(containers))
containerInfos := []ContainerInfo{}
for _, container := range containers {
container := container
workPool.Submit(func() {
defer wg.Done()
info, err := container.Info()
if err != nil {
say.Println(1, say.Red("Failed to fetch container info: %s\n", container.Handle()))
return
}
metrics, err := container.Metrics()
if err != nil {
say.Println(1, say.Red("Failed to fetch container metrics: %s\n", container.Handle()))
return
}
lock.Lock()
defer lock.Unlock()
containerInfos = append(containerInfos, ContainerInfo{
container.Handle(),
info,
metrics,
})
})
}
wg.Wait()
if raw {
encoded, err := json.MarshalIndent(containerInfos, "", " ")
if err != nil {
return err
}
out.Write(encoded)
return nil
}
if len(containerInfos) == 0 {
say.Println(0, say.Red("No Containers"))
}
for _, containerInfo := range containerInfos {
printContainer(out, containerInfo)
}
return nil
}