本文整理汇总了Golang中github.com/juju/names.NewMachineTag函数的典型用法代码示例。如果您正苦于以下问题:Golang NewMachineTag函数的具体用法?Golang NewMachineTag怎么用?Golang NewMachineTag使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NewMachineTag函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestNewMetricsAdderAPIRefusesNonAgent
func (s *metricsAdderSuite) TestNewMetricsAdderAPIRefusesNonAgent(c *gc.C) {
tests := []struct {
tag names.Tag
environManager bool
expectedError string
}{
// TODO(cmars): unit agent should get permission denied when callers are
// moved to machine agent.
{names.NewUnitTag("mysql/0"), false, ""},
{names.NewLocalUserTag("admin"), true, "permission denied"},
{names.NewMachineTag("0"), false, ""},
{names.NewMachineTag("0"), true, ""},
}
for i, test := range tests {
c.Logf("test %d", i)
anAuthoriser := s.authorizer
anAuthoriser.EnvironManager = test.environManager
anAuthoriser.Tag = test.tag
endPoint, err := metricsadder.NewMetricsAdderAPI(s.State, nil, anAuthoriser)
if test.expectedError == "" {
c.Assert(err, jc.ErrorIsNil)
c.Assert(endPoint, gc.NotNil)
} else {
c.Assert(err, gc.ErrorMatches, test.expectedError)
c.Assert(endPoint, gc.IsNil)
}
}
}
示例2: TestReportKeys
func (s *facadeSuite) TestReportKeys(c *gc.C) {
s.authorizer.Tag = names.NewMachineTag("1")
args := params.SSHHostKeySet{
EntityKeys: []params.SSHHostKeys{
{
Tag: names.NewMachineTag("0").String(),
PublicKeys: []string{"rsa0", "dsa0"},
}, {
Tag: names.NewMachineTag("1").String(),
PublicKeys: []string{"rsa1", "dsa1"},
},
},
}
result, err := s.facade.ReportKeys(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: apiservertesting.ErrUnauthorized},
{nil},
},
})
s.backend.stub.CheckCalls(c, []jujutesting.StubCall{{
"SetSSHHostKeys",
[]interface{}{
names.NewMachineTag("1"),
state.SSHHostKeys{"rsa1", "dsa1"},
},
}})
}
示例3: TestWatchEnvironVolumeAttachments
func (s *VolumeStateSuite) TestWatchEnvironVolumeAttachments(c *gc.C) {
service := s.setupMixedScopeStorageService(c, "block")
addUnit := func() {
u, err := service.AddUnit()
c.Assert(err, jc.ErrorIsNil)
err = s.State.AssignUnit(u, state.AssignCleanEmpty)
c.Assert(err, jc.ErrorIsNil)
}
addUnit()
w := s.State.WatchEnvironVolumeAttachments()
defer testing.AssertStop(c, w)
wc := testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChangeInSingleEvent("0:0") // initial
wc.AssertNoChange()
addUnit()
wc.AssertChangeInSingleEvent("1:3")
wc.AssertNoChange()
err := s.State.DetachVolume(names.NewMachineTag("0"), names.NewVolumeTag("0"))
c.Assert(err, jc.ErrorIsNil)
wc.AssertChangeInSingleEvent("0:0") // dying
wc.AssertNoChange()
err = s.State.RemoveVolumeAttachment(names.NewMachineTag("0"), names.NewVolumeTag("0"))
c.Assert(err, jc.ErrorIsNil)
wc.AssertChangeInSingleEvent("0:0") // removed
wc.AssertNoChange()
}
示例4: TestRemoveFilesystemsMachineAgent
func (s *provisionerSuite) TestRemoveFilesystemsMachineAgent(c *gc.C) {
s.setupFilesystems(c)
s.authorizer.EnvironManager = false
args := params.Entities{Entities: []params.Entity{
{"filesystem-0-0"}, {"filesystem-0-42"}, {"filesystem-42"},
{"filesystem-invalid"}, {"machine-0"},
}}
err := s.State.DetachFilesystem(names.NewMachineTag("0"), names.NewFilesystemTag("0/0"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.RemoveFilesystemAttachment(names.NewMachineTag("0"), names.NewFilesystemTag("0/0"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.DestroyFilesystem(names.NewFilesystemTag("0/0"))
c.Assert(err, jc.ErrorIsNil)
result, err := s.api.Remove(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: nil},
{Error: nil},
{Error: ¶ms.Error{Message: "permission denied", Code: "unauthorized access"}},
{Error: ¶ms.Error{Message: `"filesystem-invalid" is not a valid filesystem tag`}},
{Error: ¶ms.Error{Message: "permission denied", Code: "unauthorized access"}},
},
})
}
示例5: migratableMachines
func (c *upgradeMongoCommand) migratableMachines() (upgradeMongoParams, error) {
haClient, err := c.getHAClient()
if err != nil {
return upgradeMongoParams{}, err
}
defer haClient.Close()
results, err := haClient.MongoUpgradeMode(mongo.Mongo32wt)
if err != nil {
return upgradeMongoParams{}, errors.Annotate(err, "cannot enter mongo upgrade mode")
}
result := upgradeMongoParams{}
result.master = migratable{
ip: results.Master.PublicAddress,
machine: names.NewMachineTag(results.Master.Tag),
series: results.Master.Series,
}
result.machines = make([]migratable, len(results.Members))
for i, member := range results.Members {
result.machines[i] = migratable{
ip: member.PublicAddress,
machine: names.NewMachineTag(member.Tag),
series: member.Series,
}
}
result.rsMembers = make([]replicaset.Member, len(results.RsMembers))
for i, rsMember := range results.RsMembers {
result.rsMembers[i] = rsMember
}
return result, nil
}
示例6: TestTools
func (s *toolsSuite) TestTools(c *gc.C) {
getCanRead := func() (common.AuthFunc, error) {
return func(tag names.Tag) bool {
return tag == names.NewMachineTag("0") || tag == names.NewMachineTag("42")
}, nil
}
tg := common.NewToolsGetter(s.State, s.State, s.State, sprintfURLGetter("tools:%s"), getCanRead)
c.Assert(tg, gc.NotNil)
err := s.machine0.SetAgentVersion(current)
c.Assert(err, jc.ErrorIsNil)
args := params.Entities{
Entities: []params.Entity{
{Tag: "machine-0"},
{Tag: "machine-1"},
{Tag: "machine-42"},
}}
result, err := tg.Tools(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.Results, gc.HasLen, 3)
c.Assert(result.Results[0].Error, gc.IsNil)
c.Assert(result.Results[0].Tools, gc.NotNil)
c.Assert(result.Results[0].Tools.Version, gc.DeepEquals, current)
c.Assert(result.Results[0].Tools.URL, gc.Equals, "tools:"+current.String())
c.Assert(result.Results[0].DisableSSLHostnameVerification, jc.IsTrue)
c.Assert(result.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
c.Assert(result.Results[2].Error, gc.DeepEquals, apiservertesting.NotFoundError("machine 42"))
}
示例7: makeMachineConfig
// makeMachineConfig produces a valid cloudinit machine config.
func makeMachineConfig(c *gc.C) *cloudinit.MachineConfig {
machineID := "0"
return &cloudinit.MachineConfig{
MachineId: machineID,
MachineNonce: "gxshasqlnng",
DataDir: environs.DataDir,
LogDir: agent.DefaultLogDir,
Jobs: []params.MachineJob{params.JobManageEnviron, params.JobHostUnits},
CloudInitOutputLog: environs.CloudInitOutputLog,
Tools: &tools.Tools{URL: "file://" + c.MkDir()},
StateInfo: &state.Info{
Info: mongo.Info{
CACert: testing.CACert,
Addrs: []string{"127.0.0.1:123"},
},
Tag: names.NewMachineTag(machineID).String(),
Password: "password",
},
APIInfo: &api.Info{
CACert: testing.CACert,
Addrs: []string{"127.0.0.1:123"},
Tag: names.NewMachineTag(machineID).String(),
},
MachineAgentServiceName: "jujud-machine-0",
}
}
示例8: TestMachineNetworkConfigNameChange
func (s *networkerSuite) TestMachineNetworkConfigNameChange(c *gc.C) {
var called bool
networker.PatchFacadeCall(s, s.networker, func(request string, args, response interface{}) error {
if !called {
called = true
c.Assert(request, gc.Equals, "MachineNetworkConfig")
return ¶ms.Error{
Message: "MachineNetworkConfig",
Code: params.CodeNotImplemented,
}
}
c.Assert(request, gc.Equals, "MachineNetworkInfo")
expected := params.Entities{
Entities: []params.Entity{{Tag: names.NewMachineTag("42").String()}},
}
c.Assert(args, gc.DeepEquals, expected)
result := response.(*params.MachineNetworkConfigResults)
result.Results = make([]params.MachineNetworkConfigResult, 1)
result.Results[0].Error = common.ServerError(common.ErrPerm)
return nil
})
// Make a call, in this case result is "permission denied".
info, err := s.networker.MachineNetworkConfig(names.NewMachineTag("42"))
c.Assert(err, gc.ErrorMatches, "permission denied")
c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
c.Assert(info, gc.IsNil)
}
示例9: TestAttachFilesystemsMountReadOnly
func (s *tmpfsSuite) TestAttachFilesystemsMountReadOnly(c *gc.C) {
source := s.tmpfsFilesystemSource(c)
_, err := source.CreateFilesystems([]storage.FilesystemParams{{
Tag: names.NewFilesystemTag("1"),
Size: 1024,
}})
c.Assert(err, jc.ErrorIsNil)
cmd := s.commands.expect("df", "--output=source", "/var/lib/juju/storage/fs/foo")
cmd.respond("header\nvalue", nil)
s.commands.expect("mount", "-t", "tmpfs", "filesystem-1", "/var/lib/juju/storage/fs/foo", "-o", "size=1024m,ro")
results, err := source.AttachFilesystems([]storage.FilesystemAttachmentParams{{
Filesystem: names.NewFilesystemTag("1"),
Path: "/var/lib/juju/storage/fs/foo",
AttachmentParams: storage.AttachmentParams{
Machine: names.NewMachineTag("2"),
ReadOnly: true,
},
}})
c.Assert(err, jc.ErrorIsNil)
c.Assert(results, jc.DeepEquals, []storage.AttachFilesystemsResult{{
FilesystemAttachment: &storage.FilesystemAttachment{
Filesystem: names.NewFilesystemTag("1"),
Machine: names.NewMachineTag("2"),
FilesystemAttachmentInfo: storage.FilesystemAttachmentInfo{
Path: "/var/lib/juju/storage/fs/foo",
ReadOnly: true,
},
},
}})
}
示例10: TestWatchMachineVolumeAttachments
func (s *VolumeStateSuite) TestWatchMachineVolumeAttachments(c *gc.C) {
service := s.setupMixedScopeStorageService(c, "block")
addUnit := func() {
u, err := service.AddUnit()
c.Assert(err, jc.ErrorIsNil)
err = s.State.AssignUnit(u, state.AssignCleanEmpty)
c.Assert(err, jc.ErrorIsNil)
}
addUnit()
w := s.State.WatchMachineVolumeAttachments(names.NewMachineTag("0"))
defer testing.AssertStop(c, w)
wc := testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChangeInSingleEvent("0:0", "0:0/1", "0:0/2") // initial
wc.AssertNoChange()
addUnit()
// no change, since we're only interested in the one machine.
wc.AssertNoChange()
err := s.State.DetachVolume(names.NewMachineTag("0"), names.NewVolumeTag("0"))
c.Assert(err, jc.ErrorIsNil)
wc.AssertChangeInSingleEvent("0:0") // dying
wc.AssertNoChange()
err = s.State.RemoveVolumeAttachment(names.NewMachineTag("0"), names.NewVolumeTag("0"))
c.Assert(err, jc.ErrorIsNil)
wc.AssertChangeInSingleEvent("0:0") // removed
wc.AssertNoChange()
// TODO(axw) respond to changes to the same machine when we support
// dynamic storage and/or placement.
}
示例11: TestRemoveVolumesEnvironManager
func (s *provisionerSuite) TestRemoveVolumesEnvironManager(c *gc.C) {
s.setupVolumes(c)
args := params.Entities{Entities: []params.Entity{
{"volume-1-0"}, {"volume-1"}, {"volume-2"}, {"volume-42"},
{"volume-invalid"}, {"machine-0"},
}}
err := s.State.DetachVolume(names.NewMachineTag("0"), names.NewVolumeTag("1"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.RemoveVolumeAttachment(names.NewMachineTag("0"), names.NewVolumeTag("1"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.DestroyVolume(names.NewVolumeTag("1"))
c.Assert(err, jc.ErrorIsNil)
result, err := s.api.Remove(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{Error: ¶ms.Error{Message: "permission denied", Code: "unauthorized access"}},
{Error: nil},
{Error: ¶ms.Error{Message: "removing volume 2: volume is not dead"}},
{Error: nil},
{Error: ¶ms.Error{Message: `"volume-invalid" is not a valid volume tag`}},
{Error: ¶ms.Error{Message: "permission denied", Code: "unauthorized access"}},
},
})
}
示例12: TestAuthAndActionFromTagFn
func (s *actionsSuite) TestAuthAndActionFromTagFn(c *gc.C) {
notFoundActionTag := names.NewActionTag(utils.MustNewUUID().String())
authorizedActionTag := names.NewActionTag(utils.MustNewUUID().String())
authorizedMachineTag := names.NewMachineTag("1")
authorizedAction := fakeAction{name: "action1", receiver: authorizedMachineTag.Id()}
unauthorizedActionTag := names.NewActionTag(utils.MustNewUUID().String())
unauthorizedMachineTag := names.NewMachineTag("10")
unauthorizedAction := fakeAction{name: "action2", receiver: unauthorizedMachineTag.Id()}
invalidReceiverActionTag := names.NewActionTag(utils.MustNewUUID().String())
invalidReceiverAction := fakeAction{name: "action2", receiver: "masterexploder"}
canAccess := makeCanAccess(map[names.Tag]bool{
authorizedMachineTag: true,
})
getActionByTag := makeGetActionByTag(map[names.ActionTag]state.Action{
authorizedActionTag: authorizedAction,
unauthorizedActionTag: unauthorizedAction,
invalidReceiverActionTag: invalidReceiverAction,
})
tagFn := common.AuthAndActionFromTagFn(canAccess, getActionByTag)
for i, test := range []struct {
tag string
errString string
err error
expectedAction state.Action
}{{
tag: "invalid-action-tag",
errString: `"invalid-action-tag" is not a valid tag`,
}, {
tag: notFoundActionTag.String(),
errString: "action not found",
}, {
tag: invalidReceiverActionTag.String(),
errString: `invalid actionreceiver name "masterexploder"`,
}, {
tag: unauthorizedActionTag.String(),
err: common.ErrPerm,
}, {
tag: authorizedActionTag.String(),
expectedAction: authorizedAction,
}} {
c.Logf("test %d", i)
action, err := tagFn(test.tag)
if test.errString != "" {
c.Check(err, gc.ErrorMatches, test.errString)
c.Check(action, gc.IsNil)
} else if test.err != nil {
c.Check(err, gc.Equals, test.err)
c.Check(action, gc.IsNil)
} else {
c.Check(err, jc.ErrorIsNil)
c.Check(action, gc.Equals, action)
}
}
}
示例13: TestBadLogin
func (s *loginSuite) TestBadLogin(c *gc.C) {
// Start our own server so we can control when the first login
// happens. Otherwise in JujuConnSuite.SetUpTest api.Open is
// called with user-admin permissions automatically.
info, cleanup := s.setupServerWithValidator(c, nil)
defer cleanup()
adminUser := s.AdminUserTag(c)
for i, t := range []struct {
tag names.Tag
password string
err error
code string
}{{
tag: adminUser,
password: "wrong password",
err: &rpc.RequestError{
Message: "invalid entity name or password",
Code: "unauthorized access",
},
code: params.CodeUnauthorized,
}, {
tag: names.NewUserTag("unknown"),
password: "password",
err: &rpc.RequestError{
Message: "invalid entity name or password",
Code: "unauthorized access",
},
code: params.CodeUnauthorized,
}} {
c.Logf("test %d; entity %q; password %q", i, t.tag, t.password)
func() {
// Open the API without logging in, so we can perform
// operations on the connection before calling Login.
st := s.openAPIWithoutLogin(c, info)
defer st.Close()
_, err := apimachiner.NewState(st).Machine(names.NewMachineTag("0"))
c.Assert(errors.Cause(err), gc.DeepEquals, &rpc.RequestError{
Message: `unknown object type "Machiner"`,
Code: "not implemented",
})
// Since these are user login tests, the nonce is empty.
err = st.Login(t.tag, t.password, "", nil)
c.Assert(errors.Cause(err), gc.DeepEquals, t.err)
c.Assert(params.ErrCode(err), gc.Equals, t.code)
_, err = apimachiner.NewState(st).Machine(names.NewMachineTag("0"))
c.Assert(errors.Cause(err), gc.DeepEquals, &rpc.RequestError{
Message: `unknown object type "Machiner"`,
Code: "not implemented",
})
}()
}
}
示例14: TestDetachVolumes
func (s *cinderVolumeSourceSuite) TestDetachVolumes(c *gc.C) {
const mockServerId2 = mockServerId + "2"
var numListCalls, numDetachCalls int
mockAdapter := &mockAdapter{
listVolumeAttachments: func(serverId string) ([]nova.VolumeAttachment, error) {
numListCalls++
if serverId == mockServerId2 {
// no attachments
return nil, nil
}
c.Check(serverId, gc.Equals, mockServerId)
return []nova.VolumeAttachment{{
Id: mockVolId,
VolumeId: mockVolId,
ServerId: mockServerId,
Device: "/dev/sda",
}}, nil
},
detachVolume: func(serverId, volId string) error {
numDetachCalls++
c.Check(serverId, gc.Equals, mockServerId)
c.Check(volId, gc.Equals, mockVolId)
return nil
},
}
volSource := openstack.NewCinderVolumeSource(mockAdapter)
errs, err := volSource.DetachVolumes([]storage.VolumeAttachmentParams{{
Volume: names.NewVolumeTag("123"),
VolumeId: mockVolId,
AttachmentParams: storage.AttachmentParams{
Machine: names.NewMachineTag("0"),
InstanceId: mockServerId,
},
}, {
Volume: names.NewVolumeTag("42"),
VolumeId: "42",
AttachmentParams: storage.AttachmentParams{
Machine: names.NewMachineTag("0"),
InstanceId: mockServerId2,
},
}})
c.Assert(err, jc.ErrorIsNil)
c.Assert(errs, jc.DeepEquals, []error{nil, nil})
// DetachVolume should only be called for existing attachments.
mockAdapter.CheckCalls(c, []gitjujutesting.StubCall{{
"ListVolumeAttachments", []interface{}{mockServerId},
}, {
"DetachVolume", []interface{}{mockServerId, mockVolId},
}, {
"ListVolumeAttachments", []interface{}{mockServerId2},
}})
}
示例15: TestParseFilesystemAttachmentId
func (s *FilesystemStateSuite) TestParseFilesystemAttachmentId(c *gc.C) {
assertValid := func(id string, m names.MachineTag, v names.FilesystemTag) {
machineTag, filesystemTag, err := state.ParseFilesystemAttachmentId(id)
c.Assert(err, jc.ErrorIsNil)
c.Assert(machineTag, gc.Equals, m)
c.Assert(filesystemTag, gc.Equals, v)
}
assertValid("0:0", names.NewMachineTag("0"), names.NewFilesystemTag("0"))
assertValid("0:0/1", names.NewMachineTag("0"), names.NewFilesystemTag("0/1"))
assertValid("0/lxc/0:1", names.NewMachineTag("0/lxc/0"), names.NewFilesystemTag("1"))
}