def test_str(self):
r1 = remote.Remote('r1', ssh=Mock())
r2 = remote.Remote('r2', ssh=Mock())
c = cluster.Cluster(remotes=[
(r1, ['foo', 'bar']),
(r2, ['baz']),
], )
assert str(c) == "r1[foo,bar] r2[baz]"
def test_repr(self):
r1 = remote.Remote('r1', ssh=Mock())
r2 = remote.Remote('r2', ssh=Mock())
c = cluster.Cluster(remotes=[
(r1, ['foo', 'bar']),
(r2, ['baz']),
], )
assert repr(c) == \
"Cluster(remotes=[[Remote(name='r1'), ['foo', 'bar']], " \
"[Remote(name='r2'), ['baz']]])"
def test_repr(self):
fudge.clear_expectations()
r1 = remote.Remote('r1', ssh=fudge.Fake('SSH'))
r2 = remote.Remote('r2', ssh=fudge.Fake('SSH'))
c = cluster.Cluster(
remotes=[
(r1, ['foo', 'bar']),
(r2, ['baz']),
],
)
assert repr(c) == "Cluster(remotes=[[Remote(name='r1'), ['foo', 'bar']], [Remote(name='r2'), ['baz']]])" # noqa
def test_str(self):
fudge.clear_expectations()
r1 = remote.Remote('r1', ssh=fudge.Fake('SSH'))
r2 = remote.Remote('r2', ssh=fudge.Fake('SSH'))
c = cluster.Cluster(
remotes=[
(r1, ['foo', 'bar']),
(r2, ['baz']),
],
)
assert str(c) == "r1[foo,bar] r2[baz]"
def test_shortname_default(self):
r = remote.Remote(
name='*****@*****.**',
ssh=self.m_ssh,
)
assert r.shortname == 'xyzzy'
assert str(r) == '*****@*****.**'
def test_arch(self):
m_transport = MagicMock()
m_transport.getpeername.return_value = ('name', 22)
self.m_ssh.get_transport.return_value = m_transport
m_run = MagicMock()
args = [
'uname',
'-m',
]
stdout = StringIO('test_arch')
stdout.seek(0)
proc = RemoteProcess(
client=self.m_ssh,
args='fakey',
)
proc._stdout_buf = Mock()
proc._stdout_buf.channel = Mock()
proc._stdout_buf.channel.recv_exit_status.return_value = 0
proc._stdout_buf.channel.expects('recv_exit_status').returns(0)
proc.stdout = stdout
m_run.return_value = proc
r = remote.Remote(name='*****@*****.**', ssh=self.m_ssh)
r._runner = m_run
assert m_transport.getpeername.called_once_with()
assert proc._stdout_buf.channel.recv_exit_status.called_once_with()
assert m_run.called_once_with(
client=self.m_ssh,
args=args,
stdout=StringIO(),
name=r.shortname,
)
assert r.arch == 'test_arch'
def add_remotes(ctx, config):
"""
Create a ctx.cluster object populated with remotes mapped to roles
"""
ctx.cluster = cluster.Cluster()
# Allow jobs to run without using nodes, for self-testing
if 'roles' not in ctx.config and 'targets' not in ctx.config:
return
remotes = []
machs = []
for name in ctx.config['targets'].keys():
machs.append(name)
for t, key in ctx.config['targets'].items():
t = misc.canonicalize_hostname(t)
try:
if ctx.config['sshkeys'] == 'ignore':
key = None
except (AttributeError, KeyError):
pass
rem = remote.Remote(name=t, host_key=key, keep_alive=True)
remotes.append(rem)
if 'roles' in ctx.config:
for rem, roles in zip(remotes, ctx.config['roles']):
assert all(isinstance(role, str) for role in roles), \
"Roles in config must be strings: %r" % roles
ctx.cluster.add(rem, roles)
log.info('roles: %s - %s' % (rem, roles))
else:
for rem in remotes:
ctx.cluster.add(rem, rem.name)
def main():
if len(sys.argv) == 3:
user = sys.argv[1] + "@"
host = sys.argv[2]
elif len(sys.argv) == 2:
user = ""
host = sys.argv[1]
else:
sys.stderr.write("usage: radosgw_admin.py [user] host\n")
exit(1)
client0 = remote.Remote(user + host)
ctx = config
ctx.cluster=cluster.Cluster(remotes=[(client0,
[ 'ceph.client.rgw.%s' % (host), ]),])
ctx.rgw = argparse.Namespace()
endpoints = {}
endpoints['ceph.client.rgw.%s' % host] = (host, 80)
ctx.rgw.role_endpoints = endpoints
ctx.rgw.realm = None
ctx.rgw.regions = {'region0': { 'api name': 'api1',
'is master': True, 'master zone': 'r0z0',
'zones': ['r0z0', 'r0z1'] }}
ctx.rgw.config = {'ceph.client.rgw.%s' % host: {'system user': {'name': '%s-system-user' % host}}}
task(config, None)
exit()
def setup(self):
self.r1 = remote.Remote('r1', ssh=Mock())
self.c = cluster.Cluster(
remotes=[
(self.r1, ['foo', 'bar']),
],
)
def test_is_container(self):
m_transport = MagicMock()
m_transport.getpeername.return_value = ('name', 22)
self.m_ssh.get_transport.return_value = m_transport
m_run = MagicMock()
args = []
proc = RemoteProcess(
client=self.m_ssh,
args=args,
)
proc.returncode = 0
m_run.return_value = proc
rem = remote.Remote(name='*****@*****.**', ssh=self.m_ssh)
rem._runner = m_run
assert rem.is_container
proc.returncode = 1
rem2 = remote.Remote(name='*****@*****.**', ssh=self.m_ssh)
rem2._runner = m_run
assert not rem2.is_container
def test_17102(self, caplog):
# http://tracker.ceph.com/issues/17102
rem = remote.Remote(HOST)
interval = 3
rem.run(args="echo before; sleep %s; echo after" % interval)
for record in caplog.records():
if record.msg == 'before':
before_time = record.created
elif record.msg == 'after':
after_time = record.created
assert int(round(after_time - before_time)) == interval
def test_host_key(self):
m_key = MagicMock()
m_key.get_name.return_value = 'key_type'
m_key.get_base64.return_value = 'test ssh key'
m_transport = MagicMock()
m_transport.get_remote_server_key.return_value = m_key
self.m_ssh.get_transport.return_value = m_transport
r = remote.Remote(name='*****@*****.**', ssh=self.m_ssh)
assert r.host_key == 'key_type test ssh key'
self.m_ssh.get_transport.assert_called_once_with()
m_transport.get_remote_server_key.assert_called_once_with()
def test_sftp_get_size(self):
m_file_obj = MagicMock()
m_stat = Mock()
m_stat.st_size = 42
m_file_obj.stat.return_value = m_stat
m_open = MagicMock()
m_open.return_value = m_file_obj
m_open.return_value.__enter__.return_value = m_file_obj
with patch.object(remote.Remote, '_sftp_open_file', new=m_open):
rem = remote.Remote(name='*****@*****.**', ssh=self.m_ssh)
assert rem._sftp_get_size('/fake/file') == 42
def test_inventory_info(self):
r = remote.Remote('user@host', host_key='host_key')
r._arch = 'arch'
r._os = opsys.OS(name='os_name', version='1.2.3', codename='code')
inv_info = r.inventory_info
assert inv_info == dict(
name='host',
user='******',
arch='arch',
os_type='os_name',
os_version='1.2',
ssh_pub_key='host_key',
up=True,
)
def test_run(self):
m_transport = MagicMock()
m_transport.getpeername.return_value = ('name', 22)
self.m_ssh.get_transport.return_value = m_transport
m_run = MagicMock()
args = [
'something',
'more',
]
proc = RemoteProcess(
client=self.m_ssh,
args=args,
)
m_run.return_value = proc
rem = remote.Remote(name='*****@*****.**', ssh=self.m_ssh)
rem._runner = m_run
result = rem.run(args=args)
assert m_transport.getpeername.called_once_with()
assert m_run.called_once_with(args=args)
assert result is proc
assert result.remote is rem
def test_hostname(self):
m_transport = MagicMock()
m_transport.getpeername.return_value = ('name', 22)
self.m_ssh.get_transport.return_value = m_transport
m_run = MagicMock()
args = [
'hostname',
'--fqdn',
]
stdout = StringIO('test_hostname')
stdout.seek(0)
proc = RemoteProcess(
client=self.m_ssh,
args=args,
)
proc.stdout = stdout
proc._stdout_buf = Mock()
proc._stdout_buf.channel.recv_exit_status.return_value = 0
r = remote.Remote(name='xyzzy.example.com', ssh=self.m_ssh)
m_run.return_value = proc
r._runner = m_run
assert r.hostname == 'test_hostname'
def test_os(self):
rem = remote.Remote(HOST)
assert rem.os.name
assert rem.os.version
