def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
if 'fake' in ip:
return fakeprovider.FakeSSHClient()
# HPcloud may return ECONNREFUSED or EHOSTUNREACH
# for about 30 seconds after adding the IP
for count in iterate_timeout(timeout, exceptions.SSHTimeoutException,
"ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except paramiko.SSHException as e:
# NOTE(pabelanger): Currently paramiko only returns a string with
# error code. If we want finer granularity we'll need to regex the
# string.
log.exception('Failed to negotiate SSH: %s' % (e))
except paramiko.AuthenticationException as e:
# This covers the case where the cloud user is created
# after sshd is up (Fedora for example)
log.info('Auth exception for %s@%s. Try number %i...' %
(username, ip, count))
except socket.error as e:
if e[0] not in [errno.ECONNREFUSED, errno.EHOSTUNREACH, None]:
log.exception('Exception while testing ssh access to %s:' % ip)
out = client.ssh("test ssh access", "echo access okay", output=True)
if "access okay" in out:
return client
return None
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
if 'fake' in ip:
return fakeprovider.FakeSSHClient()
# HPcloud may return ECONNREFUSED or EHOSTUNREACH
# for about 30 seconds after adding the IP
for count in iterate_timeout(
timeout, exceptions.SSHTimeoutException, "ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except paramiko.SSHException as e:
# NOTE(pabelanger): Currently paramiko only returns a string with
# error code. If we want finer granularity we'll need to regex the
# string.
log.exception('Failed to negotiate SSH: %s' % (e))
except paramiko.AuthenticationException as e:
# This covers the case where the cloud user is created
# after sshd is up (Fedora for example)
log.info('Auth exception for %s@%s. Try number %i...' %
(username, ip, count))
except socket.error as e:
if e[0] not in [errno.ECONNREFUSED, errno.EHOSTUNREACH, None]:
log.exception(
'Exception while testing ssh access to %s:' % ip)
out = client.ssh("test ssh access", "echo access okay", output=True)
if "access okay" in out:
return client
return None
class IPV4FTPTimeoutTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SlowSSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults(
[d, client.onConnectionLost, server.onConnectionLost])
def test_lsdir_timeout_fail(self):
d = self.client.ls('/tmp', timeout=1)
return self.assertFailure(d, TimeoutError)
@defer.inlineCallbacks
def test_lsdir_timeout_pass(self):
try:
test_file = 'test_ls_dir'
sandbox = tempfile.mkdtemp()
testfile = '/'.join([sandbox, test_file])
touch(testfile)
d = yield self.client.ls(sandbox, timeout=60)
self.assertEquals(d[0][0], test_file)
defer.returnValue(d)
finally:
shutil.rmtree(sandbox)
class IPV4FunctionalNoServerTestCase(TestCase):
def setUp(self):
self.hostname = "127.0.0.1"
self.user = getpass.getuser()
self.password = "******"
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
"hostname": self.hostname,
"port": self.portnum + 1,
"user": self.user,
"password": self.password,
"buffersize": 32768,
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
# Wait for the deferred that tell us we disconnected.
return defer.gatherResults([d])
def test_run_command_connect_failure(self):
"test what happens if the server isnt running"
d = self.client.run("echo hi")
return self.assertFailure(d, ConnectError)
def test_ls_connect_failure(self):
"test what happens if the server isnt running"
sandbox = tempfile.mkdtemp()
d = self.client.ls(sandbox)
def sandbox_cleanup(data):
shutil.rmtree(sandbox)
return data
d.addBoth(sandbox_cleanup)
return self.assertFailure(d, ConnectError)
class IPV4FTPTimeoutTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SlowSSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults([d,
client.onConnectionLost,
server.onConnectionLost])
def test_lsdir_timeout_fail(self):
d = self.client.ls('/tmp', timeout=1)
return self.assertFailure(d, TimeoutError)
@defer.inlineCallbacks
def test_lsdir_timeout_pass(self):
try:
test_file = 'test_ls_dir'
sandbox = tempfile.mkdtemp()
testfile = '/'.join([sandbox, test_file])
touch(testfile)
d = yield self.client.ls(sandbox, timeout=60)
self.assertEquals(d[0][0], test_file)
defer.returnValue(d)
finally:
shutil.rmtree(sandbox)
class IPV4FunctionalNoServerTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum + 1,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
# Wait for the deferred that tell us we disconnected.
return defer.gatherResults([d])
def test_run_command_connect_failure(self):
'test what happens if the server isnt running'
d = self.client.run('echo hi')
return self.assertFailure(d, ConnectError)
def test_ls_connect_failure(self):
'test what happens if the server isnt running'
sandbox = tempfile.mkdtemp()
d = self.client.ls(sandbox)
def sandbox_cleanup(data):
shutil.rmtree(sandbox)
return data
d.addBoth(sandbox_cleanup)
return self.assertFailure(d, ConnectError)
class IPV6FunctionalBaseTestCase(TestCase):
def setUp(self):
self.hostname = '::1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults(
[d, client.onConnectionLost, server.onConnectionLost])
def test_run_command(self):
d = self.client.run('echo hi')
def got_hi(data):
log.debug('Got Data %s' % (data, ))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addCallback(got_hi)
#d = defer.Deferred()
#d.callback('done')
return d
class IPV6FunctionalBaseTestCase(TestCase):
def setUp(self):
self.hostname = '::1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults([d,
client.onConnectionLost,
server.onConnectionLost])
def test_run_command(self):
d = self.client.run('echo hi')
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addCallback(got_hi)
#d = defer.Deferred()
#d.callback('done')
return d
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
# HPcloud may return errno 111 for about 30 seconds after adding the IP
for count in iterate_timeout(timeout, "ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except socket.error as e:
print "While testing ssh access:", e
time.sleep(5)
ret, out = client.ssh("echo access okay")
if "access okay" in out:
return client
return None
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
# HPcloud may return errno 111 for about 30 seconds after adding the IP
for count in iterate_timeout(timeout, "ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except socket.error as e:
print "While testing ssh access:", e
time.sleep(5)
ret, out = client.ssh("echo access okay")
if "access okay" in out:
return client
return None
def test_password_identity_no_passphrase_success(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': '******',
'identities': [self.sandbox + '/id_rsa2'],
'buffersize': 32768}
id_rsa_pub = testUsers['testUser2']['pub']
id_rsa_priv = testUsers['testUser2']['priv']
open(self.sandbox+'/id_rsa2.pub', 'w').write(id_rsa_pub)
open(self.sandbox+'/id_rsa2', 'w').write(id_rsa_priv)
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addBoth(client_disconnect)
d.addCallback(got_hi)
return d
def test_password_identity_failure(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': '******', # sshkey phrase
'identities': [self.sandbox + '/id_rsa'],
'buffersize': 32768}
id_rsa_pub = testUsers['testUser']['pub']
id_rsa_priv = testUsers['testUser']['priv']
open(self.sandbox+'/id_rsa.pub', 'w').write(id_rsa_pub)
open(self.sandbox+'/id_rsa', 'w').write(id_rsa_priv)
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
d.addBoth(client_disconnect)
return self.assertFailure(d, UnauthorizedLogin)
def test_password_auth_success(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': self.sshServerPassword,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addBoth(client_disconnect)
d.addCallback(got_hi)
return d
def openConsole(ip, username, password):
clientIp = cgi.escape(os.environ["REMOTE_ADDR"])
bodyContent = ""
bodyContent += 'Your machine IP is %s <br>' % (str(clientIp))
try:
cl = SSHClient(clientIp)
cl.enableSSH(ip, username)
return {'status': 'success', 'data': 'SSH Successfull'}
except Exception as e:
return {
'status':
'error',
'data':
'Could not connect to remote machine. Make sure the plugin is running in your machine, Cause : %s'
% str(e)
}
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
# HPcloud may return errno 111 for about 30 seconds after adding the IP
for count in iterate_timeout(timeout, "ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except socket.error, e:
print "While testing ssh access:", e
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
for count in iterate_timeout(timeout, "ssh access"):
try:
log.debug('Connecting to ssh to %s with user %s' % (ip, username))
client = SSHClient(ip, username, log=log, **connect_kwargs)
break
except paramiko.AuthenticationException as e:
# This covers the case where the cloud user is created
# after sshd is up (Fedora for example)
log.info('Password auth exception. Try number %i...' % count)
log.debug(str(e))
except socket.error as e:
if e[0] not in [errno.ECONNREFUSED, errno.EHOSTUNREACH]:
log.exception('Exception while testing ssh access:')
out = client.ssh("test ssh access", "echo access okay", output=True)
if "access okay" in out:
return client
return None
class IPV4CommandTimeoutTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults(
[d, client.onConnectionLost, server.onConnectionLost])
def test_run_command_timeout_failed(self):
d = self.client.run('sleep 2 && ls', timeout=1)
return self.assertFailure(d, TimeoutError)
class IPV4CommandTimeoutTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults([d,
client.onConnectionLost,
server.onConnectionLost])
def test_run_command_timeout_failed(self):
d = self.client.run('sleep 2 && ls', timeout=1)
return self.assertFailure(d, TimeoutError)
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
if 'fake' in ip:
return fakeprovider.FakeSSHClient()
# HPcloud may return ECONNREFUSED or EHOSTUNREACH
# for about 30 seconds after adding the IP
for count in iterate_timeout(timeout, "ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except paramiko.AuthenticationException as e:
# This covers the case where the cloud user is created
# after sshd is up (Fedora for example)
log.info('Password auth exception. Try number %i...' % count)
except socket.error as e:
if e[0] not in [errno.ECONNREFUSED, errno.EHOSTUNREACH, None]:
log.exception('Exception while testing ssh access:')
out = client.ssh("test ssh access", "echo access okay", output=True)
if "access okay" in out:
return client
return None
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def ssh_connect(ip, username, connect_kwargs={}, timeout=60):
if ip == 'fake':
return fakeprovider.FakeSSHClient()
# HPcloud may return ECONNREFUSED or EHOSTUNREACH
# for about 30 seconds after adding the IP
for count in iterate_timeout(timeout, "ssh access"):
try:
client = SSHClient(ip, username, **connect_kwargs)
break
except paramiko.AuthenticationException as e:
# This covers the case where the cloud user is created
# after sshd is up (Fedora for example)
log.info('Password auth exception. Try number %i...' % count)
except socket.error as e:
if e[0] not in [errno.ECONNREFUSED, errno.EHOSTUNREACH]:
log.exception('Exception while testing ssh access:')
out = client.ssh("test ssh access", "echo access okay", output=True)
if "access okay" in out:
return client
return None
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def test_password_auth_failure(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': '******',
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
d.addBoth(client_disconnect)
return self.assertFailure(d, UnauthorizedLogin)
def setUp(self):
self.hostname = "127.0.0.1"
self.user = getpass.getuser()
self.password = "******"
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
"hostname": self.hostname,
"port": self.portnum,
"user": self.user,
"password": self.password,
"buffersize": 32768,
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def __init__(self,
mng_ip,
username='******',
password='******',
enable='enable',
password_enable='zxr10',
telnet_port=23,
ssh_port=22):
'''
设备初始化
'''
self.mng_ip = mng_ip
self.username = username
self.password = password
self.enable = enable
self.password_enable = password_enable
self.telnet = TelnetClient()
self.telnet_port = telnet_port
self.ssh = SSHClient()
self.ssh_port = ssh_port
self.dutType = None # 设备类型 9900 or 5960 or 其他
self.version = None # 版本信息
self.snmp_enable = False
class IPV4FunctionalAuthTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.sshServeruser = '******'
self.sshServerPassword = '******'
self.server = SSHServer(self.sshServeruser, self.sshServerPassword)
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
# create ssh auth sandbox for keys.
self.sandbox = tempfile.mkdtemp()
def tearDown(self):
# Shut down the server and client
port, self.port = self.port, None
#client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Remove the sandbox
shutil.rmtree(self.sandbox)
# Wait for the deferred that tell us we disconnected.
return defer.gatherResults([d])
def test_password_auth_success(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': self.sshServerPassword,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addBoth(client_disconnect)
d.addCallback(got_hi)
return d
def test_password_auth_failure(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': '******',
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
d.addBoth(client_disconnect)
return self.assertFailure(d, UnauthorizedLogin)
def test_password_identity_success(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': '******', # sshkey phrase
'identities': [self.sandbox+'/id_rsa'],
'buffersize': 32768}
id_rsa_pub = testUsers['testUser']['pub']
id_rsa_priv = testUsers['testUser']['priv']
open(self.sandbox+'/id_rsa.pub', 'w').write(id_rsa_pub)
open(self.sandbox+'/id_rsa', 'w').write(id_rsa_priv)
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addBoth(client_disconnect)
d.addCallback(got_hi)
return d
def test_password_identity_failure(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.sshServeruser,
'password': '******', # sshkey phrase
'identities': [self.sandbox + '/id_rsa'],
'buffersize': 32768}
id_rsa_pub = testUsers['testUser']['pub']
id_rsa_priv = testUsers['testUser']['priv']
open(self.sandbox+'/id_rsa.pub', 'w').write(id_rsa_pub)
open(self.sandbox+'/id_rsa', 'w').write(id_rsa_priv)
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
d.addBoth(client_disconnect)
return self.assertFailure(d, UnauthorizedLogin)
def test_password_identity_no_passphrase_success(self):
options = {'hostname': self.hostname,
'port': self.portnum,
'user': '******',
'identities': [self.sandbox + '/id_rsa2'],
'buffersize': 32768}
id_rsa_pub = testUsers['testUser2']['pub']
id_rsa_priv = testUsers['testUser2']['priv']
open(self.sandbox+'/id_rsa2.pub', 'w').write(id_rsa_pub)
open(self.sandbox+'/id_rsa2', 'w').write(id_rsa_priv)
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
d = self.client.run('echo hi')
def client_disconnect(data):
log.debug('Disconnecting client')
self.client.disconnect()
return data
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addBoth(client_disconnect)
d.addCallback(got_hi)
return d
class IPV4FunctionalNoReconnectionTestCase(TestCase):
def setUp(self):
self.timeout = 10
self.hostname = "127.0.0.1"
self.user = getpass.getuser()
self.password = "******"
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
"hostname": self.hostname,
"port": self.portnum,
"user": self.user,
"password": self.password,
"buffersize": 32768,
}
self.client = SSHClient(options)
self.client.maxRetries = 0
# self.client.maxDelay = 0
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug("tearing down")
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
# Wait for the server to stop.
return defer.gatherResults([d])
def test_run_command(self):
def server_stop_listening(data):
sld = self.port.stopListening()
return sld
def server_drop_connections(data):
port, self.port = self.port, None
server, self.server = self.server, None
server.protocol.transport.loseConnection()
log.debug("Dropping server connection")
return self.client.onConnectionLost
def run_command(data):
log.debug("running command hi2")
results = self.client.run("echo hi2")
return results
def test_failure_done(deferred):
log.debug("Failure %s " % deferred)
return self.assertEqual(deferred.type, ConnectionDone)
def test_success(data):
log.debug("Success %s" % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, "hi\n")
def bring_up_server(data):
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(self.portnum, self.server, interface=self.hostname)
log.debug("server started")
return data.factory.dConnected
d = self.client.run("echo hi")
d.addBoth(test_success)
d.addCallback(server_stop_listening)
d.addCallback(server_drop_connections)
d.addCallback(bring_up_server)
d.addCallback(run_command)
d.addErrback(test_failure_done)
return d
def test_lsdir(self):
test_file = "test_ls_dir"
sandbox = tempfile.mkdtemp()
testfile = "/".join([sandbox, test_file])
touch(testfile)
d = self.client.ls(sandbox)
def cleanup_sandbox(data):
log.debug("Cleaning up sandbox")
shutil.rmtree(sandbox)
def test_success(data):
return self.assertEqual(data[0][0], test_file)
def server_stop_listening(data):
sld = self.port.stopListening()
return sld
def server_drop_connections(data):
port, self.port = self.port, None
server, self.server = self.server, None
server.protocol.transport.loseConnection()
log.debug("Dropping server connection")
return self.client.onConnectionLost
def bring_up_server(data):
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(self.portnum, self.server, interface=self.hostname)
log.debug("server started")
return data.factory.dConnected
def run_lsdir(data):
log.debug("running command ls again")
results = self.client.ls(sandbox)
return results
def test_failure_done(deferred):
log.debug("Failure %s " % deferred)
return self.assertEqual(deferred.type, ConnectionDone)
d.addCallback(test_success)
d.addCallback(server_stop_listening)
d.addCallback(server_drop_connections)
d.addCallback(bring_up_server)
d.addCallback(run_lsdir)
d.addErrback(test_failure_done)
d.addBoth(cleanup_sandbox)
return d
class IPV4FunctionalNoReconnectionTestCase(TestCase):
def setUp(self):
self.timeout = 10
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.maxRetries = 0
#self.client.maxDelay = 0
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
# Wait for the server to stop.
return defer.gatherResults([d])
def test_run_command(self):
def server_stop_listening(data):
sld = self.port.stopListening()
return sld
def server_drop_connections(data):
port, self.port = self.port, None
server, self.server = self.server, None
server.protocol.transport.loseConnection()
log.debug('Dropping server connection')
return self.client.onConnectionLost
def run_command(data):
log.debug('running command hi2')
results = self.client.run('echo hi2')
return results
def test_failure_done(deferred):
log.debug('Failure %s ' % deferred)
return self.assertEqual(deferred.type, ConnectionDone)
def test_success(data):
log.debug('Success %s' % (data, ))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
def bring_up_server(data):
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(self.portnum,
self.server,
interface=self.hostname)
log.debug('server started')
return data.factory.dConnected
d = self.client.run('echo hi')
d.addBoth(test_success)
d.addCallback(server_stop_listening)
d.addCallback(server_drop_connections)
d.addCallback(bring_up_server)
d.addCallback(run_command)
d.addErrback(test_failure_done)
return d
def test_lsdir(self):
test_file = 'test_ls_dir'
sandbox = tempfile.mkdtemp()
testfile = '/'.join([sandbox, test_file])
touch(testfile)
d = self.client.ls(sandbox)
def cleanup_sandbox(data):
log.debug('Cleaning up sandbox')
shutil.rmtree(sandbox)
def test_success(data):
return self.assertEqual(data[0][0], test_file)
def server_stop_listening(data):
sld = self.port.stopListening()
return sld
def server_drop_connections(data):
port, self.port = self.port, None
server, self.server = self.server, None
server.protocol.transport.loseConnection()
log.debug('Dropping server connection')
return self.client.onConnectionLost
def bring_up_server(data):
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(self.portnum,
self.server,
interface=self.hostname)
log.debug('server started')
return data.factory.dConnected
def run_lsdir(data):
log.debug('running command ls again')
results = self.client.ls(sandbox)
return results
def test_failure_done(deferred):
log.debug('Failure %s ' % deferred)
return self.assertEqual(deferred.type, ConnectionDone)
d.addCallback(test_success)
d.addCallback(server_stop_listening)
d.addCallback(server_drop_connections)
d.addCallback(bring_up_server)
d.addCallback(run_lsdir)
d.addErrback(test_failure_done)
d.addBoth(cleanup_sandbox)
return d
class Pod:
"""Class which represents test pods.
For example with traffic gen, forward/swap applications, etc
"""
k8s_CoreV1Api = None
_log = None
_name = "pod"
_namespace = "default"
_nodeSelector_hostname = None
_last_status = None
_id = None
_admin_ip = None
_dp_ip = None
_ssh_client = None
_sriov_vf = None
_sriov_vf_mac = None
def __init__(self, name, namespace="default", logger_name="k8srapid"):
self._log = logging.getLogger(logger_name)
self._name = name
self._namespace = namespace
self._ssh_client = SSHClient(logger_name=logger_name)
def __del__(self):
"""Destroy POD. Do a cleanup.
"""
if self._ssh_client is not None:
self._ssh_client.disconnect()
def create_from_yaml(self, file_name):
"""Load POD description from yaml file.
"""
with open(path.join(path.dirname(__file__), file_name)) as yaml_file:
self.body = yaml.safe_load(yaml_file)
self.body["metadata"]["name"] = self._name
if (self._nodeSelector_hostname is not None):
if ("nodeSelector" not in self.body["spec"]):
self.body["spec"]["nodeSelector"] = {}
self.body["spec"]["nodeSelector"][
"kubernetes.io/hostname"] = self._nodeSelector_hostname
self._log.debug("Creating POD, body:\n%s" % self.body)
try:
self.k8s_CoreV1Api.create_namespaced_pod(
body=self.body, namespace=self._namespace)
except client.rest.ApiException as e:
self._log.error("Couldn't create POD %s!\n%s\n" %
(self._name, e))
def terminate(self):
"""Terminate POD. Close SSH connection.
"""
if self._ssh_client is not None:
self._ssh_client.disconnect()
try:
self.k8s_CoreV1Api.delete_namespaced_pod(name=self._name,
namespace=self._namespace)
except client.rest.ApiException as e:
if e.reason != "Not Found":
self._log.error("Couldn't delete POD %s!\n%s\n" %
(self._name, e.reason))
def update_admin_ip(self):
"""Check for admin IP address assigned by k8s.
"""
try:
pod = self.k8s_CoreV1Api.read_namespaced_pod_status(
name=self._name, namespace=self._namespace)
self._admin_ip = pod.status.pod_ip
except client.rest.ApiException as e:
self._log.error("Couldn't update POD %s admin IP!\n%s\n" %
(self._name, e))
def wait_for_start(self):
"""Wait for POD to start.
"""
self._log.info("Waiting for POD %s to start..." % self._name)
while True:
self.get_status()
if (self._last_status == "Running" or self._last_status == "Failed"
or self._last_status == "Unknown"):
break
else:
time.sleep(3)
self.update_admin_ip()
return self._last_status
def ssh_run_cmd(self, cmd):
"""Execute command for POD via SSH connection.
SSH credentials should be configured before use of this function.
"""
self._ssh_client.run_cmd(cmd)
def get_name(self):
return self._name
def get_admin_ip(self):
return self._admin_ip
def get_dp_ip(self):
return self._dp_ip
def get_dp_mac(self):
return self._sriov_vf_mac
def get_dp_pci_dev(self):
return self._sriov_vf
def get_id(self):
return self._id
def get_status(self):
"""Get current status fro the pod.
"""
try:
pod = self.k8s_CoreV1Api.read_namespaced_pod_status(
name=self._name, namespace=self._namespace)
except client.rest.ApiException as e:
self._log.error("Couldn't read POD %s status!\n%s\n" %
(self._name, e))
self._last_status = pod.status.phase
return self._last_status
def get_sriov_dev_mac(self):
"""Get assigned by k8s SRIOV network device plugin SRIOV VF devices.
Return 0 in case of sucessfull configuration.
Otherwise return -1.
"""
self._log.info("Checking assigned SRIOV VF for POD %s" % self._name)
ret = self._ssh_client.run_cmd(
"cat /opt/rapid/k8s_sriov_device_plugin_envs")
if ret != 0:
self._log.error("Failed to check assigned SRIOV VF!"
"Error %s" % self._ssh_client.get_error())
return -1
cmd_output = self._ssh_client.get_output().decode("utf-8").rstrip()
self._log.debug("Environment variable %s" % cmd_output)
# Parse environment variable
cmd_output = cmd_output.split("=")[1]
self._sriov_vf = cmd_output.split(",")[0]
self._log.debug("Using first SRIOV VF %s" % self._sriov_vf)
self._log.info("Getting MAC address for assigned SRIOV VF %s" %
self._sriov_vf)
self._ssh_client.run_cmd("sudo /opt/rapid/port_info_app -n 4 -w %s" %
self._sriov_vf)
if ret != 0:
self._log.error("Failed to get MAC address!"
"Error %s" % self._ssh_client.get_error())
return -1
# Parse MAC address
cmd_output = self._ssh_client.get_output().decode("utf-8").rstrip()
self._log.debug(cmd_output)
cmd_output = cmd_output.splitlines()
for line in cmd_output:
if line.startswith("Port 0 MAC: "):
self._sriov_vf_mac = line[12:]
self._log.debug("MAC %s" % self._sriov_vf_mac)
def set_dp_ip(self, dp_ip):
self._dp_ip = dp_ip
def set_id(self, pod_id):
self._id = pod_id
def set_nodeselector(self, hostname):
"""Set hostname on which POD will be executed.
"""
self._nodeSelector_hostname = hostname
def set_ssh_credentials(self, user, rsa_private_key):
"""Set SSH credentials for the SSH connection to the POD.
"""
self.update_admin_ip()
self._ssh_client.set_credentials(ip=self._admin_ip,
user=user,
rsa_private_key=rsa_private_key)
logging.basicConfig(level=logging.DEBUG)
#logging.basicConfig(level=logging.INFO)
from twisted.python import log as twistedlog
observer = twistedlog.PythonLoggingObserver()
observer.start()
log = logging.getLogger('txsshclient.client')
options = {
'hostname': '127.0.0.1',
'port': 2222,
'user': '******',
'password': '******',
'buffersize': 32768
}
client = SSHClient(options)
client.connect()
def retry():
log.debug('retrying')
d = client.run('sleep 5 && ls')
def failed_or_success(result):
if isinstance(result, failure.Failure):
log.info("Failed %s" % (result, ))
else:
log.info("Success %s" % (result, ))
d.addBoth(failed_or_success)
class IPV4FunctionalBaseTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults([d,
client.onConnectionLost,
server.onConnectionLost])
def test_run_command(self):
d = self.client.run('echo hi')
def got_hi(data):
log.debug('Got Data %s' % (data,))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addCallback(got_hi)
return d
@defer.inlineCallbacks
def test_lsdir(self):
try:
test_file = 'test_ls_dir'
sandbox = tempfile.mkdtemp()
testfile = '/'.join([sandbox, test_file])
touch(testfile)
d = yield self.client.ls(sandbox)
self.assertEquals(d[0][0], test_file)
defer.returnValue(d)
finally:
shutil.rmtree(sandbox)
def test_lsdir_no_dir(self):
d = self.client.ls('/_not_real')
return self.assertFailure(d, SFTPError)
@defer.inlineCallbacks
def test_mkdir(self):
try:
sandbox = tempfile.mkdtemp()
test_dir = 'tmpMkdir'
directory = '/'.join([sandbox, test_dir])
result = yield self.client.mkdir(directory)
self.assertEquals(result[0], 'mkdir succeeded')
self.assertTrue(os.path.isdir(directory))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_rmdir(self):
try:
sandbox = tempfile.mkdtemp()
test_dir = 'tmpRmdir'
directory = '/'.join([sandbox, test_dir])
os.mkdir(directory)
result = yield self.client.rmdir(directory)
self.assertEquals(result[0], 'rmdir succeeded')
self.assertFalse(os.path.exists(directory))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_rename(self):
try:
original_filename = 'test_rename'
destination_filename = 'test_rename_changed'
sandbox = tempfile.mkdtemp()
original_path = '/'.join([sandbox, original_filename])
destination_path = '/'.join([sandbox, destination_filename])
touch(original_path)
result = yield self.client.rename(original_path,
destination_path)
self.assertEquals(result[0], 'rename succeeded')
self.assertFalse(os.path.exists(original_path))
self.assertTrue(os.path.exists(destination_path))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_ln(self):
try:
original_filename = 'test_ln'
destination_filename = 'test_ln_destination'
sandbox = tempfile.mkdtemp()
original_path = '/'.join([sandbox, original_filename])
destination_path = '/'.join([sandbox, destination_filename])
touch(original_path)
result = yield self.client.ln(destination_path, original_path)
self.assertEquals(result[0], 'symlink succeeded')
self.assertTrue(os.path.isfile(original_path))
self.assertTrue(os.path.islink(destination_path))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_rm(self):
try:
original_filename = 'test_rm_file'
sandbox = tempfile.mkdtemp()
original_path = '/'.join([sandbox, original_filename])
touch(original_path)
result = yield self.client.rm(original_path)
self.assertEquals(result[0], 'remove succeeded')
self.assertFalse(os.path.exists(original_path))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_put(self):
try:
source_data = 'This was my sourcefile...'
source_filename = 'test_source_file'
destination_filename = 'test_destination_file'
source_sandbox = tempfile.mkdtemp()
destination_sandbox = tempfile.mkdtemp()
source_path = '/'.join([source_sandbox, source_filename])
destination_path = '/'.join([destination_sandbox,
destination_filename])
open(source_path, 'w').write(source_data)
result = yield self.client.put(source_path, destination_path)
self.assertTrue(os.path.isfile(source_path))
self.assertTrue(os.path.isfile(destination_path))
self.assertEqual(source_data,
open(destination_path, 'r').read())
defer.returnValue(result)
finally:
shutil.rmtree(source_sandbox)
shutil.rmtree(destination_sandbox)
@defer.inlineCallbacks
def test_get(self):
try:
source_data = 'This was my sourcefile...'
source_filename = 'test_source_file'
destination_filename = 'test_destination_file'
source_sandbox = tempfile.mkdtemp()
destination_sandbox = tempfile.mkdtemp()
source_path = '/'.join([source_sandbox, source_filename])
destination_path = '/'.join([destination_sandbox,
destination_filename])
open(source_path, 'w').write(source_data)
result = yield self.client.get(source_path, destination_path)
self.assertTrue(os.path.isfile(source_path))
self.assertTrue(os.path.isfile(destination_path))
self.assertEqual(source_data,
open(destination_path, 'r').read())
defer.returnValue(result)
finally:
shutil.rmtree(source_sandbox)
shutil.rmtree(destination_sandbox)
@defer.inlineCallbacks
def test_chown(self):
try:
chown_filename = 'test_chown_file'
sandbox = tempfile.mkdtemp()
chown_path = '/'.join([sandbox, chown_filename])
touch(chown_path)
import os
import pwd
uid = pwd.getpwuid(os.getuid()).pw_uid
result = yield self.client.chown(chown_path, uid)
self.assertEquals(result[0], 'setstat succeeded')
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_chgrp(self):
try:
chgrp_filename = 'test_chgrp_file'
sandbox = tempfile.mkdtemp()
chgrp_path = '/'.join([sandbox, chgrp_filename])
touch(chgrp_path)
import os
import pwd
gid = pwd.getpwuid(os.getuid()).pw_gid
result = yield self.client.chgrp(chgrp_path, gid)
self.assertEquals(result[0], 'setstat succeeded')
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_chmod(self):
try:
chmod_filename = 'test_chmod_file'
sandbox = tempfile.mkdtemp()
chmod_path = '/'.join([sandbox, chmod_filename])
touch(chmod_path)
result = yield self.client.chmod(chmod_path, '1000')
self.assertEquals(result[0], 'setstat succeeded')
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
class IPV4FunctionalBaseTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults(
[d, client.onConnectionLost, server.onConnectionLost])
def test_run_command(self):
d = self.client.run('echo hi')
def got_hi(data):
log.debug('Got Data %s' % (data, ))
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
d.addCallback(got_hi)
return d
@defer.inlineCallbacks
def test_lsdir(self):
try:
test_file = 'test_ls_dir'
sandbox = tempfile.mkdtemp()
testfile = '/'.join([sandbox, test_file])
touch(testfile)
d = yield self.client.ls(sandbox)
self.assertEquals(d[0][0], test_file)
defer.returnValue(d)
finally:
shutil.rmtree(sandbox)
def test_lsdir_no_dir(self):
d = self.client.ls('/_not_real')
return self.assertFailure(d, SFTPError)
@defer.inlineCallbacks
def test_mkdir(self):
try:
sandbox = tempfile.mkdtemp()
test_dir = 'tmpMkdir'
directory = '/'.join([sandbox, test_dir])
result = yield self.client.mkdir(directory)
self.assertEquals(result[0], 'mkdir succeeded')
self.assertTrue(os.path.isdir(directory))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_rmdir(self):
try:
sandbox = tempfile.mkdtemp()
test_dir = 'tmpRmdir'
directory = '/'.join([sandbox, test_dir])
os.mkdir(directory)
result = yield self.client.rmdir(directory)
self.assertEquals(result[0], 'rmdir succeeded')
self.assertFalse(os.path.exists(directory))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_rename(self):
try:
original_filename = 'test_rename'
destination_filename = 'test_rename_changed'
sandbox = tempfile.mkdtemp()
original_path = '/'.join([sandbox, original_filename])
destination_path = '/'.join([sandbox, destination_filename])
touch(original_path)
result = yield self.client.rename(original_path, destination_path)
self.assertEquals(result[0], 'rename succeeded')
self.assertFalse(os.path.exists(original_path))
self.assertTrue(os.path.exists(destination_path))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_ln(self):
try:
original_filename = 'test_ln'
destination_filename = 'test_ln_destination'
sandbox = tempfile.mkdtemp()
original_path = '/'.join([sandbox, original_filename])
destination_path = '/'.join([sandbox, destination_filename])
touch(original_path)
result = yield self.client.ln(destination_path, original_path)
self.assertEquals(result[0], 'symlink succeeded')
self.assertTrue(os.path.isfile(original_path))
self.assertTrue(os.path.islink(destination_path))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_rm(self):
try:
original_filename = 'test_rm_file'
sandbox = tempfile.mkdtemp()
original_path = '/'.join([sandbox, original_filename])
touch(original_path)
result = yield self.client.rm(original_path)
self.assertEquals(result[0], 'remove succeeded')
self.assertFalse(os.path.exists(original_path))
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_put(self):
try:
source_data = 'This was my sourcefile...'
source_filename = 'test_source_file'
destination_filename = 'test_destination_file'
source_sandbox = tempfile.mkdtemp()
destination_sandbox = tempfile.mkdtemp()
source_path = '/'.join([source_sandbox, source_filename])
destination_path = '/'.join(
[destination_sandbox, destination_filename])
open(source_path, 'w').write(source_data)
result = yield self.client.put(source_path, destination_path)
self.assertTrue(os.path.isfile(source_path))
self.assertTrue(os.path.isfile(destination_path))
self.assertEqual(source_data, open(destination_path, 'r').read())
defer.returnValue(result)
finally:
shutil.rmtree(source_sandbox)
shutil.rmtree(destination_sandbox)
@defer.inlineCallbacks
def test_get(self):
try:
source_data = 'This was my sourcefile...'
source_filename = 'test_source_file'
destination_filename = 'test_destination_file'
source_sandbox = tempfile.mkdtemp()
destination_sandbox = tempfile.mkdtemp()
source_path = '/'.join([source_sandbox, source_filename])
destination_path = '/'.join(
[destination_sandbox, destination_filename])
open(source_path, 'w').write(source_data)
result = yield self.client.get(source_path, destination_path)
self.assertTrue(os.path.isfile(source_path))
self.assertTrue(os.path.isfile(destination_path))
self.assertEqual(source_data, open(destination_path, 'r').read())
defer.returnValue(result)
finally:
shutil.rmtree(source_sandbox)
shutil.rmtree(destination_sandbox)
@defer.inlineCallbacks
def test_chown(self):
try:
chown_filename = 'test_chown_file'
sandbox = tempfile.mkdtemp()
chown_path = '/'.join([sandbox, chown_filename])
touch(chown_path)
import os
import pwd
uid = pwd.getpwuid(os.getuid()).pw_uid
result = yield self.client.chown(chown_path, uid)
self.assertEquals(result[0], 'setstat succeeded')
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_chgrp(self):
try:
chgrp_filename = 'test_chgrp_file'
sandbox = tempfile.mkdtemp()
chgrp_path = '/'.join([sandbox, chgrp_filename])
touch(chgrp_path)
import os
import pwd
gid = pwd.getpwuid(os.getuid()).pw_gid
result = yield self.client.chgrp(chgrp_path, gid)
self.assertEquals(result[0], 'setstat succeeded')
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
@defer.inlineCallbacks
def test_chmod(self):
try:
chmod_filename = 'test_chmod_file'
sandbox = tempfile.mkdtemp()
chmod_path = '/'.join([sandbox, chmod_filename])
touch(chmod_path)
result = yield self.client.chmod(chmod_path, '1000')
self.assertEquals(result[0], 'setstat succeeded')
defer.returnValue(result)
finally:
shutil.rmtree(sandbox)
def configure_server(server, branches):
client = SSHClient(utils.get_public_ip(server), 'jenkins')
client.ssh('make file cache directory', 'mkdir -p ~/cache/files')
client.ssh('make pip cache directory', 'mkdir -p ~/cache/pip')
client.ssh('install build-essential',
'sudo DEBIAN_FRONTEND=noninteractive '
'apt-get --option "Dpkg::Options::=--force-confold"'
' --assume-yes install build-essential python-dev '
'linux-headers-virtual linux-headers-`uname -r`')
for branch_data in branches:
if branch_data['debs']:
client.ssh('cache debs for branch %s' % branch_data['name'],
'sudo apt-get -y -d install %s' %
' '.join(branch_data['debs']))
if branch_data['pips']:
venv = client.ssh('get temp dir for venv', 'mktemp -d').strip()
client.ssh('create venv',
'virtualenv --no-site-packages %s' % venv)
client.ssh('cache pips for branch %s' % branch_data['name'],
'source %s/bin/activate && '
'PIP_DOWNLOAD_CACHE=~/cache/pip pip install %s' %
(venv, ' '.join(branch_data['pips'])))
client.ssh('remove venv', 'rm -fr %s' % venv)
for url in branch_data['images']:
fname = url.split('/')[-1]
try:
client.ssh('check for %s' % fname,
'ls ~/cache/files/%s' % fname)
except:
client.ssh('download image %s' % fname,
'wget -nv -c %s -O ~/cache/files/%s' % (url, fname))
client.ssh('clear workspace', 'rm -rf ~/workspace-cache')
client.ssh('make workspace', 'mkdir -p ~/workspace-cache')
for project in PROJECTS:
sp = project.split('/')[0]
client.ssh('clone %s' % project,
'cd ~/workspace-cache && '
'git clone https://review.openstack.org/p/%s' % project)
script = os.environ.get('DEVSTACK_GATE_CUSTOM_SCRIPT', '')
if script and os.path.isfile(script):
bn = os.path.basename(script)
client.scp(script, '/tmp/%s' % bn)
client.ssh('run custom script %s' % bn,
'chmod +x /tmp/%s && sudo /tmp/%s' % (bn, bn))
client.ssh('sync', 'sync && sleep 5')
class IPV4FunctionalReconnectionTestCase(TestCase):
def setUp(self):
self.hostname = '127.0.0.1'
self.user = getpass.getuser()
self.password = '******'
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
'hostname': self.hostname,
'port': self.portnum,
'user': self.user,
'password': self.password,
'buffersize': 32768
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug('tearing down')
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults(
[d, client.onConnectionLost, server.onConnectionLost])
def test_run_command(self):
def server_stop_listening(data):
sld = self.port.stopListening()
return sld
def server_drop_connections(data):
port, self.port = self.port, None
server, self.server = self.server, None
server.protocol.transport.loseConnection()
return server.onConnectionLost
def run_command(sld):
results = self.client.run('echo hi')
return results
def test_failure(data):
return self.assertFailure(data, ConnectionLost)
def test_success(data):
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, 'hi\n')
return data
def start_server(data):
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(self.portnum,
self.server,
interface=self.hostname)
return self.port
d = self.client.run('echo hi')
d.addBoth(test_success)
d.addCallback(server_stop_listening)
d.addCallback(server_drop_connections)
d.addCallback(run_command)
d.addBoth(test_failure)
d.addBoth(start_server)
d.addCallback(run_command)
d.addBoth(test_success)
return d
class IPV4FunctionalReconnectionTestCase(TestCase):
def setUp(self):
self.hostname = "127.0.0.1"
self.user = getpass.getuser()
self.password = "******"
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(0, self.server, interface=self.hostname)
self.portnum = self.port.getHost().port
options = {
"hostname": self.hostname,
"port": self.portnum,
"user": self.user,
"password": self.password,
"buffersize": 32768,
}
self.client = SSHClient(options)
self.client.protocol = ClientProtocol
self.client.connect()
def tearDown(self):
# Shut down the server and client
log.debug("tearing down")
port, self.port = self.port, None
client, self.client = self.client, None
server, self.server = self.server, None
# A Deferred for the server listening port
d = port.stopListening()
# Tell the client to disconnect and not retry.
client.disconnect()
return defer.gatherResults([d, client.onConnectionLost, server.onConnectionLost])
def test_run_command(self):
def server_stop_listening(data):
sld = self.port.stopListening()
return sld
def server_drop_connections(data):
port, self.port = self.port, None
server, self.server = self.server, None
server.protocol.transport.loseConnection()
return server.onConnectionLost
def run_command(sld):
results = self.client.run("echo hi")
return results
def test_failure(data):
return self.assertFailure(data, ConnectionLost)
def test_success(data):
self.assertEqual(data.exitCode, 0)
self.assertEqual(data.output, "hi\n")
return data
def start_server(data):
self.server = SSHServer()
self.server.protocol = ServerProtocol
self.port = reactor.listenTCP(self.portnum, self.server, interface=self.hostname)
return self.port
d = self.client.run("echo hi")
d.addBoth(test_success)
d.addCallback(server_stop_listening)
d.addCallback(server_drop_connections)
d.addCallback(run_command)
d.addBoth(test_failure)
d.addBoth(start_server)
d.addCallback(run_command)
d.addBoth(test_success)
return d
def collect(self, device, log):
manageIp = str(device.manageIp)
log.info('Connecting to ssh://%s@%s:%d' % (
device.zCommandUsername,
manageIp,
device.zCommandPort
))
self.client = SSHClient({
'hostname': manageIp,
'port': device.zCommandPort,
'user': device.zCommandUsername,
'password': device.zCommandPassword,
'buffersize': 32768})
self.client.connect()
self.timeout = device.zCommandCommandTimeout
data = {}
required_files = ['neutron.conf']
optional_files = ['plugins/ml2/ml2_conf.ini']
plugin_names = set()
try:
# Check if neutron-server runs on this machine
d = yield self.client.run("pgrep neutron-server", timeout=self.timeout)
if d.exitCode != 0:
# neutron isn't running on this host, so its config
# files are suspect, and should be ignored.
log.info("neutron-server not running on host- not collecting ini files")
defer.returnValue(data)
return
# Collect ini files
for filename in required_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename, required=True)
for filename in optional_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename)
required_files = []
optional_files = []
if data['neutron.conf']:
ini = data['neutron.conf']
neutron_core_plugin = self.ini_get(device, filename, ini, 'DEFAULT', 'core_plugin', required=True)
plugin_names.add(neutron_core_plugin)
if 'plugins/ml2/ml2_conf.ini' in data:
mechanism_drivers = split_list(self.ini_get(
device,
filename,
data['plugins/ml2/ml2_conf.ini'],
'ml2',
'mechanism_drivers',
required=True) or '')
for mechanism_driver in mechanism_drivers:
plugin_names.add("ml2." + mechanism_driver)
data['plugin_names'] = set()
for plugin_name in plugin_names:
plugin = zope.component.queryUtility(INeutronImplementationPlugin, plugin_name)
if not plugin:
continue
plugin_class = plugin.__class__.__name__
log.info("Checking for additinal ini requirements in neutron implementation plugin '%s': %s" % (plugin_name, plugin_class))
data['plugin_names'].add(plugin_name)
for filename, section, option in plugin.ini_required():
required_files.append(filename)
for filename, section, option in plugin.ini_optional():
optional_files.append(filename)
for filename in required_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename, required=True)
for filename in optional_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename)
except Exception:
raise
finally:
self.client.disconnect()
defer.returnValue(data)
def configure_server(server, branches):
client = SSHClient(utils.get_public_ip(server), 'jenkins')
client.ssh('make file cache directory', 'mkdir -p ~/cache/files')
client.ssh('make pip cache directory', 'mkdir -p ~/cache/pip')
client.ssh(
'install build-essential', 'sudo DEBIAN_FRONTEND=noninteractive '
'apt-get --option "Dpkg::Options::=--force-confold"'
' --assume-yes install build-essential python-dev '
'linux-headers-virtual linux-headers-`uname -r`')
for branch_data in branches:
if branch_data['debs']:
client.ssh(
'cache debs for branch %s' % branch_data['name'],
'sudo apt-get -y -d install %s' %
' '.join(branch_data['debs']))
if branch_data['pips']:
venv = client.ssh('get temp dir for venv', 'mktemp -d').strip()
client.ssh('create venv',
'virtualenv --no-site-packages %s' % venv)
client.ssh(
'cache pips for branch %s' % branch_data['name'],
'source %s/bin/activate && '
'PIP_DOWNLOAD_CACHE=~/cache/pip pip install %s' %
(venv, ' '.join(branch_data['pips'])))
client.ssh('remove venv', 'rm -fr %s' % venv)
for url in branch_data['images']:
fname = url.split('/')[-1]
try:
client.ssh('check for %s' % fname,
'ls ~/cache/files/%s' % fname)
except:
client.ssh('download image %s' % fname,
'wget -c %s -O ~/cache/files/%s' % (url, fname))
client.ssh('clear workspace', 'rm -rf ~/workspace-cache')
client.ssh('make workspace', 'mkdir -p ~/workspace-cache')
for project in PROJECTS:
sp = project.split('/')[0]
client.ssh(
'clone %s' % project, 'cd ~/workspace-cache && '
'git clone https://review.openstack.org/p/%s' % project)
script = os.environ.get('DEVSTACK_GATE_CUSTOM_SCRIPT', '')
if script and os.path.isfile(script):
bn = os.path.basename(script)
client.scp(script, '/tmp/%s' % bn)
client.ssh('run custom script %s' % bn,
'chmod +x /tmp/%s && /tmp/%s' % (bn, bn))
client.ssh('sync', 'sync && sleep 5')
def __init__(self, name, namespace="default", logger_name="k8srapid"):
self._log = logging.getLogger(logger_name)
self._name = name
self._namespace = namespace
self._ssh_client = SSHClient(logger_name=logger_name)
#
#Author Pradeep CH
#
__author__ = 'Pradeep CH'
__version__ = '1.0.0'
# Create instance of FieldStorage
form = cgi.FieldStorage()
clientIp = cgi.escape(os.environ["REMOTE_ADDR"])
bodyContent = '' #html.getBackButton('/pat/ssh/remotessh.htm')
# Get mode from fields
un = form.getvalue('username')
ip = form.getvalue('ip')
if not ip or not un:
bodyContent += 'IP and Username required.'
else:
bodyContent += 'Your machine IP is %s <br>' % (str(clientIp))
try:
cl = SSHClient(clientIp)
cl.enableSSH(ip, un)
bodyContent += 'SSH successfull'
except Exception as e:
bodyContent += 'Could not connect to remote machine. Make sure the PAT plugin is running in your machine, Cause : %s' % str(
e)
#print html
html.printHeader('Authetication Validation')
html.printBodyContent(bodyContent)
def configure_server(server, branches):
client = SSHClient(utils.get_public_ip(server), "jenkins")
client.ssh("make file cache directory", "mkdir -p ~/cache/files")
client.ssh("make pip cache directory", "mkdir -p ~/cache/pip")
client.ssh(
"install build-essential",
"sudo DEBIAN_FRONTEND=noninteractive "
'apt-get --option "Dpkg::Options::=--force-confold"'
" --assume-yes install build-essential python-dev "
"linux-headers-virtual linux-headers-`uname -r`",
)
for branch_data in branches:
if branch_data["debs"]:
client.ssh(
"cache debs for branch %s" % branch_data["name"],
"sudo apt-get -y -d install %s" % " ".join(branch_data["debs"]),
)
if branch_data["pips"]:
venv = client.ssh("get temp dir for venv", "mktemp -d").strip()
client.ssh("create venv", "virtualenv --no-site-packages %s" % venv)
client.ssh(
"cache pips for branch %s" % branch_data["name"],
"source %s/bin/activate && "
"PIP_DOWNLOAD_CACHE=~/cache/pip pip install %s" % (venv, " ".join(branch_data["pips"])),
)
client.ssh("remove venv", "rm -fr %s" % venv)
for url in branch_data["images"]:
fname = url.split("/")[-1]
try:
client.ssh("check for %s" % fname, "ls ~/cache/files/%s" % fname)
except:
client.ssh("download image %s" % fname, "wget -nv -c %s -O ~/cache/files/%s" % (url, fname))
client.ssh("clear workspace", "rm -rf ~/workspace-cache")
client.ssh("make workspace", "mkdir -p ~/workspace-cache")
for project in PROJECTS:
client.ssh(
"clone %s" % project, "cd ~/workspace-cache && " "git clone https://review.openstack.org/p/%s" % project
)
script = os.environ.get("DEVSTACK_GATE_CUSTOM_SCRIPT", "")
if script and os.path.isfile(script):
bn = os.path.basename(script)
client.scp(script, "/tmp/%s" % bn)
client.ssh("run custom script %s" % bn, "chmod +x /tmp/%s && sudo /tmp/%s" % (bn, bn))
client.ssh("sync", "sync && sleep 5")
def collect(self, device, log):
manageIp = str(device.manageIp)
log.info('Connecting to ssh://%s@%s:%d' % (
device.zCommandUsername,
manageIp,
device.zCommandPort
))
client = SSHClient({
'hostname': manageIp,
'port': device.zCommandPort,
'user': device.zCommandUsername,
'password': device.zCommandPassword,
'buffersize': 32768})
client.connect()
timeout = device.zCommandCommandTimeout
data = {}
try:
for instanceId, instanceUUID in device.openstack_instanceList:
cmd = "virsh --readonly -c 'qemu:///system' dumpxml '%s'" % instanceUUID
log.info("Running %s" % cmd)
d = yield client.run(cmd, timeout=timeout)
if d.exitCode != 0 or d.stderr:
if 'Domain not found' in d.stderr:
log.debug("Domain not found while running virsh (rc=%s, stderr='%s')" % (d.exitCode, d.stderr))
else:
log.error("Error running virsh (rc=%s, stderr='%s')" % (d.exitCode, d.stderr))
continue
try:
tree = etree.fromstring(d.output)
instanceName = str(tree.xpath("/domain/name/text()")[0])
zenossInstanceId = 'server-%s' % (instanceUUID)
data[instanceUUID] = {
'id': zenossInstanceId,
'serialNumber': str(tree.xpath("/domain/sysinfo/system/entry[@name='serial']/text()")[0]),
'biosUuid': str(tree.xpath("/domain/sysinfo/system/entry[@name='uuid']/text()")[0])
}
except Exception:
log.error("Invalid XML Received from (%s):\n%s\n\n" % (cmd, d.output))
raise LibvirtXMLError('Incomplete or invalid XML returned from virsh command. Consult log for more details.')
vnics = []
for interface in tree.xpath("/domain/devices/interface"):
target = interface.find("target/[@dev]")
mac = interface.find("mac/[@address]")
if target is None or mac is None:
# unrecognized interface type
continue
# compute the resourceId in the same way that ceilometer's
# net pollster does.
vnicName = str(target.get('dev'))
zenossVnicId = 'vnic-%s-%s' % (instanceUUID, vnicName)
ceilometerResourceId = '%s-%s-%s' % (instanceName, instanceUUID, vnicName)
vnics.append({
'id': zenossVnicId,
'name': vnicName,
'macaddress': str(mac.get('address')),
'resourceId': ceilometerResourceId
})
data[instanceUUID]['vnics'] = vnics
finally:
client.disconnect()
returnValue(data)
from sshclient import SSHClient
import logging
logging.basicConfig(level=logging.DEBUG)
# logging.basicConfig(level=logging.INFO)
from twisted.python import log as twistedlog
observer = twistedlog.PythonLoggingObserver()
observer.start()
log = logging.getLogger("txsshclient.client")
options = {"hostname": "127.0.0.1", "port": 2222, "user": "******", "password": "******", "buffersize": 32768}
client = SSHClient(options)
client.connect()
def retry():
log.debug("retrying")
d = client.run("sleep 5 && ls")
def failed_or_success(result):
if isinstance(result, failure.Failure):
log.info("Failed %s" % (result,))
else:
log.info("Success %s" % (result,))
d.addBoth(failed_or_success)
class inifiles(PythonPlugin):
_yaml_config = None
_eventService = None
deviceProperties = PythonPlugin.deviceProperties \
+ ('zCommandUsername', 'zCommandPassword',
'zCommandPort', 'zCommandCommandTimeout',
'zOpenStackNeutronConfigDir')
def sendEvent(self, evt):
if not self._eventService:
self._eventService = zope.component.queryUtility(IEventService)
self._eventService.sendEvent(evt)
def sendFileClearEvent(self, device, filename):
evt = dict(
device=device.id,
component='',
summary="File %s was loaded successfully" % filename,
severity=Event.Clear,
eventClassKey='openStackIniFileAccess',
eventKey=filename
)
self.sendEvent(evt)
def sendFileErrorEvent(self, device, filename, errmsg):
evt = dict(
device=device.id,
component='',
summary="File %s could not be accessed: %s" % (filename, errmsg),
severity=Event.Error,
eventClassKey='openStackIniFileAccess',
eventKey=filename
)
self.sendEvent(evt)
def sendOptionClearEvent(self, device, filename, section, option):
evt = dict(
device=device.id,
component='',
summary="%s: Required option [%s] %s was loaded successfully" % (filename, section, option),
severity=Event.Clear,
eventClassKey='openStackIniFileOptionParsing',
eventKey="%s/%s/%s" % (filename, section, option)
)
self.sendEvent(evt)
def sendOptionErrorEvent(self, device, filename, section, option):
evt = dict(
device=device.id,
component='',
summary="%s: Required option [%s] %s was not found" % (filename, section, option),
severity=Event.Error,
eventClassKey='openStackIniFileOptionParsing',
eventKey="%s/%s/%s" % (filename, section, option)
)
self.sendEvent(evt)
def ini_get(self, device, filename, ini, section, option, required=False):
try:
return ini.get(section, option)
if required:
self.sendOptionClearEvent(device, filename, section, option)
except ConfigParser.NoOptionError:
if required:
self.sendOptionErrorEvent(device, filename, section, option)
return None
@defer.inlineCallbacks
def read_ini(self, device, filename, required=False):
filepath = os.path.join(device.zOpenStackNeutronConfigDir, filename)
log.info("Retrieving %s", filepath)
cmd = "cat %s" % filepath
d = yield self.client.run(cmd, timeout=self.timeout)
if d.exitCode != 0 or d.stderr:
if required:
log.error("Unable to access required file %s (%s)" % (filepath, d.stderr.strip()))
self.sendFileErrorEvent(device, filepath, d.stderr)
else:
log.info("Unable to access optional file %s (%s)" % (filepath, d.stderr.strip()))
defer.returnValue(None)
return
self.sendFileClearEvent(device, filepath)
ini = ConfigParser.RawConfigParser(allow_no_value=True)
ini.readfp(io.BytesIO(d.output))
defer.returnValue(ini)
return
@defer.inlineCallbacks
def collect(self, device, log):
manageIp = str(device.manageIp)
log.info('Connecting to ssh://%s@%s:%d' % (
device.zCommandUsername,
manageIp,
device.zCommandPort
))
self.client = SSHClient({
'hostname': manageIp,
'port': device.zCommandPort,
'user': device.zCommandUsername,
'password': device.zCommandPassword,
'buffersize': 32768})
self.client.connect()
self.timeout = device.zCommandCommandTimeout
data = {}
required_files = ['neutron.conf']
optional_files = ['plugins/ml2/ml2_conf.ini']
plugin_names = set()
try:
# Check if neutron-server runs on this machine
d = yield self.client.run("pgrep neutron-server", timeout=self.timeout)
if d.exitCode != 0:
# neutron isn't running on this host, so its config
# files are suspect, and should be ignored.
log.info("neutron-server not running on host- not collecting ini files")
defer.returnValue(data)
return
# Collect ini files
for filename in required_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename, required=True)
for filename in optional_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename)
required_files = []
optional_files = []
if data['neutron.conf']:
ini = data['neutron.conf']
neutron_core_plugin = self.ini_get(device, filename, ini, 'DEFAULT', 'core_plugin', required=True)
plugin_names.add(neutron_core_plugin)
if 'plugins/ml2/ml2_conf.ini' in data:
mechanism_drivers = split_list(self.ini_get(
device,
filename,
data['plugins/ml2/ml2_conf.ini'],
'ml2',
'mechanism_drivers',
required=True) or '')
for mechanism_driver in mechanism_drivers:
plugin_names.add("ml2." + mechanism_driver)
data['plugin_names'] = set()
for plugin_name in plugin_names:
plugin = zope.component.queryUtility(INeutronImplementationPlugin, plugin_name)
if not plugin:
continue
plugin_class = plugin.__class__.__name__
log.info("Checking for additinal ini requirements in neutron implementation plugin '%s': %s" % (plugin_name, plugin_class))
data['plugin_names'].add(plugin_name)
for filename, section, option in plugin.ini_required():
required_files.append(filename)
for filename, section, option in plugin.ini_optional():
optional_files.append(filename)
for filename in required_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename, required=True)
for filename in optional_files:
if filename not in data:
data[filename] = yield self.read_ini(device, filename)
except Exception:
raise
finally:
self.client.disconnect()
defer.returnValue(data)
def process(self, device, results, log):
log.info("Modeler %s processing data for device %s",
self.name(), device.id)
if 'neutron.conf' not in results:
log.info("No neutron ini files to process.")
return
data = {
'neutron_core_plugin': None,
'neutron_mechanism_drivers': [],
'neutron_type_drivers': [],
'set_neutron_ini': {}
}
if 'plugin_names' not in results:
log.error("No neutron implementation plugins were identified, unable to continue.")
return
if results['neutron.conf']:
filename = 'neutron.conf'
ini = results[filename]
data['neutron_core_plugin'] = self.ini_get(device, filename, ini, 'DEFAULT', 'core_plugin', required=True)
if data['neutron_core_plugin']:
if data['neutron_core_plugin'] in ('neutron.plugins.ml2.plugin.Ml2Plugin', 'ml2'):
filename = 'plugins/ml2/ml2_conf.ini'
ini = results[filename]
if ini:
data['neutron_type_drivers'] = split_list(self.ini_get(device, filename, ini, 'ml2', 'type_drivers', required=True))
data['neutron_mechanism_drivers'] = split_list(self.ini_get(device, filename, ini, 'ml2', 'mechanism_drivers', required=True))
for plugin_name in results['plugin_names']:
# See if we have any plugins registered for the core module
# (if not ML2) or mechanism type (if ML2)
plugin = zope.component.queryUtility(INeutronImplementationPlugin, plugin_name)
if not plugin:
continue
log.debug("(Process) Using plugin '%s'" % plugin_name)
for filename, section, option in plugin.ini_required():
ini = results.get(filename, None)
if ini:
data['set_neutron_ini'][(filename, section, option)] = self.ini_get(device, filename, ini, section, option, required=True)
for filename, section, option in plugin.ini_optional():
ini = results.get(filename, None)
if ini:
data['set_neutron_ini'][(filename, section, option)] = self.ini_get(device, filename, ini, section, option)
return ObjectMap({'setApplyDataMapToOpenStackInfrastructureEndpoint': ObjectMap(data)})
