示例#1
0
    def restart():
        cmd_output = "error: could not determine how to restart the daemon"

        if FileHelper.file_exist(LynxCtrl.service_path_upstart):
            cmd_output = LynxCtrl.restart_upstart()
        elif FileHelper.file_exist(LynxCtrl.service_path_initd):
            cmd_output = LynxCtrl.restart_initd()
        return cmd_output
    def files_installed(cls, brand):
        path_app_support = "/Library/Application Support/{brand}".format(
            brand=brand)
        path_prefpane = "/Library/PreferencePanes/{brand}.prefPane".format(
            brand=brand)
        path_cache = "/Library/Caches/{brand}/cache.db".format(brand=brand)
        path_log = "/Library/Logs/{brand}.log".format(brand=brand)

        result = FileHelper.dir_exist(
            path_app_support) and FileHelper.dir_exist(
                path_prefpane) and FileHelper.file_exist(
                    path_cache) and FileHelper.file_exist(path_log)

        return result
示例#3
0
def step_impl(context, db):
    database_dir = LinuxClient().controller.config_db_dir

    state_db = os.path.join(database_dir,
                            LinuxClient().controller.state_database)

    if FileHelper.file_exist(state_db):
        FileHelper.delete_file(state_db)
    metric_db = os.path.join(database_dir,
                             LinuxClient().controller.metrics_database)
    if FileHelper.file_exist(metric_db):
        FileHelper.delete_file(metric_db)
    # config_db = LinuxClient().controller.config_database
    # if FileHelper.file_exist(config_db):
    #     FileHelper.delete_file(config_db)

    context.execute_steps(unicode('When I restart Linux Client'))
示例#4
0
 def start(self):
     """
     usage: start
     :return:
     """
     cmd_output = "error: could not determine how to start the service"
     if FileHelper.file_exist(self.mozy_daemon):
             cmd_output = self.start_upstart()
     return cmd_output
def parse_feature(features, pattern="*.feature"):
    testfeatures = []
    if FileHelper.file_exist(features) and FileHelper.file_ext(features) == "feature":
        testfeatures.append(features)
    else:
        files = FileHelper.find_file(features, pattern)
        # TODO: refine with FileHelper
        for file in files:
            testfeatures.append("features" + file.split("features")[1])
    return testfeatures
示例#6
0
 def test_create_file(self):
     """
     test: create test file
     """
     testfile = "%s%s%s" %(TestFileHelper.testdatadir, os.path.sep,  "testfilename")
     size = 2000
     FileHelper.create_file(testfile, size=size )
     result = FileHelper.file_exist(testfile)
     self.assertTrue(result)
     stat = FileHelper.get_file_stat(testfile)
     self.assertEqual(stat.st_size,size)
示例#7
0
    def is_client_installed():
        """
        usage: check whether linux client is installed
        :return: True if installed || False if not installed
        """
        result = False
        if FileHelper.file_exist(
                LynxCtrl.service_path_upstart) or FileHelper.file_exist(
                    LynxCtrl.service_path_initd):
            if FileHelper.dir_exist(LynxCtrl.conf_dir):
                if FileHelper.file_exist(LynxCtrl.mozyutil_daemon_path):
                    result = True
                else:
                    print "%s not present" % LynxCtrl.mozyutil_daemon_path
            else:
                print "%s not present" % LynxCtrl.conf_dir
        else:
            print "service control script not present at %s or %s" % (
                LynxCtrl.service_path_initd, LynxCtrl.service_path_upstart)

        return result
示例#8
0
    def is_client_installed(self):
        """
        usage: check whether windows client is installed
        :return: True if installed || False if not installed
        """
        result = False
        if FileHelper.dir_exist(self.install_path) and FileHelper.file_exist(self.mozyutil) and FileHelper.file_exist(self.configapp) and FileHelper.file_exist(self.statusapp):
            result = True
        else:
            LogHelper.error("ERROR: %s is installed." % self.install_path)

        return result
示例#9
0
def capture_worker_info(sender, instance, **kwargs):
    """
    dump worker infomation whenever worker is connected
    """
    info = PlatformHelper.get_platform_info()
    info['worker_name']='{0}'.format(sender)
    filename = os.path.join(os.path.dirname(__file__), "worker_info.yaml")
    if FileHelper.file_exist(filename):
        LogHelper.info("delete config file %s" % filename)
        FileHelper.delete_file(filename)
    data = dict((k.upper(), v) for k, v in info.items())
    with open(filename, 'w') as outfile:
        yaml.dump(data, outfile, default_flow_style=False)
 def clean_conf(self):
     path = self.get_configuration_path()
     data_path = path + "conf.dat"
     print data_path
     if FileHelper.file_exist(data_path):
         db = SqliteHelper(data_path)
         db.execute("delete from rules")
         db.execute("delete from filesystem")
         db.execute("delete from fsitems")
         db.execute("delete from set_names")
         db.execute("delete from sets")
         db.close()
     else:
         LogHelper.error("ERROR:Could not find conf to reset. Terminating")
示例#11
0
 def search_history_result(path):
     data_path = path + "state.dat"
     print data_path
     if FileHelper.file_exist(data_path):
         db = SqliteHelper(data_path)
         statement = "select result from history where start_date in (select max(start_date) from history)"
         # print statement
         result = db.find(statement)
         print type(result)
         print result
         return result
     else:
         LogHelper.error(
             "ERROR:Could not find result to search. Terminating")
    def download_fb(
        cls,
        product=None,
        dry_run=False,
    ):

        current_platform = PlatformHelper.get_system()
        fb_site = "https://artifacts.elastic.co/downloads/beats/filebeat/"
        package_name = ""

        if current_platform == "Linux" and PlatformHelper.get_arch(
        ) == "deb-64":
            package_name = 'filebeat-5.2.0-amd64.deb'

        if current_platform == "Linux" and PlatformHelper.get_arch(
        ) == "deb-32":
            package_name = 'filebeat-5.2.0-i386.deb'

        if current_platform == "Windows":
            package_name = 'filebeat-5.2.0-windows-x86_64.zip'

        if current_platform == "Darwin":
            package_name = 'filebeat-5.2.0-darwin-x86_64.tar.gz'

        installer_dir = ConfigAdapter.get_installer_path(product)

        cls.package_name = package_name
        installer_path = os.path.join(installer_dir, package_name)
        url = fb_site + package_name
        LogHelper.info("installer_path is " + installer_path)
        LogHelper.info("package url is " + url)

        if not FileHelper.dir_exist(installer_dir):
            FileHelper.create_directory(installer_dir)

        if FileHelper.file_exist(installer_path):
            FileHelper.delete_file(installer_path)

        if not dry_run:
            downloaded_package = urllib2.urlopen(url)
            LogHelper.info("download result is %s" % downloaded_package)
            with open(installer_path, 'wb') as output:
                output.write(downloaded_package.read())

        return installer_path
示例#13
0
def dump_options_to_config(filename="runner_config.yaml"):
    """
    dump options dict to a yaml file
    :return:
    """
    LogHelper.info("start to dump runner options to %s" % filename)
    if not filename.endswith(".yaml"):
        filename = filename + ".yaml"

    config_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "configuration"))
    config_file = os.path.join(config_dir, filename)

    if FileHelper.file_exist(config_file):
        LogHelper.info("delete config file %s" % config_file)
        FileHelper.delete_file(config_file)

    data = dict((k.upper(), v) for k, v in options.__dict__.items())

    with open(config_file, 'w') as outfile:
        yaml.dump(data, outfile, default_flow_style=False)
    def __mount_image(cls, image_path):
        LogHelper.debug("check that package is existed")
        if not FileHelper.file_exist(image_path):
            raise StandardError(
                'file {package} is not existed'.format(package=image_path))

        LogHelper.debug("mount dmg")
        mount_cmd = MacController.prefix_for_sudo(
        ) + 'sudo -S hdiutil attach {package}'.format(package=image_path)
        output = CmdHelper.run(mount_cmd)
        LogHelper.debug("mount result is {output}".format(output=output))

        mounted_volumes = cls.__find_mounted_volume(pattern='.*MozyPro.*')

        if len(mounted_volumes) > 1:
            LogHelper.error(
                "More than one volume deteched, something went wrong")

        mounted_volume = mounted_volumes[-1]

        return mounted_volume
def activate_linux_client(context):
    for row in context.table.rows:
        email_raw = row.get('email') or row.get('username')
        password = row.get('password')
        customkeytext = row.get('customkeytext')
        password_file = row.get('password_file')
        #TODO: add other parameters

    regex = re.match(r"{env}_{oemclient}_?.*", email_raw)
    if regex:
        cre_with_oc = re.sub(r"{oemclient}", RUNNER_CONFIG.get('OEM_CLIENT'),
                             email_raw)
        cre_with_oc_env = re.sub(r"{env}", RUNNER_CONFIG.get('ENVIRONMENT'),
                                 cre_with_oc)
        expected_credential = LYNX_CONFIG.get('CREDENTIAL').get(
            cre_with_oc_env)

        email = expected_credential.get('USERNAME')
        password_correct = expected_credential.get('PASSWORD')
    else:
        email = email_raw

    kargs = {}

    if email:
        kargs['email'] = email

    if password:
        kargs['password'] = password

    if password_file and password_file.upper() == "VALID":

        password_file_path = os.path.join(LYNX_CONFIG.get('TMP_PATH'),
                                          "password.txt")
        FileHelper.delete_file(password_file_path)

        if FileHelper.file_exist(password_file_path):
            FileHelper.delete_file(password_file_path)

        with open(password_file_path, "w") as text_file:
            text_file.write(password_correct)
        kargs['password-file'] = password_file_path

    if password_file and password_file.upper() == "INVALID":

        password_file_path = os.path.join(LYNX_CONFIG.get('TMP_PATH'),
                                          "wrong_password.txt")

        if FileHelper.file_exist(password_file_path):
            FileHelper.delete_file(password_file_path)

        with open(password_file_path, "w") as text_file:
            text_file.write(
                "{password}_wrong".format(password=password_correct))

        kargs['password-file'] = password_file_path

    if customkeytext:
        kargs['customkeytext'] = customkeytext

    kargs['force_encryption_change'] = None

    output = LinuxGUIClient.activate_cmd.activate(**kargs)
    LogHelper.info("activate output is %s" % output)
示例#16
0
def run():
    if options.database_enabled:
        id = testrun.upper()+start_time.replace(":", "_").replace("-", "_")
        tr = TestRun(id, start_time, qa_env=options.environment,
                     build=options.build, client=options.product,
                     oem=options.oem_client,
                     branch=options.job, runby="*****@*****.**")

        LogHelper.debug("Start to write TestRun to ES")
        tr.save_to_elasticsearch()
        LogHelper.debug("Finish to write TestRun to ES")

    create_runner_log()
    verify_options()
    if product == 'MAC_MACFRYR':
        LogHelper.debug("MAC_MACFRYR Test Case")
        mac_client = NativeClientFactory.get_client(product='MAC', oem=oem_client)
        if build:
            mac_client.installer.download_and_install(build[0], job[0])
        mac_client.controller.prepare_environment(environment)

        macfryr_client = NativeClientFactory.get_client(product='MACFRYR', oem=oem_client)
        if build:
            macfryr_client.installer.download_and_install(build[1], job[1])
        macfryr_client.controller.prepare_environment(environment)

        LogHelper.info('Install MacFryr Client')
        LogHelper.info('Prepare MacFryr Client Environment')

    elif product == 'WINDOWS_WINFRYR':
        LogHelper.debug("WINDOWS_WINFRYR Test Case")
        win_client = NativeClientFactory.get_client(product='WINDOWS', oem=oem_client)
        LogHelper.info('Load Configuration')
        if build:
            win_client.installer.download_and_install(build[0], job[0])
        win_client.controller.prepare_environment(environment)
        LogHelper.info('Install WINDOWS Client')
        LogHelper.info('Prepare WINDOWS Client Environment')

        winfryr_client = NativeClientFactory.get_client(product='WINFRYR', oem=oem_client)
        if build:
            winfryr_client.installer.download_and_install(build[1], job[1])
        winfryr_client.controller.prepare_environment(environment)
        LogHelper.info('Install WINFRYR Client')
        LogHelper.info('Prepare WINFRYR Client Environment')
    elif product == 'MTS':
        LogHelper.info("No need to install anything to test against MTS.")
    #TODO
    else:
        LogHelper.info("Standalone app ")
        native_client = NativeClientFactory.get_client(product=product, oem=oem_client)
        if build:
            native_client.installer.download_and_install(build, job)
        native_client.controller.prepare_environment(environment)

    dump_options_to_config()

    if options.taskid:
        print ("update task record after execution")
        CeleryHelper.update_task_status(options.taskid, testrun, result='STARTED')

    behave_cmd = "behave %s --no-capture --no-capture-stderr" % features
    LogHelper.info(behave_cmd)
    if options.tags:
        behave_cmd += " --tags %s" %(options.tags)

    dry_run = options.dry_run
    if dry_run:
            behave_cmd += ' --dry-run'

    output = CmdHelper.run(behave_cmd)
    print output

    if options.database_enabled:
        # TestRun Finish.
        tr.end_time = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
        tr.save_to_elasticsearch()


    rerun_failed = options.rerun
    if rerun_failed and FileHelper.file_exist("rerun_failing.features"):
        LogHelper.info('Rerun failed feature')
        behave_cmd = "behave @rerun_failing.features"
    	behave_output = CmdHelper.run(behave_cmd)
    	print behave_output


    final_result = 'COMPLETED'
    if options.taskid:
        LogHelper.debug("update task status in databsae")
        CeleryHelper.update_task_status(options.taskid, testrun, result=final_result)
        time.sleep(2)
        LogHelper.debug("check testrun status")
        query_body = {
            "query": {
                "bool": {
                    "must": [
                        {
                            "match": {
                                "testrun_id": testrun
                            }
                        }
                    ],
                    "must_not": [
                        {
                            "match": {
                                "status": final_result
                            }
                        }
                    ]
                }
            }
        }

        result = ElasticsearchHelper().search_document(index='task', doc_type='task', body=query_body)
        uncompleted_tasks = result.get('hits').get('total')
        LogHelper.debug("%d tasks is uncompleted" % uncompleted_tasks)
        if uncompleted_tasks == 0:
            print "all tasks are completed"
            LogHelper.debug("all tasks are done for testrun %s" % testrun)
            output = CeleryHelper.detach_from_queue(testrun)
            print output
            LogHelper.debug(output)
示例#17
0
 def clear_config(self):
     if FileHelper.file_exist(self.config_database):
         FileHelper.delete_file(self.config_database)
     if FileHelper.file_exist(self.state_database):
         FileHelper.delete_file(self.state_database)
示例#18
0
 def stop(self):
     cmd_output = "error: could not determine how to stop the service"
     if FileHelper.file_exist(self.mozy_daemon):
             cmd_output = self.stop_upstart()
     return cmd_output