def __init__(self,
ip_address=None,
server_id=None,
username=None,
password=None,
config=None,
os_distro=None,
key=None):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
ssh_timeout = config.connection_timeout
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
if self.username is None:
self.username = '******'
self.password = password
self.server_id = server_id
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address,
config.ip_address_version_for_ssh)
time.sleep(config.connection_retry_interval)
if int(time.time()) - start >= config.connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(username=self.username,
password=self.password,
host=self.ip_address,
tcp_timeout=20,
auth_strategy=auth_strategy,
look_for_keys=False,
key=key)
self.ssh_client.connect_with_timeout(cooldown=20, timeout=ssh_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(
message.format(timeout=ssh_timeout, ip_address=ip_address))
def __init__(self, ip_address=None, server_id=None, username=None,
password=None, config=None, os_distro=None, key=None):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
ssh_timeout = config.connection_timeout
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
if self.username is None:
self.username = '******'
self.password = password
self.server_id = server_id
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address,
config.ip_address_version_for_ssh)
time.sleep(config.connection_retry_interval)
if int(time.time()) - start >= config.connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(
username=self.username, password=self.password,
host=self.ip_address, tcp_timeout=20, auth_strategy=auth_strategy,
look_for_keys=False, key=key)
self.ssh_client.connect_with_timeout(cooldown=20, timeout=ssh_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(message.format(
timeout=ssh_timeout, ip_address=ip_address))
class LinuxClient(BaseClient):
def __init__(self,
ip_address=None,
server_id=None,
username=None,
password=None,
config=None,
os_distro=None,
key=None):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
ssh_timeout = config.connection_timeout
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
if self.username is None:
self.username = '******'
self.password = password
self.server_id = server_id
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address,
config.ip_address_version_for_ssh)
time.sleep(config.connection_retry_interval)
if int(time.time()) - start >= config.connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(username=self.username,
password=self.password,
host=self.ip_address,
tcp_timeout=20,
auth_strategy=auth_strategy,
look_for_keys=False,
key=key)
self.ssh_client.connect_with_timeout(cooldown=20, timeout=ssh_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(
message.format(timeout=ssh_timeout, ip_address=ip_address))
def can_connect_to_public_ip(self):
"""
@summary: Checks if you can connect to server using public ip
@return: True if you can connect, False otherwise
@rtype: bool
"""
# This returns true since the connection has already been tested in the
# init method
return self.ssh_client is not None
def can_ping_public_ip(self, public_addresses, ip_address_version_for_ssh):
"""
@summary: Checks if you can ping a public ip
@param addresses: List of public addresses
@type addresses: Address List
@return: True if you can ping, False otherwise
@rtype: bool
"""
for public_address in public_addresses:
if public_address.version == 4 and not PingClient.ping(
public_address.addr, ip_address_version_for_ssh):
return False
return True
def can_authenticate(self):
"""
@summary: Checks if you can authenticate to the server
@return: True if you can connect, False otherwise
@rtype: bool
"""
return self.ssh_client.is_connected()
def get_hostname(self):
"""
@summary: Gets the host name of the server
@return: The host name of the server
@rtype: string
"""
return self.ssh_client.execute_command("hostname").stdout.rstrip()
def can_remote_ping_private_ip(self, private_addresses):
"""
@summary: Checks if you can ping a private ip from this server.
@param private_addresses: List of private addresses
@type private_addresses: Address List
@return: True if you can ping, False otherwise
@rtype: bool
"""
for private_address in private_addresses:
remote = PingClient.ping_using_remote_machine(
self.ssh_client, private_address.addr)
if private_address.version == 4 and not remote:
return False
return True
def get_files(self, path):
"""
@summary: Gets the list of filenames from the path
@param path: Path from where to get the filenames
@type path: string
@return: List of filenames
@rtype: List of strings
"""
command = "ls -m " + path
return self.ssh_client.execute_command(command).stdout.rstrip(
'\n').split(', ')
def get_ram_size_in_mb(self):
"""
@summary: Returns the RAM size in MB
@return: The RAM size in MB
@rtype: string
"""
output = self.ssh_client.execute_command('free -m | grep Mem').stdout
# TODO (dwalleck): We should handle the failure case here
if output:
return output.split()[1]
def get_swap_size_in_mb(self):
"""
@summary: Returns the Swap size in MB
@return: The Swap size in MB
@rtype: int
"""
output = self.ssh_client.execute_command(
'fdisk -l /dev/xvdc1 2>/dev/null | grep '
'"Disk.*bytes"').stdout.rstrip('\n')
if output:
return int(output.split()[2])
def get_disk_size_in_gb(self, disk_path):
"""
@summary: Returns the disk size in GB
@return: The disk size in GB
@rtype: int
"""
command = "df -h | grep '{0}'".format(disk_path)
output = self.ssh_client.execute_command(command).stdout
size = output.split()[1]
def is_decimal(char):
return str.isdigit(char) or char == "."
size = filter(is_decimal, size)
return float(size)
def get_number_of_vcpus(self):
"""
@summary: Get the number of vcpus assigned to the server
@return: The number of vcpus assigned to the server
@rtype: int
"""
command = 'cat /proc/cpuinfo | grep processor | wc -l'
output = self.ssh_client.execute_command(command).stdout
return int(output)
def get_partitions(self):
"""
@summary: Returns the contents of /proc/partitions
@return: The partitions attached to the instance
@rtype: string
"""
command = 'cat /proc/partitions'
output = self.ssh_client.execute_command(command).stdout
return output
def get_uptime(self):
"""
@summary: Get the uptime time of the server
@return: The uptime of the server
"""
result = self.ssh_client.execute_command('cat /proc/uptime').stdout
uptime = float(result.split(' ')[0])
return uptime
def create_file(self, file_name, file_content, file_path=None):
'''
@summary: Create a new file
@param file_name: File Name
@type file_name: String
@param file_content: File Content
@type file_content: String
@return filedetails: File details such as content, name and path
@rtype filedetails; FileDetails
'''
if file_path is None:
file_path = "/root/" + file_name
self.ssh_client.execute_command('echo -n ' + file_content + '>>' +
file_path)
return FileDetails("644", file_content, file_path)
def get_file_details(self, filepath):
"""
@summary: Get the file details
@param filepath: Path to the file
@type filepath: string
@return: File details including permissions and content
@rtype: FileDetails
"""
command = ('[ -f ' + filepath + ' ] && echo "File exists" || '
'echo "File does not exist"')
output = self.ssh_client.execute_command(command).stdout
if not output.rstrip('\n') == 'File exists':
raise FileNotFoundException("File:" + filepath +
" not found on instance.")
file_permissions = self.ssh_client.execute_command(
'stat -c %a ' + filepath).stdout.rstrip("\n")
file_contents = self.ssh_client.execute_command('cat ' +
filepath).stdout
return FileDetails(file_permissions, file_contents, filepath)
def is_file_present(self, filepath):
"""
@summary: Check if the given file is present
@param filepath: Path to the file
@type filepath: string
@return: True if File exists, False otherwise
"""
command = ('[ -f ' + filepath + ' ] && echo "File exists" || '
'echo "File does not exist"')
output = self.ssh_client.execute_command(command).stdout
return output.rstrip('\n') == 'File exists'
def get_partition_types(self):
"""
@summary: Return the partition types for all partitions
@return: The partition types for all partitions
@rtype: Dictionary
"""
partitions_list = self.ssh_client.execute_command(
'blkid').stdout.rstrip('\n').split('\n')
partition_types = {}
for row in partitions_list:
partition_name = row.split()[0].rstrip(':')
partition_types[partition_name] = re.findall(
r'TYPE="([^"]+)"', row)[0]
return partition_types
def get_partition_details(self):
"""
@summary: Return the partition details
@return: The partition details
@rtype: Partition List
"""
# Return a list of partition objects that each contains the name and
# size of the partition in bytes and the type of the partition
partition_types = self.get_partition_types()
partition_names = ' '.join(partition_types.keys())
partition_size_output = self.ssh_client.execute_command(
'fdisk -l %s 2>/dev/null | '
'grep "Disk.*bytes"' % partition_names).stdout
partition_size_output = partition_size_output.rstrip('\n').split('\n')
partitions = []
for row in partition_size_output:
row_details = row.split()
partition_name = row_details[1].rstrip(':')
partition_type = partition_types[partition_name]
if partition_type == 'swap':
partition_size = DiskSize(float(row_details[2]),
row_details[3].rstrip(','))
else:
partition_size = DiskSize(
int(row_details[4]) / 1073741824, 'GB')
partitions.append(
Partition(partition_name, partition_size, partition_type))
return partitions
def verify_partitions(self, expected_disk_size, expected_swap_size,
server_status, actual_partitions):
"""
@summary: Verify the partition details of the server
@param expected_disk_size: The expected value of the Disk size in GB
@type expected_disk_size: string
@param expected_swap_size: The expected value of the Swap size in GB
@type expected_swap_size: string
@param server_status: The status of the server
@type server_status: string
@param actual_partitions: The actual partition details of the server
@type actual_partitions: Partition List
@return: The result of verification and the message to be displayed
@rtype: Tuple (bool,string)
"""
expected_partitions = self._get_expected_partitions(
expected_disk_size, expected_swap_size, server_status)
if actual_partitions is None:
actual_partitions = self.get_partition_details()
for partition in expected_partitions:
if partition not in actual_partitions:
return False, self._construct_partition_mismatch_message(
expected_partitions, actual_partitions)
return True, "Partitions Matched"
def _get_expected_partitions(self, expected_disk_size, expected_swap_size,
server_status):
"""
@summary: Returns the expected partitions for a server based on status
@param expected_disk_size: The Expected disk size of the server in GB
@type expected_disk_size: string
@param expected_swap_size: The Expected swap size of the server in MB
@type expected_swap_size: string
@param server_status: Status of the server (ACTIVE or RESCUE)
@type server_status: string
@return: The expected partitions
@rtype: Partition List
"""
# ignoring swap untill the rescue functionality is clarified
expected_partitions = [
Partition('/dev/xvda1', DiskSize(expected_disk_size, 'GB'),
'ext3'),
Partition('/dev/xvdc1', DiskSize(expected_swap_size, 'MB'), 'swap')
]
if str.upper(server_status) == 'RESCUE':
expected_partitions = [
Partition('/dev/xvdb1', DiskSize(expected_disk_size, 'GB'),
'ext3')
]
# expected_partitions.append(Partition('/dev/xvdd1',
# DiskSize(expected_swap_size, 'MB'), 'swap'))
return expected_partitions
def _construct_partition_mismatch_message(self, expected_partitions,
actual_partitions):
"""
@summary: Constructs the partition mismatch message based on
expected_partitions and actual_partitions
@param expected_partitions: Expected partitions of the server
@type expected_partitions: Partition List
@param actual_partitions: Actual Partitions of the server
@type actual_partitions: Partition List
@return: The partition mismatch message
@rtype: string
"""
message = 'Partitions Mismatch \n Expected Partitions:\n'
for partition in expected_partitions:
message += str(partition) + '\n'
message += ' Actual Partitions:\n'
for partition in actual_partitions:
message += str(partition) + '\n'
return message
def mount_file_to_destination_directory(self, source_path,
destination_path):
'''
@summary: Mounts the file to destination directory
@param source_path: Path to file source
@type source_path: String
@param destination_path: Path to mount destination
@type destination_path: String
'''
self.ssh_client.execute_command('mount ' + source_path + ' ' +
destination_path)
def get_xen_user_metadata(self):
command = 'xenstore-ls vm-data/user-metadata'
output = self.ssh_client.execute_command(command).stdout
meta_list = output.split('\n')
meta = {}
for item in meta_list:
# Skip any blank lines
if item:
meta_item = item.split("=")
key = meta_item[0].strip()
value = meta_item[1].strip('" ')
meta[key] = value
return meta
def get_xenstore_disk_config_value(self):
"""Returns the xenstore value for disk config (True/False)"""
command = 'xenstore-read vm-data/auto-disk-config'
output = self.ssh_client.execute_command(command).stdout
return output.strip().lower() == 'true'
def create_directory(self, path):
'''
@summary: Creates Directory
@param path: Directory path
@type path: string
'''
command = "{0} {1}".format("mkdir -p", path)
output = self.ssh_client.execute_command(command).stdout
return output
def is_directory_present(self, directory_path):
'''
@summary: Check if directory is present
@param path: Path for the directory
@type path: string
'''
cmd_str = "{0} {1} {2} {3} {4}"
args = [
"[ -d", directory_path,
"] && echo 'Directory found' || echo 'Directory", directory_path,
"not found'"
]
command = cmd_str.format(*args)
output = self.ssh_client.execute_command(command)
return output.rstrip('\n') == 'Directory found'
def get_directory_details(self, dirpath):
"""
@summary: Get the directory details
@param direpath: Path to the directory
@type dirpath: string
@return: Directory details including permissions and content
@rtype: DirectoryDetails
"""
output = self.is_directory_present(dirpath)
if not output:
raise DirectoryNotFoundException(
"Directory: {0} not found.".format(dirpath))
dir_permissions = self.ssh_client.execute_command(
"stat -c %a {0}".format(dirpath)).stdout.rstrip("\n")
dir_size = float(
self.ssh_client.execute_command(
"du -s {0}".format(dirpath)).stdout.split('\t', 1)[0])
return DirectoryDetails(dir_permissions, dir_size, dirpath)
def get_block_devices(self):
disks_raw = self.ssh_client.execute_command('lsblk -dn').stdout
disks_raw_list = disks_raw.split('\n')
devices = []
for disk in disks_raw_list:
disk_params = disk.split()
if disk_params:
devices.append({
'name': disk_params[0],
'size': disk_params[3]
})
return devices
class LinuxClient(RemoteInstanceClient):
def __init__(self,
ip_address=None,
username='******',
password=None,
key=None,
connection_timeout=600,
retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
self.password = password
# Verify the server can be pinged before attempting to connect
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address)
if reachable:
break
time.sleep(retry_interval)
if int(time.time()) - start >= connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(username=self.username,
password=self.password,
host=self.ip_address,
tcp_timeout=20,
auth_strategy=auth_strategy,
look_for_keys=False,
key=key)
self.ssh_client.connect_with_timeout(cooldown=20,
timeout=connection_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(
message.format(timeout=connection_timeout,
ip_address=ip_address))
def can_authenticate(self):
"""
Verifies that a connection was made to the remote server
@return: Whether the connection was successful
@rtype: bool
"""
return self.ssh_client.is_connected()
def get_hostname(self):
"""
Gets the host name of the server
@return: The host name of the server
@rtype: string
"""
output = self.ssh_client.execute_command("hostname")
if output:
return output.stdout.rstrip()
def get_allocated_ram(self):
"""
Returns the amount of RAM the server has
@return: The RAM size in MB
@rtype: string
"""
output = self.ssh_client.execute_command('free -m | grep Mem')
if output:
return output.stdout.split()[1]
def get_disk_size(self, disk_path):
"""
Returns the size of a given disk
@return: The disk size in GB
@rtype: int
"""
disks = self.get_all_disks()
return disks.get(disk_path)
def get_number_of_cpus(self):
"""
Return the number of CPUs assigned to the server
@return: The number of CPUs a server has
@rtype: int
"""
command = 'cat /proc/cpuinfo | grep processor | wc -l'
output = self.ssh_client.execute_command(command)
if output:
return int(output.stdout)
def get_uptime(self):
"""
Get the uptime time of the server.
@return: The uptime of the server in seconds
@rtype: int
"""
result = self.ssh_client.execute_command('cat /proc/uptime')
if result:
uptime = float(result.stdout.split(' ')[0])
return uptime
def create_file(self, file_name, file_content, file_path=None):
"""
Creates a new file with the provided content.
@param file_name: File name
@type file_name: string
@param file_content: File content
@type file_content: String
@rtype: FileDetails
"""
if file_path is None:
file_path = "/root/{file_name}".format(file_name=file_name)
self.ssh_client.execute_command(
'echo -n {file_content} >> {file_path}'.format(
file_content=file_content, file_name=file_name))
return FileDetails("644", file_content, file_path)
def get_file_details(self, file_path):
"""
Retrieves the contents of a file and its permissions.
@param file_path: Path to the file
@type file_path: string
@return: File details including permissions and content
@rtype: FileDetails
"""
command = ('[ -f {file_path} ] && echo "File exists" || '
'echo "File does not exist"'.format(file_path=file_path))
output = self.ssh_client.execute_command(command)
if output is None:
return None
output = output.stdout
if not output.rstrip('\n') == 'File exists':
raise FileNotFoundException(
"File {file_path} not found on instance.".format(
file_path=file_path))
file_permissions = self.ssh_client.execute_command(
'stat -c %a {file_path}'.format(
file_path=file_path)).stdout.rstrip("\n")
file_contents = self.ssh_client.execute_command(
'cat {file_path}'.format(file_path=file_path)).stdout
return FileDetails(file_permissions, file_contents, file_path)
def is_file_present(self, file_path):
"""
Verifies if the given file is present.
@param file_path: Path to the file
@type file_path: string
@return: True if File exists, False otherwise
@rtype: bool
"""
command = ('[ -f {file_path} ] && echo "File exists" || '
'echo "File does not exist"'.format(file_path=file_path))
output = self.ssh_client.execute_command(command).stdout
if output:
return output.rstrip('\n') == 'File exists'
def mount_disk(self, source_path, destination_path):
"""
Mounts a disk to specified destination.
@param source_path: Path to file source
@type source_path: string
@param destination_path: Path to mount destination
@type destination_path: string
"""
self.ssh_client.execute_command(
'mount {source_path} {destination_path}'.format(
source_path=source_path, destination_path=destination_path))
def unmount_disk(self, disk_path):
"""
Unmounts the disk at the specified location.
@param disk_path: Path to file source
@type disk_path: string
"""
self.ssh_client.execute_command(
'umount {disk_path}'.format(disk_path=disk_path))
def get_xen_user_metadata(self):
"""
Retrieves the user-metadata section from the XenStore.
@return: The contents of the user-metadata
@rtype: dict
"""
command = 'xenstore-ls vm-data/user-metadata'
output = self.ssh_client.execute_command(command)
if not output:
return None
output = output.stdout
meta_list = output.split('\n')
meta = {}
for item in meta_list:
# Skip any blank lines
if item:
meta_item = item.split("=")
key = meta_item[0].strip()
value = meta_item[1].strip('" ')
meta[key] = value
return meta
def get_xenstore_disk_config_value(self):
"""
Returns the XenStore value for disk config.
@return: Whether the virtual machine uses auto disk config
@rtype: bool
"""
command = 'xenstore-read vm-data/auto-disk-config'
output = self.ssh_client.execute_command(command)
if output is None:
return None
output = output.stdout
return output.strip().lower() == 'true'
def create_directory(self, path):
"""
Creates a directory at the specified path.
@param path: Directory path
@type path: string
"""
command = "mkdir -p {path}".format(path=path)
output = self.ssh_client.execute_command(command)
if output is None:
return None
return output.stdout
def is_directory_present(self, directory_path):
"""
Check if given directory exists.
@param directory_path: Path to the directory
@type directory_path: string
@return: Result of directory check
@rtype: bool
"""
command = ("[ -d {path} ] && echo 'Directory found'"
"|| echo 'Directory {path} not found'".format(
path=directory_path))
output = self.ssh_client.execute_command(command)
if output is None:
return None
output = output.stdout
return output.rstrip('\n') == 'Directory found'
def get_directory_details(self, dir_path):
"""
Retrieves informational data about a directory.
@param dir_path: Path to the directory
@type dir_path: string
@return: Directory details
@rtype: DirectoryDetails
"""
output = self.is_directory_present(dir_path)
if output is None:
raise DirectoryNotFoundException(
"Directory: {0} not found.".format(dir_path))
dir_permissions = self.ssh_client.execute_command(
"stat -c %a {0}".format(dir_path)).stdout.rstrip("\n")
dir_size = float(
self.ssh_client.execute_command(
"du -s {0}".format(dir_path)).stdout.split('\t', 1)[0])
return DirectoryDetails(dir_permissions, dir_size, dir_path)
def get_all_disks(self):
"""
Returns a list of all block devices for a server.
@return: The accessible block devices
@rtype: dict
"""
disks_raw = self.ssh_client.execute_command('fdisk -l')
if disks_raw is None:
return None
disks_raw = disks_raw.stdout
p = re.compile('Disk /dev/\w+: \d+.*')
disks_list = p.findall(disks_raw)
disks = {}
for disk in disks_list:
items = disk.split()
disk_name = items[1].replace(':', '')
size = int(items[4]) / (1 << 30)
disks[disk_name] = size
return disks
def format_disk(self, disk, filesystem_type):
"""
Formats a disk to the provided filesystem type.
@param disk: The path to the disk to be formatted
@type disk: string
@param filesystem_type: The filesystem type to format the disk to
@type filesystem_type: string
@return: Output of command execution
@rtype: string
"""
out = self.ssh_client.execute_command('mkfs -t {type} {disk}'.format(
type=filesystem_type, disk=disk))
if out is None:
return None
return out.stdout
class LinuxClient(BaseClient):
def __init__(self, ip_address=None, server_id=None, username=None,
password=None, config=None, os_distro=None, key=None):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
ssh_timeout = config.connection_timeout
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
if self.username is None:
self.username = '******'
self.password = password
self.server_id = server_id
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address,
config.ip_address_version_for_ssh)
time.sleep(config.connection_retry_interval)
if int(time.time()) - start >= config.connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(
username=self.username, password=self.password,
host=self.ip_address, tcp_timeout=20, auth_strategy=auth_strategy,
look_for_keys=False, key=key)
self.ssh_client.connect_with_timeout(cooldown=20, timeout=ssh_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(message.format(
timeout=ssh_timeout, ip_address=ip_address))
def can_connect_to_public_ip(self):
"""
@summary: Checks if you can connect to server using public ip
@return: True if you can connect, False otherwise
@rtype: bool
"""
# This returns true since the connection has already been tested in the
# init method
return self.ssh_client is not None
def can_ping_public_ip(self, public_addresses, ip_address_version_for_ssh):
"""
@summary: Checks if you can ping a public ip
@param addresses: List of public addresses
@type addresses: Address List
@return: True if you can ping, False otherwise
@rtype: bool
"""
for public_address in public_addresses:
if public_address.version == 4 and not PingClient.ping(
public_address.addr, ip_address_version_for_ssh):
return False
return True
def can_authenticate(self):
"""
@summary: Checks if you can authenticate to the server
@return: True if you can connect, False otherwise
@rtype: bool
"""
return self.ssh_client.is_connected()
def get_hostname(self):
"""
@summary: Gets the host name of the server
@return: The host name of the server
@rtype: string
"""
return self.ssh_client.execute_command("hostname").stdout.rstrip()
def can_remote_ping_private_ip(self, private_addresses):
"""
@summary: Checks if you can ping a private ip from this server.
@param private_addresses: List of private addresses
@type private_addresses: Address List
@return: True if you can ping, False otherwise
@rtype: bool
"""
for private_address in private_addresses:
remote = PingClient.ping_using_remote_machine(self.ssh_client,
private_address.addr)
if private_address.version == 4 and not remote:
return False
return True
def get_files(self, path):
"""
@summary: Gets the list of filenames from the path
@param path: Path from where to get the filenames
@type path: string
@return: List of filenames
@rtype: List of strings
"""
command = "ls -m " + path
return self.ssh_client.execute_command(
command).stdout.rstrip('\n').split(', ')
def get_ram_size_in_mb(self):
"""
@summary: Returns the RAM size in MB
@return: The RAM size in MB
@rtype: string
"""
output = self.ssh_client.execute_command('free -m | grep Mem').stdout
# TODO (dwalleck): We should handle the failure case here
if output:
return output.split()[1]
def get_swap_size_in_mb(self):
"""
@summary: Returns the Swap size in MB
@return: The Swap size in MB
@rtype: int
"""
output = self.ssh_client.execute_command(
'fdisk -l /dev/xvdc1 2>/dev/null | grep '
'"Disk.*bytes"').stdout.rstrip('\n')
if output:
return int(output.split()[2])
def get_disk_size_in_gb(self, disk_path):
"""
@summary: Returns the disk size in GB
@return: The disk size in GB
@rtype: int
"""
command = "df -h | grep '{0}'".format(disk_path)
output = self.ssh_client.execute_command(command).stdout
size = output.split()[1]
def is_decimal(char):
return str.isdigit(char) or char == "."
size = list(filter(is_decimal, size))
return float(size)
def get_number_of_vcpus(self):
"""
@summary: Get the number of vcpus assigned to the server
@return: The number of vcpus assigned to the server
@rtype: int
"""
command = 'cat /proc/cpuinfo | grep processor | wc -l'
output = self.ssh_client.execute_command(command).stdout
return int(output)
def get_partitions(self):
"""
@summary: Returns the contents of /proc/partitions
@return: The partitions attached to the instance
@rtype: string
"""
command = 'cat /proc/partitions'
output = self.ssh_client.execute_command(command).stdout
return output
def get_uptime(self):
"""
@summary: Get the uptime time of the server
@return: The uptime of the server
"""
result = self.ssh_client.execute_command('cat /proc/uptime').stdout
uptime = float(result.split(' ')[0])
return uptime
def create_file(self, file_name, file_content, file_path=None):
'''
@summary: Create a new file
@param file_name: File Name
@type file_name: String
@param file_content: File Content
@type file_content: String
@return filedetails: File details such as content, name and path
@rtype filedetails; FileDetails
'''
if file_path is None:
file_path = "/root/" + file_name
self.ssh_client.execute_command(
'echo -n ' + file_content + '>>' + file_path)
return FileDetails("644", file_content, file_path)
def get_file_details(self, filepath):
"""
@summary: Get the file details
@param filepath: Path to the file
@type filepath: string
@return: File details including permissions and content
@rtype: FileDetails
"""
command = ('[ -f ' + filepath + ' ] && echo "File exists" || '
'echo "File does not exist"')
output = self.ssh_client.execute_command(command).stdout
if not output.rstrip('\n') == 'File exists':
raise FileNotFoundException(
"File:" + filepath + " not found on instance.")
file_permissions = self.ssh_client.execute_command(
'stat -c %a ' + filepath).stdout.rstrip("\n")
file_contents = self.ssh_client.execute_command(
'cat ' + filepath).stdout
return FileDetails(file_permissions, file_contents, filepath)
def is_file_present(self, filepath):
"""
@summary: Check if the given file is present
@param filepath: Path to the file
@type filepath: string
@return: True if File exists, False otherwise
"""
command = ('[ -f ' + filepath + ' ] && echo "File exists" || '
'echo "File does not exist"')
output = self.ssh_client.execute_command(command).stdout
return output.rstrip('\n') == 'File exists'
def get_partition_types(self):
"""
@summary: Return the partition types for all partitions
@return: The partition types for all partitions
@rtype: Dictionary
"""
partitions_list = self.ssh_client.execute_command(
'blkid').stdout.rstrip('\n').split('\n')
partition_types = {}
for row in partitions_list:
partition_name = row.split()[0].rstrip(':')
partition_types[partition_name] = re.findall(
r'TYPE="([^"]+)"', row)[0]
return partition_types
def get_partition_details(self):
"""
@summary: Return the partition details
@return: The partition details
@rtype: Partition List
"""
# Return a list of partition objects that each contains the name and
# size of the partition in bytes and the type of the partition
partition_types = self.get_partition_types()
partition_names = ' '.join(list(partition_types.keys()))
partition_size_output = self.ssh_client.execute_command(
'fdisk -l %s 2>/dev/null | '
'grep "Disk.*bytes"' % partition_names).stdout
partition_size_output = partition_size_output.rstrip('\n').split('\n')
partitions = []
for row in partition_size_output:
row_details = row.split()
partition_name = row_details[1].rstrip(':')
partition_type = partition_types[partition_name]
if partition_type == 'swap':
partition_size = DiskSize(
float(row_details[2]), row_details[3].rstrip(','))
else:
partition_size = DiskSize(
int(row_details[4]) / 1073741824, 'GB')
partitions.append(
Partition(partition_name, partition_size, partition_type))
return partitions
def verify_partitions(self, expected_disk_size, expected_swap_size,
server_status, actual_partitions):
"""
@summary: Verify the partition details of the server
@param expected_disk_size: The expected value of the Disk size in GB
@type expected_disk_size: string
@param expected_swap_size: The expected value of the Swap size in GB
@type expected_swap_size: string
@param server_status: The status of the server
@type server_status: string
@param actual_partitions: The actual partition details of the server
@type actual_partitions: Partition List
@return: The result of verification and the message to be displayed
@rtype: Tuple (bool,string)
"""
expected_partitions = self._get_expected_partitions(
expected_disk_size, expected_swap_size, server_status)
if actual_partitions is None:
actual_partitions = self.get_partition_details()
for partition in expected_partitions:
if partition not in actual_partitions:
return False, self._construct_partition_mismatch_message(
expected_partitions, actual_partitions)
return True, "Partitions Matched"
def _get_expected_partitions(self, expected_disk_size, expected_swap_size,
server_status):
"""
@summary: Returns the expected partitions for a server based on status
@param expected_disk_size: The Expected disk size of the server in GB
@type expected_disk_size: string
@param expected_swap_size: The Expected swap size of the server in MB
@type expected_swap_size: string
@param server_status: Status of the server (ACTIVE or RESCUE)
@type server_status: string
@return: The expected partitions
@rtype: Partition List
"""
# ignoring swap untill the rescue functionality is clarified
expected_partitions = [Partition('/dev/xvda1',
DiskSize(expected_disk_size, 'GB'),
'ext3'),
Partition('/dev/xvdc1',
DiskSize(expected_swap_size, 'MB'),
'swap')]
if str.upper(server_status) == 'RESCUE':
expected_partitions = [Partition(
'/dev/xvdb1', DiskSize(expected_disk_size, 'GB'), 'ext3')]
# expected_partitions.append(Partition('/dev/xvdd1',
# DiskSize(expected_swap_size, 'MB'), 'swap'))
return expected_partitions
def _construct_partition_mismatch_message(self, expected_partitions,
actual_partitions):
"""
@summary: Constructs the partition mismatch message based on
expected_partitions and actual_partitions
@param expected_partitions: Expected partitions of the server
@type expected_partitions: Partition List
@param actual_partitions: Actual Partitions of the server
@type actual_partitions: Partition List
@return: The partition mismatch message
@rtype: string
"""
message = 'Partitions Mismatch \n Expected Partitions:\n'
for partition in expected_partitions:
message += str(partition) + '\n'
message += ' Actual Partitions:\n'
for partition in actual_partitions:
message += str(partition) + '\n'
return message
def mount_file_to_destination_directory(self, source_path,
destination_path):
'''
@summary: Mounts the file to destination directory
@param source_path: Path to file source
@type source_path: String
@param destination_path: Path to mount destination
@type destination_path: String
'''
self.ssh_client.execute_command(
'mount ' + source_path + ' ' + destination_path)
def get_xen_user_metadata(self):
command = 'xenstore-ls vm-data/user-metadata'
output = self.ssh_client.execute_command(command).stdout
meta_list = output.split('\n')
meta = {}
for item in meta_list:
# Skip any blank lines
if item:
meta_item = item.split("=")
key = meta_item[0].strip()
value = meta_item[1].strip('" ')
meta[key] = value
return meta
def get_xenstore_disk_config_value(self):
"""Returns the xenstore value for disk config (True/False)"""
command = 'xenstore-read vm-data/auto-disk-config'
output = self.ssh_client.execute_command(command).stdout
return output.strip().lower() == 'true'
def create_directory(self, path):
'''
@summary: Creates Directory
@param path: Directory path
@type path: string
'''
command = "{0} {1}".format("mkdir -p", path)
output = self.ssh_client.execute_command(command).stdout
return output
def is_directory_present(self, directory_path):
'''
@summary: Check if directory is present
@param path: Path for the directory
@type path: string
'''
cmd_str = "{0} {1} {2} {3} {4}"
args = ["[ -d",
directory_path,
"] && echo 'Directory found' || echo 'Directory",
directory_path, "not found'"]
command = cmd_str.format(*args)
output = self.ssh_client.execute_command(command)
return output.rstrip('\n') == 'Directory found'
def get_directory_details(self, dirpath):
"""
@summary: Get the directory details
@param direpath: Path to the directory
@type dirpath: string
@return: Directory details including permissions and content
@rtype: DirectoryDetails
"""
output = self.is_directory_present(dirpath)
if not output:
raise DirectoryNotFoundException(
"Directory: {0} not found.".format(dirpath))
dir_permissions = self.ssh_client.execute_command(
"stat -c %a {0}".format(dirpath)).stdout.rstrip("\n")
dir_size = float(self.ssh_client.execute_command(
"du -s {0}".format(dirpath)).stdout.split('\t', 1)[0])
return DirectoryDetails(dir_permissions, dir_size, dirpath)
def get_block_devices(self):
disks_raw = self.ssh_client.execute_command('lsblk -dn').stdout
disks_raw_list = disks_raw.split('\n')
devices = []
for disk in disks_raw_list:
disk_params = disk.split()
if disk_params:
devices.append({'name': disk_params[0],
'size': disk_params[3]})
return devices
class LinuxClient(RemoteInstanceClient):
def __init__(self, ip_address=None, username='******', password=None,
key=None, connection_timeout=600, retry_interval=10):
self.client_log = cclogging.getLogger(
cclogging.get_object_namespace(self.__class__))
if ip_address is None:
raise ServerUnreachable("None")
self.ip_address = ip_address
self.username = username
self.password = password
# Verify the server can be pinged before attempting to connect
start = int(time.time())
reachable = False
while not reachable:
reachable = PingClient.ping(ip_address)
if reachable:
break
time.sleep(retry_interval)
if int(time.time()) - start >= connection_timeout:
raise ServerUnreachable(ip_address)
if key is not None:
auth_strategy = SSHAuthStrategy.KEY_STRING
else:
auth_strategy = SSHAuthStrategy.PASSWORD
self.ssh_client = SSHBehaviors(
username=self.username, password=self.password,
host=self.ip_address, tcp_timeout=20, auth_strategy=auth_strategy,
look_for_keys=False, key=key)
self.ssh_client.connect_with_timeout(
cooldown=20, timeout=connection_timeout)
if not self.ssh_client.is_connected():
message = ('SSH timeout after {timeout} seconds: '
'Could not connect to {ip_address}.')
raise SshConnectionException(message.format(
timeout=connection_timeout, ip_address=ip_address))
def can_authenticate(self):
"""
Verifies that a connection was made to the remote server
@return: Whether the connection was successful
@rtype: bool
"""
return self.ssh_client.is_connected()
def get_hostname(self):
"""
Gets the host name of the server
@return: The host name of the server
@rtype: string
"""
output = self.ssh_client.execute_command("hostname")
if output:
return output.stdout.rstrip()
def get_allocated_ram(self):
"""
Returns the amount of RAM the server has
@return: The RAM size in MB
@rtype: string
"""
output = self.ssh_client.execute_command('free -m | grep Mem')
if output:
return output.stdout.split()[1]
def get_disk_size(self, disk_path):
"""
Returns the size of a given disk
@return: The disk size in GB
@rtype: int
"""
disks = self.get_all_disks()
return disks.get(disk_path)
def get_number_of_cpus(self):
"""
Return the number of CPUs assigned to the server
@return: The number of CPUs a server has
@rtype: int
"""
command = 'cat /proc/cpuinfo | grep processor | wc -l'
output = self.ssh_client.execute_command(command)
if output:
return int(output.stdout)
def get_uptime(self):
"""
Get the uptime time of the server.
@return: The uptime of the server in seconds
@rtype: int
"""
result = self.ssh_client.execute_command('cat /proc/uptime')
if result:
uptime = float(result.stdout.split(' ')[0])
return uptime
def create_file(self, file_name, file_content, file_path=None):
"""
Creates a new file with the provided content.
@param file_name: File name
@type file_name: string
@param file_content: File content
@type file_content: String
@rtype: FileDetails
"""
if file_path is None:
file_path = "/root/{file_name}".format(file_name=file_name)
self.ssh_client.execute_command(
'echo -n {file_content} >> {file_path}'.format(
file_content=file_content, file_name=file_name))
return FileDetails("644", file_content, file_path)
def get_file_details(self, file_path):
"""
Retrieves the contents of a file and its permissions.
@param file_path: Path to the file
@type file_path: string
@return: File details including permissions and content
@rtype: FileDetails
"""
command = ('[ -f {file_path} ] && echo "File exists" || '
'echo "File does not exist"'.format(file_path=file_path))
output = self.ssh_client.execute_command(command)
if output is None:
return None
output = output.stdout
if not output.rstrip('\n') == 'File exists':
raise FileNotFoundException(
"File {file_path} not found on instance.".format(
file_path=file_path))
file_permissions = self.ssh_client.execute_command(
'stat -c %a {file_path}'.format(
file_path=file_path)).stdout.rstrip("\n")
file_contents = self.ssh_client.execute_command(
'cat {file_path}'.format(file_path=file_path)).stdout
return FileDetails(file_permissions, file_contents, file_path)
def is_file_present(self, file_path):
"""
Verifies if the given file is present.
@param file_path: Path to the file
@type file_path: string
@return: True if File exists, False otherwise
@rtype: bool
"""
command = ('[ -f {file_path} ] && echo "File exists" || '
'echo "File does not exist"'.format(file_path=file_path))
output = self.ssh_client.execute_command(command).stdout
if output:
return output.rstrip('\n') == 'File exists'
def mount_disk(self, source_path, destination_path):
"""
Mounts a disk to specified destination.
@param source_path: Path to file source
@type source_path: string
@param destination_path: Path to mount destination
@type destination_path: string
"""
self.ssh_client.execute_command(
'mount {source_path} {destination_path}'.format(
source_path=source_path, destination_path=destination_path))
def unmount_disk(self, disk_path):
"""
Unmounts the disk at the specified location.
@param disk_path: Path to file source
@type disk_path: string
"""
self.ssh_client.execute_command(
'umount {disk_path}'.format(disk_path=disk_path))
def get_xen_user_metadata(self):
"""
Retrieves the user-metadata section from the XenStore.
@return: The contents of the user-metadata
@rtype: dict
"""
command = 'xenstore-ls vm-data/user-metadata'
output = self.ssh_client.execute_command(command)
if not output:
return None
output = output.stdout
meta_list = output.split('\n')
meta = {}
for item in meta_list:
# Skip any blank lines
if item:
meta_item = item.split("=")
key = meta_item[0].strip()
value = meta_item[1].strip('" ')
meta[key] = value
return meta
def get_xenstore_disk_config_value(self):
"""
Returns the XenStore value for disk config.
@return: Whether the virtual machine uses auto disk config
@rtype: bool
"""
command = 'xenstore-read vm-data/auto-disk-config'
output = self.ssh_client.execute_command(command)
if output is None:
return None
output = output.stdout
return output.strip().lower() == 'true'
def create_directory(self, path):
"""
Creates a directory at the specified path.
@param path: Directory path
@type path: string
"""
command = "mkdir -p {path}".format(path=path)
output = self.ssh_client.execute_command(command)
if output is None:
return None
return output.stdout
def is_directory_present(self, directory_path):
"""
Check if given directory exists.
@param directory_path: Path to the directory
@type directory_path: string
@return: Result of directory check
@rtype: bool
"""
command = ("[ -d {path} ] && echo 'Directory found'"
"|| echo 'Directory {path} not found'".format(
path=directory_path))
output = self.ssh_client.execute_command(command)
if output is None:
return None
output = output.stdout
return output.rstrip('\n') == 'Directory found'
def get_directory_details(self, dir_path):
"""
Retrieves informational data about a directory.
@param dir_path: Path to the directory
@type dir_path: string
@return: Directory details
@rtype: DirectoryDetails
"""
output = self.is_directory_present(dir_path)
if output is None:
raise DirectoryNotFoundException(
"Directory: {0} not found.".format(dir_path))
dir_permissions = self.ssh_client.execute_command(
"stat -c %a {0}".format(dir_path)).stdout.rstrip("\n")
dir_size = float(self.ssh_client.execute_command(
"du -s {0}".format(dir_path)).stdout.split('\t', 1)[0])
return DirectoryDetails(dir_permissions, dir_size, dir_path)
def get_all_disks(self):
"""
Returns a list of all block devices for a server.
@return: The accessible block devices
@rtype: dict
"""
disks_raw = self.ssh_client.execute_command('fdisk -l')
if disks_raw is None:
return None
disks_raw = disks_raw.stdout
p = re.compile('Disk /dev/\w+: \d+.*')
disks_list = p.findall(disks_raw)
disks = {}
for disk in disks_list:
items = disk.split()
disk_name = items[1].replace(':', '')
size = int(items[4])/(1 << 30)
disks[disk_name] = size
return disks
def format_disk(self, disk, filesystem_type):
"""
Formats a disk to the provided filesystem type.
@param disk: The path to the disk to be formatted
@type disk: string
@param filesystem_type: The filesystem type to format the disk to
@type filesystem_type: string
@return: Output of command execution
@rtype: string
"""
out = self.ssh_client.execute_command('mkfs -t {type} {disk}'.format(
type=filesystem_type, disk=disk))
if out is None:
return None
return out.stdout
