def server_diff(hostA, hostB, source_file, remote_path):
global OverthereHostSession
global OperatingSystemFamily
global LocalConnectionOptions
global ObertherHostSession
global StringUtils
global Diff
#context.logOutput(remote_path)
localOpts = LocalConnectionOptions(os=OperatingSystemFamily.UNIX)
local_session = OverthereHostSession(OverthereHost(localOpts))
sessionA = OverthereHostSession(hostA)
sessionB = OverthereHostSession(hostB)
try:
d1 = sessionA.remote_file(remote_path)
local_d1 = local_session.work_dir_file("hostA")
local_session.copy_to(d1, local_d1)
myFile = "%s" % (local_d1)
local_f1 = myFile.split(':')[1]
d2 = sessionB.remote_file(remote_path)
local_d2 = local_session.work_dir_file("hostB")
local_session.copy_to(d2, local_d2)
myFile = "%s" % (local_d2)
local_f2 = myFile.split(':')[1]
response = local_session.execute("diff %s %s" % (local_f1, local_f2), check_success=False)
finally:
sessionA.close_conn()
sessionB.close_conn()
local_session.close_conn()
# End try
return response.stdout
def server_diff(hostA, hostB, source_file, remote_path):
global OverthereHostSession
global OperatingSystemFamily
global LocalConnectionOptions
global ObertherHostSession
global StringUtils
global Diff
#context.logOutput(remote_path)
localOpts = LocalConnectionOptions(os=OperatingSystemFamily.UNIX)
local_session = OverthereHostSession(OverthereHost(localOpts))
sessionA = OverthereHostSession(hostA)
sessionB = OverthereHostSession(hostB)
try:
d1 = sessionA.remote_file(remote_path)
local_d1 = local_session.work_dir_file("hostA")
local_session.copy_to(d1, local_d1)
myFile = "%s" % (local_d1)
local_f1 = myFile.split(':')[1]
d2 = sessionB.remote_file(remote_path)
local_d2 = local_session.work_dir_file("hostB")
local_session.copy_to(d2, local_d2)
myFile = "%s" % (local_d2)
local_f2 = myFile.split(':')[1]
response = local_session.execute("diff %s %s" % (local_f1, local_f2),
check_success=False)
finally:
sessionA.close_conn()
sessionB.close_conn()
local_session.close_conn()
# End try
return response.stdout
class UnixBuildServer(object):
def __init__(self, server):
self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],password=server['password'])
self.host = OverthereHost(self.sshOpts)
self.session = OverthereHostSession(self.host)
self.base_working_directory = server['BaseWorkingDirectory']
self.working_directory = self.base_working_directory
self.create_working_directory(self.base_working_directory)
workDir = self.session.remote_file(self.base_working_directory)
self.session.get_conn().setWorkingDirectory(workDir)
@staticmethod
def createServer(server):
return UnixBuildServer(server)
def set_working_directory(self, relative_directory_path):
self.working_directory = "%s/%s" % (self.base_working_directory, relative_directory_path)
self.create_working_directory(self.working_directory)
workDir = self.session.remote_file(self.working_directory)
self.session.get_conn().setWorkingDirectory(workDir)
# main interface
# session related methods
def close_session(selfs):
self.session.close()
def create_working_directory(self, dir_full_path):
response = self.session.execute("/bin/mkdir -p %s" % (dir_full_path))
# File Handeling
def read_file_in_workspace(self, file_name):
print "not yet implemented"
def write_file_in_workspace(self, file_name, content):
print "not yet implemented"
def create_directory(self, directory_name):
self.execute_command(["/bin/mkdir -p %s" % (directory_name)])
# command Execution
def filename_generator(self, size=9, chars=string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
def get_tmp_script_filename(self):
return "%s.sh" % self.filename_generator()
def execute_command(self, command, environment_variables=None):
# get a BashScriptBuilder object
command_object = BashScriptBuilder()
# copy in the environment variables
if environment_variables is not None:
for key, value in environment_variables.items():
command_object.set_env_var(key, value)
# add the rest of the possible multiline command
command_object.add_lines(command)
executable_command = command_object.build()
print "executing command: %s " % (executable_command)
tmp_script_filename = self.get_tmp_script_filename()
self.session.upload_text_content_to_work_dir(command_object.build(), tmp_script_filename, executable=True)
#
response = self.session.execute("%s/%s" % (self.working_directory, tmp_script_filename), check_success=False, suppress_streaming_output=False)
if response.rc != 0:
print response.stderr
print response.stdout
print "unable to execute command %s" % (command)
raise Exception('unable to execute command')
else:
print "Response:", str(response.stdout)
return response
class DarBuildServer(object):
def __init__(self, server):
self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],password=server['password'])
self.host = OverthereHost(self.sshOpts)
self.session = OverthereHostSession(self.host)
self.zipBinary = server['pathToZipExecutable']
self.workingDirectory = server['workingDirectory']
self.create_directory(self.workingDirectory)
workDir = self.session.remote_file(self.workingDirectory)
self.session.get_conn().setWorkingDirectory(workDir)
def __del__(self):
self.destroy_work_directory()
self.session.close_conn()
@staticmethod
def createServer(server):
return DarBuildServer(server)
#
def init_dar(self, appName, appVersion):
workspace_root = self.create_dar_directory(appName, appVersion)
manifest_filename = "%s/deployit-manifest.xml" % workspace_root
self.write_dar_manifest(appName, appVersion, workspace_root)
def import_ear(self, appName, appVersion, deployable, url):
self.download_file_into_dar(appName, appVersion,deployable, str(url))
def create_dar_directory(self, appName, appVersion):
dirName = "%s/%s" % (appVersion, appName)
# check if the directory exists .. if it does we should go do something else.
# might want to do a better locking mechanism
if self.dir_exists(dirName):
print "unable to create dar directory: %s/%s/%s" % (self.workingDirectory, appVersion, appName)
raise Exception('unable to create Dar Package Directory')
else:
self.create_directory(dirName)
return dirName
def download_file_into_dar(self, appName, appVersion, deployable, url):
#filename = url.split('/')[-1]
filename = os.path.basename(url)
outfile = "%s/%s/%s/%s" % (appVersion, appName,deployable, filename)
dirName = "%s/%s/%s" % (appVersion, appName,deployable)
if self.dir_exists(dirName):
print "output dir already exists: %s" % (dirName)
else:
self.create_directory(dirName)
self.execute_command("/usr/bin/curl -L -o %s %s" % (outfile, url))
def read_manifest(self, appName, appVersion):
file_name = "%s/%s/%s/deployit-manifest.xml" % (self.workingDirectory, appVersion, appName)
return self.session.read_file(file_name, encoding="UTF-8")
def write_manifest(self, appName, appVersion, content):
file_name = "%s/%s/deployit-manifest.xml" % (appVersion, appName)
self.write_to_file(file_name, content)
def create_directory(self, dirName):
self.execute_command("/bin/mkdir -p %s" % (dirName))
def create_file(self, fileName, content=None):
if content:
self.write_to_file(fileName, str(content))
else:
self.execute_command("/bin/touch %s" % (fileName))
def write_to_file(self, fileName, content):
remoteFile = self.session.remote_file("%s/%s" % (self.workingDirectory, fileName))
self.session.copy_text_to_file(str(content), remoteFile)
def dir_exists(self, dirName):
print dirName
command = "[ -d %s ]" % (dirName)
response = self.session.execute(command, check_success=False, suppress_streaming_output=False)
if response.rc == 0 :
return True
else:
return False
def execute_command(self, command):
print "executing command: %s " % (command)
response = self.session.execute(command, check_success=False, suppress_streaming_output=False)
if response.rc != 0:
print response.stderr
print "unable to execute command %s" % (command)
raise Exception('unable to execute command ')
else:
print "Response:", str(response.stdout)
# self.switch_working_directory()
return response
def write_dar_manifest(self, appName, appVersion, workspace_root):
filename = "./%s/deployit-manifest.xml" % (workspace_root)
file_content = self.basic_dar_manifest_template().substitute(appVersion=appVersion, appName=appName)
self.create_file(filename, file_content)
def basic_dar_manifest_template(self):
xml_template = '<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n'
xml_template += ' <udm.DeploymentPackage version=\"$appVersion\" application=\"$appName\"> \n'
xml_template += ' <orchestrator /> \n'
xml_template += ' <deployables/> \n'
xml_template += ' </udm.DeploymentPackage> \n'
return Template(xml_template)
def package_dar(self, appName, appVersion):
command = "if [ -f %s_%s.dar ] \n"
command += " then rm -rf %s_%s.dar \n"
command += "fi \n"
command += "cd %s/%s \n" % (appVersion, appName)
command += "/usr/bin/zip -r %s/%s_%s.dar *" % (self.workingDirectory, appName, appVersion.replace('.','_'))
self.execute_multiline_command(command)
def write_exec_script(self, commands, script):
self.session.upload_text_content_to_work_dir(self, commands, script, executable=False)
def execute_multiline_command(self, command):
tmp_filename = self.filename_generator()
self.write_to_file(tmp_filename, command)
self.execute_command("chmod +x %s" % (tmp_filename))
self.execute_command("./%s" % (tmp_filename))
def filename_generator(self, size=9, chars=string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
def upload_dar_package(self, appName, appVersion, xldeployServer):
dar_file_name = "%s_%s.dar" % (appName, appVersion.replace('.','_'))
command = "/usr/bin/curl -u %s:%s -X POST -H \"content-type:multipart/form-data\" %s/package/upload/%s -F fileData=@./%s " % (xldeployServer['username'], xldeployServer['password'], xldeployServer['url'], dar_file_name, dar_file_name)
print command
self.execute_command(command)
class ConfigRTCServer(object):
def __init__(self, server, dirname="tmp", work_directory=None):
# if 'key_file' in server:
# self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],privateKeyFile=server['key_file'])
# else:
# self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],password=server['password'])
self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],privateKeyFile=server['key_file'],password=server['password'] )
self.host = OverthereHost(self.sshOpts)
self.session = OverthereHostSession(self.host)
self.WorkDirBase = server['filesystemLocation']
self.session.execute("/bin/mkdir -p %s" % (self.WorkDirBase))
workDir = self.session.remote_file(self.WorkDirBase)
self.session.get_conn().setWorkingDirectory(workDir)
if work_directory is None:
self.WorkDirTimeStamp = int(time.time())
self.WorkDirName = dirname
self.workDirectory = None
else:
self.workDirectory = work_directory
self.RtcClient = server['pathToClientSoftware']
@staticmethod
def createServer(server, dirname, work_directory=None):
return ConfigRTCServer(server, dirname, work_directory)
def get_work_directory(self):
return self.workDirectory
def get_file_contents(self, file_name):
response = self.session.read_file("%s/%s" % (self.getWorkDirectory(), file_name))
return response
def write_string_as_file(self, file_name, content):
remote_file = self.session.remote_file("%s/%s" % (self.getWorkDirectory(), file_name))
response = self.session.copy_text_to_file(str(content), remote_file)
def execute_lscm_command(self, command, run_in_workdirectory=False):
#logger.info(command)
command = self.sub_placeholders(command)
lscm_command="%s %s" % (self.RtcClient, command)
if run_in_workdirectory is False:
response = self.execute_command(lscm_command)
else:
response = self.execute_command_in_workDirectory(lscm_command)
return response
def execute_command_in_workDirectory(self, command):
# #logger.info("switching overthere to workdirectory")
# workDir = self.session.remote_file(self.get_work_directory())
# self.session.get_conn().setWorkingDirectory(workDir)
# #logger.info("switched to workDirectory")
command = "cd %s;%s" % (self.get_work_directory(), command)
return self.execute_command(command)
#def execute_command(self, command):
# #logger.info("executing command: %s " % (command))
# response = self.session.execute(command, check_success=False, suppress_streaming_output=False)
# if response.rc != 0:
# #logger.info(response.stderr)
# #logger.info("unable to execute command %s" % (command))
# raise Exception('unable to execute command ')
# else:
# #logger.info("Response", str(response.stdout))
# return response
def execute_command(self, command, retain_scripts=True):
command_object = BashScriptBuilder()
for command_line in command.split(';'):
command_object.add_line(command_line)
executable_command = command_object.build()
tmp_script_file_name = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(9))
#logger.info("uploading script %s" % tmp_script_file_name)
script = self.session.upload_text_content_to_work_dir(executable_command, tmp_script_file_name, executable=True)
response = self.session.execute(script.getPath(), check_success=False, suppress_streaming_output=False)
#logger.info("stdErr for command yielded: " + str(response.stderr))
#logger.info("stdOut for command yielded: " + str(response.stdout))
#logger.info("the returncode for the command was:" + str(response.rc))
if response.rc != 0:
#logger.info("unable to execute command %s" % (command))
raise Exception('unable to execute command ')
else:
#logger.info("Response", str(response.stdout))
return response
def getWorkDirectory(self):
if self.workDirectory is None:
self.session.execute("/bin/mkdir -p %s/%s/%s" % (self.WorkDirBase,self.WorkDirTimeStamp,self.WorkDirName))
self.workDirectory = "%s/%s/%s" % (self.WorkDirBase,self.WorkDirTimeStamp,self.WorkDirName)
return self.workDirectory
def destroy_work_directory(self):
if self.workDirectory is not None:
self.execute_command("/bin/rm -rf %s/%s" % (self.WorkDirBase, self.WorkDirName))
def sub_placeholders(self, input):
#logger.info(self.workDirectory)
#logger.info(self.getWorkDirectory())
output = input.replace('<work_dir>', self.getWorkDirectory())
return output
#
# Copyright 2021 XEBIALABS
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
from overtherepy import OverthereHostSession
session = OverthereHostSession(container.ansibleController.host)
target = session.remote_file(target_path)
print('Delete {0}'.format(target))
target.delete()
response = CommandResponse(rc=rc,
stdout=capture_so_handler.outputLines,
stderr=capture_se_handler.outputLines)
if response.rc != 0:
session.logger.error(StringUtils.concat(response.stdout))
session.logger.error(StringUtils.concat(response.stderr))
session.logger.error("Exit code {0}".format(response.rc))
sys.exit(response.rc)
return response
ansible_controler = repositoryService.read(ansible_controller_id)
remote_session = OverthereHostSession(ansibleController.host)
remote_yaml_file = remote_session.remote_file(yaml_file)
print("remote_yaml_file {0}".format(remote_yaml_file))
operating_system = System.getProperty("os.name").lower()
print("running " + operating_system + " OS on localhost")
if operating_system.startswith("win"):
os = OperatingSystemFamily.WINDOWS
else:
os = OperatingSystemFamily.UNIX
local_opts = LocalConnectionOptions(os=os)
local_host = OverthereHost(local_opts)
local_session = OverthereHostSession(local_host, stream_command_output=True)
local_yaml_file = local_session.work_dir_file(remote_yaml_file.getName())
print("local_yaml_file {0}".format(local_yaml_file))
class DarBuildServer(object):
def __init__(self, server):
self.retryCount = server['retryCount']
if self.retryCount == 0:
self.retryCount = 1
self.retryBaseInterval = 60
self.sshOpts = SshConnectionOptions(server['host'],
username=server['username'],
privateKeyFile=server['key_file'],
password=server['password'],
port=server['port'])
self.host = OverthereHost(self.sshOpts)
self.session = OverthereHostSession(self.host)
tries = 0
while tries < self.retryCount:
tries += 1
try:
self.zipBinary = server['pathToZipExecutable']
self.workingDirectory = server['workingDirectory']
self.create_directory(self.workingDirectory)
workDir = self.session.remote_file(self.workingDirectory)
self.session.get_conn().setWorkingDirectory(workDir)
break
except:
if tries > 3:
print sys.exc_info()[0]
print sys.exc_info()[1]
if tries > self.retryCount:
print sys.exc_info()[2].format_stack()
print "we were unable to setup a connection to server: %s after %i retries" % (
server['host'], tries)
sys.exit(2)
sleeptime = self.retryBaseInterval * tries
print "retrying to setup a connection to server %s in %i seconds" % (
server['host'], sleeptime)
time.sleep(sleeptime)
def __del__(self):
self.destroy_work_directory()
self.session.close_conn()
def closeConnection(self):
print "closing ssh connection"
self.session.close_conn()
@staticmethod
def createServer(server):
return DarBuildServer(server)
#
def init_dar(self, appName, appVersion):
workspace_root = self.create_dar_directory(appName, appVersion)
manifest_filename = "%s/deployit-manifest.xml" % workspace_root
self.write_dar_manifest(appName, appVersion, workspace_root)
def delete_workspace(self, appName, appVersion):
dirName = "%s/%s" % (appVersion, appName)
response = self.execute_command("/bin/rm -rf %s" % (dirName))
response = self.execute_command("/bin/rm -rf %s" % (appVersion))
def import_ear(self, appName, appVersion, deployable, url):
self.download_file_into_dar(appName, appVersion, deployable, str(url))
def create_dar_directory(self, appName, appVersion):
dirName = "%s/%s" % (appVersion, appName)
# check if the directory exists .. if it does we should go do something else.
# might want to do a better locking mechanism
if self.dir_exists(dirName):
print "unable to create dar directory: %s/%s/%s" % (
self.workingDirectory, appVersion, appName)
raise Exception('unable to create Dar Package Directory')
else:
self.create_directory(dirName)
return dirName
def download_file_into_dar(self, appName, appVersion, deployable, url):
#filename = url.split('/')[-1]
filename = os.path.basename(url)
outfile = "%s/%s/%s/%s" % (appVersion, appName, deployable, filename)
dirName = "%s/%s/%s" % (appVersion, appName, deployable)
if self.dir_exists(dirName):
print "output dir already exists: %s" % (dirName)
else:
self.create_directory(dirName)
self.execute_command(
"/usr/bin/curl --retry 5 --retry-delay 2 -k -L -o %s %s" %
(outfile, url))
def read_manifest(self, appName, appVersion):
file_name = "%s/%s/%s/deployit-manifest.xml" % (self.workingDirectory,
appVersion, appName)
return self.session.read_file(file_name, encoding="UTF-8")
def write_manifest(self, appName, appVersion, content):
file_name = "%s/%s/deployit-manifest.xml" % (appVersion, appName)
self.write_to_file(file_name, content)
def create_directory(self, dirName):
self.execute_command("/bin/mkdir -p %s" % (dirName))
def create_file(self, fileName, content=None):
if content:
self.write_to_file(fileName, str(content))
else:
self.execute_command("/bin/touch %s" % (fileName))
def write_to_file(self, fileName, content):
remoteFile = self.session.remote_file(
"%s/%s" % (self.workingDirectory, fileName))
self.session.copy_text_to_file(str(content), remoteFile)
def dir_exists(self, dirName):
command = "[ -d %s ]" % (dirName)
response = self.session.execute(command,
check_success=False,
suppress_streaming_output=False)
if response.rc == 0:
return True
else:
return False
def execute_command(self, command):
print "executing command: %s " % (command)
response = self.session.execute(command,
check_success=False,
suppress_streaming_output=False)
if response.rc != 0:
print response.stderr
print response.stdout
print "unable to execute command %s" % (command)
raise Exception('unable to execute command ')
else:
print "Response:", str(response.stdout)
print "Errors:", str(response.stderr)
# self.switch_working_directory()
return response
def write_dar_manifest(self, appName, appVersion, workspace_root):
filename = "./%s/deployit-manifest.xml" % (workspace_root)
file_content = self.basic_dar_manifest_template().substitute(
appVersion=appVersion, appName=appName)
self.create_file(filename, file_content)
def basic_dar_manifest_template(self):
xml_template = '<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n'
xml_template += ' <udm.DeploymentPackage version=\"$appVersion\" application=\"$appName\"> \n'
xml_template += ' <orchestrator /> \n'
xml_template += ' <deployables/> \n'
xml_template += ' </udm.DeploymentPackage> \n'
return Template(xml_template)
def package_dar(self, appName, appVersion):
command = "set -x \n"
command += "if [ -f %s_%s.dar ] \n"
command += " then rm -rf %s_%s.dar \n"
command += "fi \n"
command += "cd %s/%s \n" % (appVersion, appName)
command += "/usr/bin/zip -r %s/%s_%s.dar *" % (
self.workingDirectory, appName.replace(
'/', '_'), appVersion.replace('.', '_'))
self.execute_multiline_command(command)
def remove_dar(self, appName, appVersion):
command = "set -x \n"
command += "cd %s \n" % self.workingDirectory
command += "if [ -f %s_%s.dar ] \n" % (appName.replace(
'/', '_'), appVersion.replace('.', '_'))
command += " then rm -rf %s_%s.dar \n" % (appName.replace(
'/', '_'), appVersion.replace('.', '_'))
command += " fi \n"
self.execute_multiline_command(command)
def write_exec_script(self, commands, script):
self.session.upload_text_content_to_work_dir(self,
commands,
script,
executable=False)
def execute_multiline_command(self, command):
tmp_filename = self.filename_generator()
self.write_to_file(tmp_filename, command)
self.execute_command("chmod +x %s" % (tmp_filename))
self.execute_command("./%s" % (tmp_filename))
def filename_generator(self,
size=9,
chars=string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
def upload_dar_package(self, appName, appVersion, xldeployServer):
dar_file_name = "%s_%s.dar" % (appName.replace(
'/', '_'), appVersion.replace('.', '_'))
command = "/usr/bin/curl -k -u %s:%s -X POST -H \"content-type:multipart/form-data\" %s/package/upload/%s -F fileData=@./%s " % (
xldeployServer['username'], xldeployServer['password'],
xldeployServer['url'], dar_file_name, dar_file_name)
self.execute_command(command)
