def execute_script(server):
print "Running script [%s] on server instance [%s]" % (scriptToExecute, server.getProperty("serverName"))
sshOpts = SshConnectionOptions(server.getProperty("address"), server.getProperty("username"), password=server.getProperty("password"))
host = OverthereHost(sshOpts)
session = OverthereHostSession(host)
response = session.execute([scriptToExecute], check_success=False)
if response.rc != 0:
print "Failed to execute command"
print response.stderr
else:
print "Response", str(response.stdout)
session.close_conn()
class ConfigFsServer(object):
def __init__(self, server, username=None, password=None):
self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],password=server['password'])
self.host = OverthereHost(self.sshOpts)
self.session = OverthereHostSession(self.host)
def __del__(self):
self.session.close_conn()
@staticmethod
def createServer(server, username=None, password=None):
return ConfigFsServer(server, username, password)
def get_file_contents(self, file_path):
response = self.session.read_file(file_path)
return response
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 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"):
self.sshOpts = SshConnectionOptions(server['host'], username=server['username'],password=server['password'])
self.host = OverthereHost(self.sshOpts)
self.session = OverthereHostSession(self.host)
self.WorkDirBase = server['filesystemLocation']
self.WorkDirTimeStamp = int(time.time())
self.WorkDirName = dirname
self.workDirectory = None
self.RtcClient = server['pathToClientSoftware']
def __del__(self):
self.destroy_work_directory()
self.session.close_conn()
@staticmethod
def createServer(server, dirname):
return ConfigRTCServer(server, dirname)
def get_file_contents(self, file_name):
response = self.session.read_file("%s/%s" % (self.getWorkDirectory(), file_name))
return response
def execute_lscm_command(self, command, run_in_workdirectory=False):
print command
command = self.sub_placeholders(command)
print 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(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)
return response
def getWorkDirectory(self):
if self.workDirectory is None:
self.execute_command("/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):
print self.workDirectory
print self.getWorkDirectory()
output = input.replace('<work_dir>', self.getWorkDirectory())
return output
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS
# FOR A PARTICULAR PURPOSE. THIS CODE AND INFORMATION ARE NOT SUPPORTED BY XEBIALABS.
#
from overtherepy import LocalConnectionOptions, OverthereHost, OverthereHostSession
from com.xebialabs.overthere import OperatingSystemFamily
import sys
import re
def to_map(stdout):
data={}
for s in response.stdout:
if 'export' in s:
info = s.replace('export ',' ').replace('"',' ').strip().split('=')
data[str(info[0])]=str(info[1])
return data
session = OverthereHostSession(target.container.host)
response = session.execute("docker-machine env %s " % target.machineName)
data=to_map(response.stdout)
ip = re.findall( r'[0-9]+(?:\.[0-9]+){3}', data['DOCKER_HOST'])
if len(ip) == 1:
data['address'] = ip[0]
print "IP Address is %s " % data['address']
print data
session.close_conn()
context.setAttribute(context_key, data)
new_stack_status = data['Stacks'][0]['StackStatus']
if new_stack_status == stack_status:
sys.stdout.write(".")
else:
sys.stdout.write("\n")
sys.stdout.write(new_stack_status)
stack_status = new_stack_status
if stack_status == "ROLLBACK_COMPLETE" or stack_status == "UPDATE_ROLLBACK_COMPLETE":
sys.stdout.write("\n")
print "KO"
sys.exit(1)
break
else:
result = "RETRY"
finally:
if result == "RETRY":
inc_context(stack_name)
cpt = get_value_context(stack_name)
#print "WAIT....{0}/{1}".format(cpt, attempts)
if cpt < int(attempts):
result = "RETRY"
import time
time.sleep(5)
else:
print "Too many attempts {0}".format(attempts)
result = int(attempts)
session.close_conn()
class TestOverthereSession(object):
# preparing to test
def setUp(self):
self._linuxhost = OverthereHost(LocalConnectionOptions(os=OperatingSystemFamily.UNIX))
self._session = OverthereHostSession(self._linuxhost)
self._session.logger = OverthereSessionLogger(capture=True)
# ending the test
def tearDown(self):
self._session.close_conn()
def _clear_logs(self):
self._session.logger.output_lines = []
self._session.logger.error_lines = []
def assert_in_list(self, list, expect):
r = [s for s in list if str(s) == str(expect)]
eq_(len(r), 1, "expect [%s] to be in list [%s]" % (expect, str(list)))
def test_not_windows_host(self):
ok_(not self._session.is_windows())
def test_work_dir_cleanup(self):
workdir = self._session.work_dir()
ok_(workdir.exists())
workdir_path = workdir.path
self._session.close_conn()
ok_(not os.path.exists(workdir_path))
def test_read_write_file(self):
f = self._session.upload_text_content_to_work_dir("some text", "my.txt")
text = self._session.read_file(f.path)
eq_("some text", text)
def test_upload_executable_file(self):
f = self._session.upload_text_content_to_work_dir("#!/bin/sh\necho hello", "my.sh", executable=True)
r = self._session.execute(f.path)
self.assert_in_list(r.stdout, "hello")
def test_upload_classpath_resource(self):
f = self._session.upload_classpath_resource_to_work_dir("testfiles/singleline.txt")
text = self._session.read_file(f.path)
eq_("some text 1", text)
def test_read_lines(self):
f = self._session.upload_classpath_resource_to_work_dir("testfiles/multiline.txt")
lines = self._session.read_file_lines(f.path)
eq_(3, len(lines))
def test_execute(self):
f = self._session.upload_classpath_resource_to_work_dir("testfiles/echo.sh", executable=True)
response = self._session.execute([f.path, "ping"])
eq_(response['rc'], 0)
eq_(response['stdout'][0], "Hi ping")
def test_execute_automatic_system_exit_on_failure(self):
success = False
try:
f = self._session.upload_classpath_resource_to_work_dir("testfiles/echo.sh", executable=True)
self._session.execute([f.path, "ping", "1"])
except SystemExit:
success = True
pass
eq_(success, True)
def test_execute_check_success_turned_off(self):
f = self._session.upload_classpath_resource_to_work_dir("testfiles/echo.sh", executable=True)
response = self._session.execute("%s ping 1" % f.path, check_success=False)
eq_(response.rc, 1)
eq_(response['stdout'][0], "Hi ping")
eq_(response['stdout'][1], "Exiting with 1")
def test_with_support(self):
s = OverthereHostSession(self._linuxhost)
with s:
work_dir = s.work_dir().path
eq_(os.path.exists(work_dir), True)
eq_(os.path.exists(work_dir), False)
def _local_file(self, resource):
url = Thread.currentThread().contextClassLoader.getResource(resource)
return self._session.local_file(File(url.toURI()))
def test_mkdirs_on_dir_copy(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
eq_(os.path.exists(target.path), False)
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
eq_(os.path.exists(target.path + "/echo.sh"), True)
log_info = self._session.logger.output_lines
eq_(len(log_info), 2)
eq_(log_info[0], "Creating path %s" % target.path)
eq_(log_info[1], "Copying %s to %s" % (source.path, target.path))
def test_mkdirs_on_file_copy(self):
target = self._session.work_dir_file("some/path/some.txt")
source = self._local_file("testfiles/echo.sh")
eq_(os.path.exists(target.path), False)
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
log_info = self._session.logger.output_lines
eq_(len(log_info), 2)
eq_(log_info[0], "Creating path %s" % target.parentFile.path)
eq_(log_info[1], "Copying %s to %s" % (source.path, target.path))
def test_mkdirs_on_turned_off_on_copy(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
success = False
try:
self._session.copy_to(source, target, mkdirs=False)
except:
success = True
eq_(success, True)
def test_delete_from_when_target_does_not_exit(self):
target = self._session.work_dir_file("some/path")
source = None
self._session.delete_from(source, target)
log_info = self._session.logger.output_lines
eq_(len(log_info), 1)
eq_(log_info[0], "Target [%s] does not exist. No deletion to be performed" % target.path)
def test_delete_from_file_target(self):
target = self._session.work_dir_file("some/path/test.txt")
self._session.copy_text_to_file("xxx", target)
eq_(os.path.exists(target.path), True)
source = None
self._session.delete_from(source, target)
eq_(os.path.exists(target.path), False)
log_info = self._session.logger.output_lines
eq_(len(log_info), 2)
self.assert_in_list(log_info, "Deleting [%s]" % target.path)
def test_delete_from_folder_target(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
self._clear_logs()
self._session.delete_from(source, target)
eq_(os.path.exists(target.path), False)
log_info = self._session.logger.output_lines
eq_(len(log_info), 5)
self.assert_in_list(log_info, "Recursively deleting directory [%s/asubdir]" % target.path)
self.assert_in_list(log_info, "Deleting file [%s/echo.sh]" % target.path)
self.assert_in_list(log_info, "Deleting file [%s/multiline.txt]" % target.path)
self.assert_in_list(log_info, "Deleting file [%s/singleline.txt]" % target.path)
self.assert_in_list(log_info, "Deleting directory [%s]" % target.path)
def test_delete_from_with_external_resources(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
external_resource = self._session.work_dir_file("some/path/ext.txt")
self._session.copy_text_to_file("xxx", external_resource)
eq_(os.path.exists(external_resource.path), True)
self._clear_logs()
self._session.delete_from(source, target)
eq_(os.path.exists(target.path), True)
log_info = self._session.logger.output_lines
eq_(len(log_info), 5)
self.assert_in_list(log_info, "Recursively deleting directory [%s/asubdir]" % target.path)
self.assert_in_list(log_info, "Deleting file [%s/echo.sh]" % target.path)
self.assert_in_list(log_info, "Deleting file [%s/multiline.txt]" % target.path)
self.assert_in_list(log_info, "Deleting file [%s/singleline.txt]" % target.path)
self.assert_in_list(log_info, "Target directory [%s] is not shared, but still has content from an external source. Will not delete" % target.path)
def test_copy_diff(self):
old = self._local_file("directorycompare/old")
new = self._local_file("directorycompare/new")
deployed_old = self._session.work_dir_file("olddeployed")
self._session.copy_to(old, deployed_old)
eq_(os.path.exists(deployed_old.path), True)
self._clear_logs()
diff = Diff.calculate_diff(old, new)
self._session.copy_diff(deployed_old.path, diff)
log_info = self._session.logger.output_lines
eq_(len(log_info), 17)
self.assert_in_list(log_info, "3 files to be removed.")
self.assert_in_list(log_info, "3 new files to be copied.")
self.assert_in_list(log_info, "2 modified files to be copied.")
self.assert_in_list(log_info, "Start removal of files...")
self.assert_in_list(log_info, "Removing file %s/removefile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Removing directory %s/subdirremove" % deployed_old.path)
self.assert_in_list(log_info, "Removing file %s/subdirboth/removefile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Removal of files done.")
self.assert_in_list(log_info, "Start copying of new files...")
self.assert_in_list(log_info, "Copying directory %s/subdirnew" % deployed_old.path)
self.assert_in_list(log_info, "Copying file %s/newfile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Copying file %s/subdirboth/newfile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Copying of new files done.")
self.assert_in_list(log_info, "Start copying of modified files...")
self.assert_in_list(log_info, "Updating file %s/changedfile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Updating file %s/subdirboth/changedfile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Copying of modified files done.")
def test_execution_ctx_logging(self):
class ExecutionContext(object):
def __init__(self):
self.output_success = False
self.error_success = False
def logOutput(self, msg):
self.output_success = True
def logError(self, msg):
self.error_success = True
exec_ctx = ExecutionContext()
session = OverthereHostSession(self._linuxhost, execution_context=exec_ctx)
session.logger.info("Check")
eq_(exec_ctx.output_success, True)
session.logger.error("Check")
eq_(exec_ctx.error_success, True)
class TestOverthereSession(object):
# preparing to test
def setUp(self):
self._linuxhost = OverthereHost(
LocalConnectionOptions(os=OperatingSystemFamily.UNIX))
self._session = OverthereHostSession(self._linuxhost)
self._session.logger = OverthereSessionLogger(capture=True)
# ending the test
def tearDown(self):
self._session.close_conn()
def _clear_logs(self):
self._session.logger.output_lines = []
self._session.logger.error_lines = []
def assert_in_list(self, list, expect):
r = [s for s in list if str(s) == str(expect)]
eq_(len(r), 1, "expect [%s] to be in list [%s]" % (expect, str(list)))
def test_not_windows_host(self):
ok_(not self._session.is_windows())
def test_work_dir_cleanup(self):
workdir = self._session.work_dir()
ok_(workdir.exists())
workdir_path = workdir.path
self._session.close_conn()
ok_(not os.path.exists(workdir_path))
def test_read_write_file(self):
f = self._session.upload_text_content_to_work_dir(
"some text", "my.txt")
text = self._session.read_file(f.path)
eq_("some text", text)
def test_upload_executable_file(self):
f = self._session.upload_text_content_to_work_dir(
"#!/bin/sh\necho hello", "my.sh", executable=True)
r = self._session.execute(f.path)
self.assert_in_list(r.stdout, "hello")
def test_upload_classpath_resource(self):
f = self._session.upload_classpath_resource_to_work_dir(
"testfiles/singleline.txt")
text = self._session.read_file(f.path)
eq_("some text 1", text)
def test_read_lines(self):
f = self._session.upload_classpath_resource_to_work_dir(
"testfiles/multiline.txt")
lines = self._session.read_file_lines(f.path)
eq_(3, len(lines))
def test_execute(self):
f = self._session.upload_classpath_resource_to_work_dir(
"testfiles/echo.sh", executable=True)
response = self._session.execute([f.path, "ping"])
eq_(response['rc'], 0)
eq_(response['stdout'][0], "Hi ping")
def test_execute_automatic_system_exit_on_failure(self):
success = False
try:
f = self._session.upload_classpath_resource_to_work_dir(
"testfiles/echo.sh", executable=True)
self._session.execute([f.path, "ping", "1"])
except SystemExit:
success = True
pass
eq_(success, True)
def test_execute_check_success_turned_off(self):
f = self._session.upload_classpath_resource_to_work_dir(
"testfiles/echo.sh", executable=True)
response = self._session.execute("%s ping 1" % f.path,
check_success=False)
eq_(response.rc, 1)
eq_(response['stdout'][0], "Hi ping")
eq_(response['stdout'][1], "Exiting with 1")
def test_with_support(self):
s = OverthereHostSession(self._linuxhost)
with s:
work_dir = s.work_dir().path
eq_(os.path.exists(work_dir), True)
eq_(os.path.exists(work_dir), False)
def _local_file(self, resource):
url = Thread.currentThread().contextClassLoader.getResource(resource)
return self._session.local_file(File(url.toURI()))
def test_mkdirs_on_dir_copy(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
eq_(os.path.exists(target.path), False)
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
eq_(os.path.exists(target.path + "/echo.sh"), True)
log_info = self._session.logger.output_lines
eq_(len(log_info), 2)
eq_(log_info[0], "Creating path %s" % target.path)
eq_(log_info[1], "Copying %s to %s" % (source.path, target.path))
def test_mkdirs_on_file_copy(self):
target = self._session.work_dir_file("some/path/some.txt")
source = self._local_file("testfiles/echo.sh")
eq_(os.path.exists(target.path), False)
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
log_info = self._session.logger.output_lines
eq_(len(log_info), 2)
eq_(log_info[0], "Creating path %s" % target.parentFile.path)
eq_(log_info[1], "Copying %s to %s" % (source.path, target.path))
def test_mkdirs_on_turned_off_on_copy(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
success = False
try:
self._session.copy_to(source, target, mkdirs=False)
except:
success = True
eq_(success, True)
def test_delete_from_when_target_does_not_exit(self):
target = self._session.work_dir_file("some/path")
source = None
self._session.delete_from(source, target)
log_info = self._session.logger.output_lines
eq_(len(log_info), 1)
eq_(
log_info[0],
"Target [%s] does not exist. No deletion to be performed" %
target.path)
def test_delete_from_file_target(self):
target = self._session.work_dir_file("some/path/test.txt")
self._session.copy_text_to_file("xxx", target)
eq_(os.path.exists(target.path), True)
source = None
self._session.delete_from(source, target)
eq_(os.path.exists(target.path), False)
log_info = self._session.logger.output_lines
eq_(len(log_info), 2)
self.assert_in_list(log_info, "Deleting [%s]" % target.path)
def test_delete_from_folder_target(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
self._clear_logs()
self._session.delete_from(source, target)
eq_(os.path.exists(target.path), False)
log_info = self._session.logger.output_lines
eq_(len(log_info), 5)
self.assert_in_list(
log_info,
"Recursively deleting directory [%s/asubdir]" % target.path)
self.assert_in_list(log_info,
"Deleting file [%s/echo.sh]" % target.path)
self.assert_in_list(log_info,
"Deleting file [%s/multiline.txt]" % target.path)
self.assert_in_list(log_info,
"Deleting file [%s/singleline.txt]" % target.path)
self.assert_in_list(log_info, "Deleting directory [%s]" % target.path)
def test_delete_from_with_external_resources(self):
target = self._session.work_dir_file("some/path")
source = self._local_file("testfiles")
self._session.copy_to(source, target)
eq_(os.path.exists(target.path), True)
external_resource = self._session.work_dir_file("some/path/ext.txt")
self._session.copy_text_to_file("xxx", external_resource)
eq_(os.path.exists(external_resource.path), True)
self._clear_logs()
self._session.delete_from(source, target)
eq_(os.path.exists(target.path), True)
log_info = self._session.logger.output_lines
eq_(len(log_info), 5)
self.assert_in_list(
log_info,
"Recursively deleting directory [%s/asubdir]" % target.path)
self.assert_in_list(log_info,
"Deleting file [%s/echo.sh]" % target.path)
self.assert_in_list(log_info,
"Deleting file [%s/multiline.txt]" % target.path)
self.assert_in_list(log_info,
"Deleting file [%s/singleline.txt]" % target.path)
self.assert_in_list(
log_info,
"Target directory [%s] is not shared, but still has content from an external source. Will not delete"
% target.path)
def test_copy_diff(self):
old = self._local_file("directorycompare/old")
new = self._local_file("directorycompare/new")
deployed_old = self._session.work_dir_file("olddeployed")
self._session.copy_to(old, deployed_old)
eq_(os.path.exists(deployed_old.path), True)
self._clear_logs()
diff = Diff.calculate_diff(old, new)
self._session.copy_diff(deployed_old.path, diff)
log_info = self._session.logger.output_lines
eq_(len(log_info), 17)
self.assert_in_list(log_info, "3 files to be removed.")
self.assert_in_list(log_info, "3 new files to be copied.")
self.assert_in_list(log_info, "2 modified files to be copied.")
self.assert_in_list(log_info, "Start removal of files...")
self.assert_in_list(
log_info, "Removing file %s/removefile.txt" % deployed_old.path)
self.assert_in_list(
log_info, "Removing directory %s/subdirremove" % deployed_old.path)
self.assert_in_list(
log_info,
"Removing file %s/subdirboth/removefile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Removal of files done.")
self.assert_in_list(log_info, "Start copying of new files...")
self.assert_in_list(
log_info, "Copying directory %s/subdirnew" % deployed_old.path)
self.assert_in_list(log_info,
"Copying file %s/newfile.txt" % deployed_old.path)
self.assert_in_list(
log_info,
"Copying file %s/subdirboth/newfile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Copying of new files done.")
self.assert_in_list(log_info, "Start copying of modified files...")
self.assert_in_list(
log_info, "Updating file %s/changedfile.txt" % deployed_old.path)
self.assert_in_list(
log_info,
"Updating file %s/subdirboth/changedfile.txt" % deployed_old.path)
self.assert_in_list(log_info, "Copying of modified files done.")
def test_execution_ctx_logging(self):
class ExecutionContext(object):
def __init__(self):
self.output_success = False
self.error_success = False
def logOutput(self, msg):
self.output_success = True
def logError(self, msg):
self.error_success = True
exec_ctx = ExecutionContext()
session = OverthereHostSession(self._linuxhost,
execution_context=exec_ctx)
session.logger.info("Check")
eq_(exec_ctx.output_success, True)
session.logger.error("Check")
eq_(exec_ctx.error_success, True)
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)
