def run(self):
self.log.debug('Inside Execute')
exit_code = 0
exit_code = self._check_for_ssh_agent()
if exit_code > 0:
return exit_code
for step in self.steps:
if step.get('who', None) == self.config['WHO']:
script = step.get('script', None)
if not script:
error_message = 'No script to execute in step ' \
' {0}'.format(step)
raise Exception(error_message)
self._report_step_status(step.get('id'), \
self.STATUS['PROCESSING'])
script_runner = ScriptRunner(self.job_id,
self.shippable_adapter)
script_status, exit_code, should_continue = \
script_runner.execute_script(script)
self.log.debug(script_status)
self._report_step_status(step.get('id'), script_status)
if should_continue is False:
break
else:
break
self._push_test_results()
self._push_coverage_results()
return exit_code
def run(self):
self.log.debug('Inside Execute')
exit_code = 0
exit_code = self._check_for_ssh_agent()
if exit_code > 0:
return exit_code
for step in self.steps:
if step.get('who', None) == self.config['WHO']:
script = step.get('script', None)
if not script:
error_message = 'No script to execute in step ' \
' {0}'.format(step)
raise Exception(error_message)
script_runner = ScriptRunner(self.job_id,
self.shippable_adapter)
script_status, script_exit_code, should_continue = \
script_runner.execute_script(script)
self._update_exit_code(script_exit_code)
self.log.debug(script_status)
if should_continue is False:
break
else:
break
self._push_test_results()
self._push_coverage_results()
self._push_post_job_envs()
return self.exit_code
def __execute(self):
self.log.debug('Executing step')
if self.step_scripts:
self.log.debug('Step scripts: {0}'.format(self.step_scripts))
scripts_execution_success = self.STATUS['SUCCESS']
for script in self.step_scripts:
script_runner = ScriptRunner(header_params=self.headers)
script_status = script_runner.execute_script(script)
if script_status != self.STATUS['SUCCESS']:
scripts_execution_success = script_status
self.log.debug(
'Script competed with status: {0}'.format(script_status))
self.log.debug('All scripts competed with status: {0}'.format(
scripts_execution_success))
coverage_reports = self.__get_coverage_reports()
self.log.debug('Loaded coverage reports from disk: {0}'.format(
coverage_reports))
if coverage_reports:
self.message['coverageResults'] = coverage_reports
test_reports = self.__get_test_reports()
self.log.debug(
'Loaded test reports from disk: {0}'.format(test_reports))
if test_reports:
self.message['testResults'] = test_reports
return scripts_execution_success
else:
self.log.error('No scripts to execute, returning error')
return self.STATUS['FAILED']
def run(self):
self.log.debug("Inside Execute")
exit_code = 0
exit_code = self._check_for_ssh_agent()
if exit_code > 0:
return exit_code
for step in self.steps:
if step.get("who", None) == self.config["WHO"]:
script = step.get("script", None)
if not script:
error_message = "No script to execute in step " " {0}".format(step)
raise Exception(error_message)
script_runner = ScriptRunner(self.job_id, self.shippable_adapter)
script_status, script_exit_code, should_continue = script_runner.execute_script(script)
self._update_exit_code(script_exit_code)
self.log.debug(script_status)
if should_continue is False:
break
else:
break
self._push_test_results()
self._push_coverage_results()
self._push_post_job_envs()
return self.exit_code
def process_request(cls, request):
script_data = cls.parse_arguments(request)
script_runner = ScriptRunner()
results = script_runner.run_scripts(
script_data.get('requests'),
script_data.get('username', 'username_here'),
script_data.get('password', 'password_here'))
script_runner.utils.logout()
return results
def run(self):
self.log.debug('Inside Execute')
exit_code = 0
flushed_consoles_size_in_bytes = 0
sent_console_truncated_message = False
exit_code = self._check_for_ssh_agent()
if exit_code > 0:
return exit_code
if self.config['IS_NEW_BUILD_RUNNER_SUBSCRIPTION']:
self.log.warn('Using new build runner')
for step in self.steps:
if step.get('who', None) == self.config['WHO']:
script = step.get('script', None)
if not script:
error_message = 'No script to execute in step ' \
' {0}'.format(step)
raise Exception(error_message)
if self.config['IS_NEW_BUILD_RUNNER_SUBSCRIPTION']:
script_runner = ScriptRunner2(
self.job_id, self.shippable_adapter,
flushed_consoles_size_in_bytes,
sent_console_truncated_message)
else:
script_runner = ScriptRunner(
self.job_id, self.shippable_adapter,
flushed_consoles_size_in_bytes,
sent_console_truncated_message)
script_status, script_exit_code, should_continue, \
flushed_consoles_size_in_bytes, \
sent_console_truncated_message = \
script_runner.execute_script(script)
self._update_exit_code(script_exit_code)
self.log.debug(script_status)
if should_continue is False:
break
else:
break
self._push_test_results()
self._push_coverage_results()
self._push_post_job_envs()
return self.exit_code
def main():
# Get the data and commands file paths from command line
cli_parser = argparse.ArgumentParser(description='Unix Automation Console')
cli_parser.add_argument('--data', dest='data_path', type=str, default='./data.json',
help='path to data.json containing desired users, groups, files, and ssh keys '
'configuration info (default: ./data.json)')
cli_parser.add_argument('--commands', dest='commands_path', type=str, default='./commands.json',
help='path to commands.json containing the supported OS flavors info (default: ./commands.json)')
args = cli_parser.parse_args()
try:
file_parser = JSONFileParser(args.commands_path, args.data_path)
os_detector = OSDetector(file_parser.commands['agnostic'])
flavor_id = os_detector.detect_flavor()
print "OS detected: {0}".format(flavor_id)
script_runner = ScriptRunner(file_parser.commands[flavor_id], file_parser.data)
script_runner.run()
except Exception as error:
print 'Error: {0}'.format(error.message)
return 0
def on_button_clicked(self):
# If any button is clicked this gets called.
# Gets the name of the button that called this method from the main widget.
# Makes sure the creds can be read, and gets the specific_names for
# the script from the json data using the name of the button.
# Creates a ScriptRunner with specific_names and the button name
# split into carrier and platform. Moves the ScriptRunner to a new QThread(), objThread.
# Connects the start of objThread to the method calling execute_script, and
# connects the end of the objThread to a cleanup method.
# Starts the thread, updates the label, and appends both the sr and the QThread to lists.
sending_button = self.widget.sender()
text = sending_button.text()
splitName = text.split()
carrier = splitName[0]
platform = splitName[1]
specific_names = self.data[text]
# If edit mode is on, send these names to the editor and chill with the rest of the function
if self.edit_name_mode:
self.currently_editing_button = text
self.open_editor(specific_names)
return
# Otherwise, read and set credentials
creds = self.read_creds()
if creds == "":
return
objThread = QThread()
sr = ScriptRunner(carrier, specific_names, platform, creds,
self.chrome_driver_path)
sr.moveToThread(objThread)
sr.finished.connect(self.complete_script)
objThread.started.connect(sr.start)
objThread.finished.connect(objThread.exit)
objThread.start()
self.currently_running_scripts.append(sr)
self.threads.append(objThread)
if len(self.currently_running_scripts) == 1:
self.label.setText("Working on it...")
else:
self.label.setText(
f"Working on {len(self.currently_running_scripts)} tasks...")
self.window.setWindowTitle("In progress")
def run(self):
self.log.debug('Inside Execute')
exit_code = 0
for step in self.steps:
if step.get('who', None) == self.config['WHO']:
script = step.get('script', None)
if not script:
error_message = 'No script to execute in step ' \
' {0}'.format(step)
script_runner = ScriptRunner(self.job_id,
self.shippable_adapter)
script_status, exit_code, should_continue = script_runner.execute_script(
script)
self.log.debug(script_status)
self._report_step_status(step.get('id'), script_status)
if should_continue is False:
break
else:
break
return exit_code
def run(self):
self.log.debug('Inside Execute')
exit_code = 0
flushed_consoles_size_in_bytes = 0
sent_console_truncated_message = False
exit_code = self._check_for_ssh_agent()
if exit_code > 0:
return exit_code
for step in self.steps:
if step.get('who', None) == self.config['WHO']:
script = step.get('script', None)
if not script:
error_message = 'No script to execute in step ' \
' {0}'.format(step)
raise Exception(error_message)
script_runner = ScriptRunner(self.job_id,
self.shippable_adapter, flushed_consoles_size_in_bytes,
sent_console_truncated_message)
script_status, script_exit_code, should_continue, \
flushed_consoles_size_in_bytes, \
sent_console_truncated_message = \
script_runner.execute_script(script)
self._update_exit_code(script_exit_code)
self.log.debug(script_status)
if should_continue is False:
break
else:
break
self._push_test_results()
self._push_coverage_results()
self._push_post_job_envs()
return self.exit_code
def __execute(self):
self.log.debug('Executing step')
if self.step_scripts:
self.log.debug('Step scripts: {0}'.format(
self.step_scripts))
scripts_execution_success = self.STATUS['SUCCESS']
for script in self.step_scripts:
script_runner = ScriptRunner(header_params=self.headers)
script_status = script_runner.execute_script(script)
if script_status != self.STATUS['SUCCESS']:
scripts_execution_success = script_status
self.log.debug('Script competed with status: {0}'.format(
script_status))
self.log.debug('All scripts competed with status: {0}'.format(
scripts_execution_success))
coverage_reports = self.__get_coverage_reports()
self.log.debug('Loaded coverage reports from disk: {0}'.format(
coverage_reports))
if coverage_reports:
self.message['coverageResults'] = coverage_reports
test_reports = self.__get_test_reports()
self.log.debug('Loaded test reports from disk: {0}'.format(
test_reports))
if test_reports:
self.message['testResults'] = test_reports
return scripts_execution_success
else:
self.log.error('No scripts to execute, returning error')
return self.STATUS['FAILED']
def bootstrap_script(self, script, *gtk_args):
self.set_busy_icon()
script_runner = ScriptRunner(script, self.script_finished_listener)
self.running_scripts.add(script_runner)
script_runner.run()
import time, sys, os
sys.path.insert(1, '/home/nitin/code/Ashrut/compass/ui_app/app/config')
from config_reader import ConfigReader
# sys.path.insert(1, '/home/nitin/code/Ashrut/compass/ui_app/app/helper/handler/process')
# from process_handler import ProcessHandler
sys.path.insert(
1, '/home/nitin/code/Ashrut/compass/ui_app/app/helper/file_upload')
from file_uploader import FileUploader
sys.path.insert(1, '/home/nitin/code/Ashrut/compass/ui_app/app/helper/runners')
from script_runner import ScriptRunner
script_runner = ScriptRunner()
file_uploader = FileUploader()
config = ConfigReader()
# process_handler = ProcessHandler(config.get_app_data_folder())
class CustomKafkaConsumer():
def __init__(self, ip, port, topic, from_begin=True):
self.topic = topic
self.ip = ip
self.port = port
if from_begin:
self.__consumer = self.__connect(auto_offset_reset='earliest')
else:
self.__consumer = self.__connect(auto_offset_reset='latest')
