def cleanRPMmachine(self,ip):
     self.LoginTo(ip)
     logger.info("Clean reflex related stuff on  %s"%ip, also_console=True)
     ssh.write("pkill -9 java")
     line = ssh.read_until_prompt(loglevel="DEBUG")
     ssh.write("id")
     line = ssh.read_until_prompt(loglevel="DEBUG")
     logger.console(line)
     '''
     if line.find("402") != -1:
         logger.console("With reflex user")
         ssh.set_client_configuration(prompt="#") 
         ssh.write("exit")
         logger.info("Exiting reflex-user",also_console=True)
         ssh.write("yum erase -y reflex-tm")
         line=ssh.read_until_prompt()
         logger.info(line,also_console=True)
         logger.console("Successfully erase reflex-tm")
         ssh.write("rm -rf /opt/reflex/*")
         line = ssh.read_until_prompt()
         logger.info(line, html=False, also_console=True)
     else:
     '''
     ssh.write("yum erase -y reflex-tm")
     line = ssh.read_until_prompt()
     logger.info("Successfully erase reflex-tm",also_console=True)
     ssh.write("rm -rf /opt/reflex/*")
     line = ssh.read_until_prompt()
     logger.info("Successfully erase reflex directory",also_console=True)
 def stop_django(self):
     """Stop the Django server."""
     os.kill(self.django_pid, signal.SIGKILL)
     logger.console(
         "Django stopped (PID: %s)" % self.django_pid,
     )
     logger.console("-" * 78)
Esempio n. 3
0
def adbCmd(cmd,Device_ID ,timeout=300):
    #print "*WARN* Danger Will Robinson"
    logger.console("Execute command: "+"adb -s " + Device_ID + " " + cmd)
    print "Execute command: "+"adb -s " + Device_ID + " " + cmd
    proc=subprocess.Popen("adb -s " + Device_ID + " " + cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    return_string=getStrFromExctCMD(proc)
    return return_string
    def set_configuraciones_navegador(self, tipo_nav):
        if tipo_nav.upper() == "FIREFOX":
            # Copiamos la configuracion por defecto del navegador
            self._capabilites = DesiredCapabilities.FIREFOX.copy()

            # Sistema operativo
            self._capabilites["platform"] = "ANY"

            # Nombre del navegador
            self._capabilites["browsername"] = "firefox"

            # Version del navegador
            self._capabilites["version"] = "41.0.2"

            # JavaScript activado o no
            self._capabilites["javascriptEnabled"] = True

            # Navegador marionette activado o no
            self._capabilites["marionette"] = False

        elif tipo_nav.upper() == "CHROME":
            logger.console("#TODO Using broowser Chrome")

        elif tipo_nav.upper() == "PHANTOMJS":
            logger.console("#TODO Using browser Phantomjs")

        return self._capabilites
 def ConfigureCollector(self):
     self.LoginTo(self.collector_ip)
     logger.info("Now installing rpms and configuring Collector on %s"%self.collector_ip, also_console=True)
     ssh.write("id")
     line = ssh.read_until_prompt()
     logger.console(line)
     
     ssh.write("yum install -y reflex-collector")
     output = ssh.read_until_prompt(loglevel="INFO")
     for line in output.splitlines():
         line = line.strip(" ")
         if line.find("already installed and latest version") != -1:
                 logger.console("reflex-collector already installed", newline="yes", stream="stdout")
         elif line.find("failed") != -1:
                 logger.console("reflex-collector failed during installation", newline="yes", stream="stdout")
                 logger.error("failure", html=True)
         elif line.find("Error: Package:") != -1:
                 m1 = re.search('Error: Package:\s.*\s\(')
                 if m1:
                     package = m1.group()
                 logger.console(line, newline="yes", stream="stdout")
                 logger.error(package, html=True)
     logger.info("Reflex-collector installed successfully",also_console=True)
   
     #check reflex rpm also. Not remembered why ??
     
     self.SwitchToReflex()
     self.ReflexKeysGeneration()
     self.cliPrompt()
     ssh.write("show pm process collector")
     output = ssh.read_until_prompt(loglevel="INFO")
     logger.console(output)
 def cliPrompt(self,cluster="yes"):
     logger.info("Switching to cli Prompt",also_console=True)
     ssh.set_client_configuration(prompt="#")
     ssh.write("cli -m config",loglevel="DEBUG") 
     output = ssh.read_until_prompt(loglevel="DEBUG")
     logger.info("Showing Prompt %s"%output,also_console=True)
     if output.find("% Unrecognized command") != -1:  
        logger.warn("You are logging from Root user", html=True)
        self.SwitchToReflex()
        ssh.set_client_configuration(prompt="#")
        ssh.write("cli -m config",loglevel="DEBUG")
        output = ssh.read_until_prompt(loglevel="DEBUG")
     if cluster == "no":
        m1 = re.search("^(?P<cliPrompt>\S+\s\(\S+\)\s*\#)\s*",output.strip(),re.MULTILINE)
     else:
        for lines in output.splitlines():
            m1 = re.search("^(?P<cliPrompt>\S+\s\[\S+:\s\S+\]\s\(\S+\)\s*\#)\s*",lines.strip(),re.MULTILINE) 
            #logger.console(lines, newline=True, stream='stdout')
     #m1 = re.search("^(?P<cliPrompt>.*\$\s.*config\S+\s\(\S+\)\s*\#)\s*",output.strip(),re.MULTILINE)
     #logger.console(m1)
     if m1:
             cliPrompt = m1.group("cliPrompt")
             logger.console(cliPrompt)
     else:
             logger.warn("Not able to grep cliPrompt")
     ssh.set_client_configuration(prompt=cliPrompt)
def hadoopNamespace_Updation():   
    Login_To(NN_IP,un="admin",pw="admin@123")
    var = robo.get_variable_value("${shellPrompt}")
    ssh.set_client_configuration(prompt=var)
    conf = HAdoopConf()
    #logger.console(conf)
    logger.console(conf["journal"])
    ssh.write("hadoop fs -touchz /data/abcabc")
 def input_random_password(self, locator, name, errorLocator, expectedErrorMsg):
     global randomPassword 
     randomPassword = self.methodObj.getRandomPassword(name)
     logger.console('Random Generated Password is : %s' %randomPassword)
     self.sl.element_should_be_visible(locator)
     self.sl.input_text(locator, randomPassword)
     if(len(randomPassword) < 6):
         self._validate_message(errorLocator, expectedErrorMsg)
     return randomPassword
 def project_config(self):
     if self._project_config is None:
         if CURRENT_TASK.stack and isinstance(CURRENT_TASK.stack[0], Robot):
             # If CumulusCI is running a task, use that task's config
             return CURRENT_TASK.stack[0].project_config
         else:
             logger.console("Initializing CumulusCI config\n")
             self._project_config = CliRuntime().project_config
     return self._project_config
Esempio n. 10
0
 def _close(self):
     try:
         self.release_locks()
         self.release_value_set()
     except RuntimeError as err:
         # This is just last line of defence
         # Ignore connection errors if library server already closed
         logger.console("pabot.PabotLib#_close: threw an exception: is --pabotlib flag used? ErrorDetails: {0}".format(repr(err)), stream='stderr')
         pass
Esempio n. 11
0
 def __on_response_diagnosis(self, client, userdata, msgtop):
     """ on_response_diagnosis """
     logger.console(self._tag + "===> on_response_diagnosis")
     if self._msg_id != msgtop.message_head.message_id:
         logger.warn(self._tag + "on_response_diagnosis: Not expected msg_id")
         return
     if msgtop.HasField("remote_diagnosis_response"):
         self._result = msgtop.diagnosis_response.ack.status
         self._event.set()
    def open_browser_and_login_then_navigate_to_manage_users_page(
            self, browser, ip, username, password):
        self.driver = driver_factory.getDriver(browser, ip, username, password)
        sleep(5)

        # Navigate to Manage Users page
        logger.console("| Navigating to: " + self.driver.current_url +
                       "MVC/User/ManageUsers")
        self.driver.get(self.driver.current_url + "MVC/User/ManageUsers")
Esempio n. 13
0
 def project_config(self):
     if self._project_config is None:
         if CURRENT_TASK.stack and isinstance(CURRENT_TASK.stack[0], Robot):
             # If CumulusCI is running a task, use that task's config
             return CURRENT_TASK.stack[0].project_config
         else:
             logger.console("Initializing CumulusCI config\n")
             self._project_config = CliRuntime().project_config
     return self._project_config
Esempio n. 14
0
 def project_config(self):
     if self._project_config is None:
         if CURRENT_TASK and isinstance(CURRENT_TASK, Robot):
             # If CumulusCI is running a task, use that task's config
             return CURRENT_TASK.project_config
         else:
             logger.console('Initializing CumulusCI config\n')
             self._project_config = CliConfig().project_config
     return self._project_config
    def say_hi(self, name):
        """ Say hi with name

        Examples:
        | Say hi | name 1 |
        | Say hi | name 2 |
        """
        self._hello.set_name(name)
        logger.console('Say hi with %s' %(name))
Esempio n. 16
0
def run(command, msg=u"", check=True, log=False, console=False):
    """Wrapper around subprocess.check_output that can tolerates nonzero RCs.

    Stderr is redirected to stdout, so it is part of output
    (but can be mingled as the two streams are buffered independently).
    If check and rc is nonzero, RuntimeError is raised.
    If log (and not checked failure), both rc and output are logged.
    Logging is performed on robot logger. By default .debug(),
    optionally .console() instead.
    The default log message is optionally prepended by user-given string,
    separated by ": ".

    Commands given as single string are not supported, for safety reasons.
    Invoke bash explicitly if you need its glob support for arguments.

    :param command: List of commands and arguments. Split your long string.
    :param msg: Message prefix. Argument name is short just to save space.
    :param check: Whether to raise if return code is nonzero.
    :param log: Whether to log results.
    :param console: Whether use .console() instead of .debug().
        Mainly useful when running from non-main thread.
    :type command: Iterable or OptionString
    :type msg: str
    :type check: bool
    :type log: bool
    :type console: bool
    :returns: rc and output
    :rtype: 2-tuple of int and str
    :raises RuntimeError: If check is true and return code non-zero.
    :raises TypeError: If command is not an iterable.
    """
    if isinstance(command, OptionString):
        command = command.parts
    if not hasattr(command, u"__iter__"):
        # Strings are indexable, but turning into iterator is not supported.
        raise TypeError(f"Command {command!r} is not an iterable.")
    ret_code = 0
    output = u""
    try:
        output = subprocess.check_output(command, stderr=subprocess.STDOUT)
    except subprocess.CalledProcessError as err:
        output = err.output
        ret_code = err.returncode
        if check:
            raise RuntimeError(
                MESSAGE_TEMPLATE.format(com=err.cmd, ret=ret_code, out=output))
    if log:
        message = MESSAGE_TEMPLATE.format(com=command,
                                          ret=ret_code,
                                          out=output)
        if msg:
            message = f"{msg}: {message}"
        if console:
            logger.console(message)
        else:
            logger.debug(message)
    return ret_code, output
Esempio n. 17
0
 def just_call(self):
     """
     Basic call keyword.
     
     Example:
     | Just Call |
     """
     logger.info("Hello World")
     logger.console("Hello world")
def step1_check_componentstatus():
    stdout = ex.execute_unix_command(
        "kubectl get componentstatus -o json | jq .items[].conditions[].type")
    logger.console('\n')
    for line in stdout.split('\n'):
        if "Healthy" in line:
            logger.console(line)
        else:
            raise Exception(line)
 def check_search_functionality(self, keyword):
     """
     Asserts if the search functionality works. If it doesn't work it raises an AssertionError.
     :param keyword: Keyword to be searched for
     """
     if self.read_result_row_one().lower() == keyword.lower():
         robologger.console(f"{keyword} is equal to {self.read_result_row_one()}")
     else:
         raise AssertionError(f"Expected would be that the search keyword {keyword} to be equal with the search results {self.read_result_row_one()}")
Esempio n. 20
0
 def _toggle_bridge_mode(self, enable=None):
     #feng add
     logger.console(
         "\n For Toggle Bridge mode--> use selenium PortalWebGUICore.py :line 494\n"
     )
     self._linkElement("LAN IP")
     time.sleep(2)
     if self._isCheckboxChecked("togglecomp") is not enable:
         self._btnElement("togglecomp", by_id=True)
Esempio n. 21
0
def initiate_config():
    """
    utlility function to load configuration file
    :return: None
    """
    root_dir = get_project_root()
    logger.console(root_dir)
    config_file = os.path.join(root_dir, 'config/config.yaml')
    load_config(config_file)
Esempio n. 22
0
    def log_and_raise(self, exc_msg):
        """Log to console, on fail_on_mismatch also raise runtime exception.

        :param exc_msg: The message to include in log or exception.
        :type exc_msg: str
        :raises RuntimeError: With the message, if fail_on_mismatch.
        """
        logger.console("RuntimeError:\n{m}".format(m=exc_msg))
        if self.fail_on_mismatch:
            raise RuntimeError(exc_msg)
def fetch_the_filename_and_return_version(dict):
    if len(version_list) > 2:
        del version_list[0:2]
        logger.console("Initialized the version list")
    if re.match(
            "Smart Component for HPE Synergy 12Gb SAS Connection Module Firmware|Smart Component for HPE Synergy  D3940 Storage Module firmware",
            dict['name']):
        logger.console(dict['name'])
        version_list.append(dict['componentVersion'])
    return version_list
Esempio n. 24
0
def adbCmd(cmd, Device_ID, timeout=300):
    #print "*WARN* Danger Will Robinson"
    logger.console("Execute command: " + "adb -s " + Device_ID + " " + cmd)
    print "Execute command: " + "adb -s " + Device_ID + " " + cmd
    proc = subprocess.Popen("adb -s " + Device_ID + " " + cmd,
                            shell=True,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.STDOUT)
    return_string = getStrFromExctCMD(proc)
    return return_string
Esempio n. 25
0
 def error(self):
     error = ' '
     try:
         assert '<div class="alert alert-danger hidden"' in self.driver.page_source
     except AssertionError:
         logger.error('Error')
         errors = self.driver.find_elements_by_xpath(
             'id("content")/div/article/div')
         for error in errors:
             logger.console(error.text)
Esempio n. 26
0
 def _toggle_dynamic_wan_ip(self, enable):
     #feng add 2017/1/5
     logger.console("\nTrue = Enable / False = Disable\n")
     logger.console(enable)
     self._linkElement("WAN IP")
     time.sleep(2)
     self._linkElement("Connection Accessibility")
     time.sleep(2)
     if self._isCheckboxChecked("togglecomp") is not enable:
         self._btnElement("togglecomp", by_id=True)
Esempio n. 27
0
 def on_heartbeat(self):
     """
     callback function for when a heartbeat is received
     """
     logger.console("=> Hearbeat")
     if "Heartbeat" in self.__awaited_msgs:
         self.__msgq.put(call.HeartbeatPayload())
     return call_result.HeartbeatPayload(
         current_time=datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S') + "Z"
         )
 def read_songs_from_target_playlist(self):
     """
     Reads the songs from a playlist.
     If the list of songs is empty then an assertion error is raised.
     :return:
     """
     if len(self.SABL.songs_in_playlist()) > 0:
         robologger.console(self.SABL.read_songs_from_playlist())
     else:
         raise AssertionError("the playlist should have contained songs, instead it did not.")
 def new_playlist_creation_validation(self, playlist_name):
     """
     Validates that the new playlist was indeed created
     :param playlist_name: String containing the name of the newly created playlist
     """
     try:
         if self.SABL.playlist(playlist_name) == playlist_name:
             robologger.console("The song was present in the playlist list. Test has passed.")
     except Exception:
         raise AssertionError(f"The newly created playlist called: {playlist_name} should have been present in the list. It was not.")
 def _parse_arg(self, arg):
     """
     Highly simple parser to parse out action ('of', 'from', ... )
     from noun (<element> or <screenarea>)
     """
     noun = arg
     while noun:
         action, sep, noun = noun.partition(' ')
         print action, sep, noun
         logger.console("\n%s :: %s :: %s" % (action, sep, noun))
Esempio n. 31
0
 def _set_data_file(self, config_file, run_name, data_file):
     doc = et.parse(path.join(self.saw_home, config_file))
     # find the setup used by the specified run
     run = doc.find('runs/run[@name="{0}"]'.format(run_name))
     if run.attrib['datafile'] != data_file:
         logger.console(
             'Setting data file in {0} for run {1} to {2}'.format(
                 config_file, run_name, data_file))
         run.attrib['datafile'] = data_file
         doc.write(path.join(self.saw_home, config_file))
Esempio n. 32
0
 def _toggle_dhcp_server(self, enable=None):
     #feng add
     logger.console(
         "toggile dhcp server , in the PortalWebGUICore.py - lin 542\n")
     self._linkElement("LAN IP")
     time.sleep(2)
     #feng ----modify
     if self._isCheckboxChecked('(//input[@id=\'togglecomp\'])[3]',
                                is_xpath=True) is not enable:
         self._xpathElement('(//input[@id=\'togglecomp\'])[3]', None)
Esempio n. 33
0
    def __init__(self):
        Driver.__init__(self)
        self.driver = self.driver()
        self.driver.get(
            'https://vebd2.vertexinc.com/vertex/sanity-sso/auth/login.html?originalUrl=https://vebd2.vertexinc.com/vertex/sanity/ve/#/login'
        )
        self.driver.maximize_window()
        userName = self.driver.find_element(locators['login.username'][0],
                                            locators['login.username'][1])
        userName.send_keys('sri')

        passWord = self.driver.find_element(locators['login.password'][0],
                                            locators['login.password'][1])
        passWord.send_keys('iL0veTax')

        signInButton = self.driver.find_element(
            locators['login.signin.button'][0],
            locators['login.signin.button'][1])
        signInButton.click()
        signInButton.click()

        adhocButton = self.driver.find_element(locators['adhoc.button'][0],
                                               locators['adhoc.button'][1])
        highlight(adhocButton)
        adhocButton.click()
        xPathToDBName = "//*[@id='select-database']/select/option[text()='%s']" % 'open_yesu_test'

        try:
            element = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.ID, "select-database")))
        finally:
            logger.console("Element not found!")
            self.driver.quit()

        selectDB = self.driver.find_element(By.XPATH, xPathToDBName)
        highlight(selectDB)
        selectDB.click()

        xPathToTable = "//*[@id='select-table']/select/option[text()='%s']" % 'open_dan'
        selectTable = self.driver.find_element(By.XPATH, xPathToTable)
        selectTable.click()
        time.sleep(5)

        runAdhocQuery = self.driver.find_element(
            locators['adhoc.runAdhocQuery'][0],
            locators['adhoc.runAdhocQuery'][1])
        highlight(runAdhocQuery)
        runAdhocQuery.click()

        inputs = self.driver.find_elements_by_xpath(
            'body.desktop-detected.ng-scope:nth-child(2) div.ng-scope:nth-child(1) div.ng-scope:nth-child(2) div.animated.fadeIn.ng-scope section.ng-scope:nth-child(5) div.row:nth-child(1) article.col-xs-12.col-sm-12.col-md-12.col-lg-12.sortable-grid.ui-sortable div.jarviswidget.jarviswidget-sortable div.widget-body.no-padding div.smart-form.ng-valid.ng-valid-pattern.ng-valid-maxlength.ng-dirty.ng-valid-parse div.row:nth-child(3) section.col.col-12 div.fixed-table-container table.table.table-bordered.table-striped tbody.ng-scope:nth-child(2) tr.vs-repeat-repeated-element.ng-scope:nth-child(4) > td:nth-child(7)'
        )

        for input in inputs:
            print(inputs.text)
Esempio n. 34
0
    def kafka_CPU_validation(self, *args, **kwargs):
        banner("Kafka CPU validation")
        '''args: hostip
        '''
        self._load_kwargs(kwargs)
        logger.console("self.tun_interface_state: {}".format(
            self.tun_interface_state))
        try:
            if self.tun_interface_state == "UP":
                cmd = "docker exec kafka kafka-avro-console-consumer --topic cpu --bootstrap-server localhost:9092|head -20|grep {}|wc -l".format(
                    self.host_name)
                kafka_CPU_validation = cli_run(cmd=cmd,
                                               host_ip=self.hostip,
                                               linux_user=self.username,
                                               linux_password=self.password)

                serialised_kafka_CPU_validation = self._serialize_response(
                    time.time(), kafka_CPU_validation)
                print("serialised_kafka_CPU_validation is:{}".format(
                    serialised_kafka_CPU_validation))

                self.cmd_output = str(serialised_kafka_CPU_validation['Result']
                                      ['stdout']).replace('\n', '').strip()

                if int(self.cmd_output) > 0:
                    return True
                else:
                    return False

            elif self.tun_interface_state == "DOWN":
                cmd = "docker exec kafka kafka-avro-console-consumer --topic cpu --bootstrap-server localhost:9092|head -20|grep {}|wc -l".format(
                    self.host_name)
                kafka_CPU_validation = cli_run(cmd=cmd,
                                               host_ip=self.hostip,
                                               linux_user=self.username,
                                               linux_password=self.password)

                serialised_kafka_CPU_validation = self._serialize_response(
                    time.time(), kafka_CPU_validation)
                print("serialised_kafka_CPU_validation is:{}".format(
                    serialised_kafka_CPU_validation))

                self.cmd_output = str(serialised_kafka_CPU_validation['Result']
                                      ['stdout']).replace('\n', '').strip()

                if int(self.cmd_output) == 0:
                    return True
                else:
                    return False
            else:
                return False

        except Exception as e:
            logger.console(
                "Error in kafka_CPU_validation status: {}".format(e))
Esempio n. 35
0
def HAdoopShellCmds(cmd):
    #logger.warn(robo.get_library_instance('SSHLibrary'))
    #ssh = robo.get_library_instance('SSHLibrary')
    Login_To(NN_IP,un="admin",pw="admin@123")
    journalnodes = []
    host_mapping = IpHostName()
    var = robo.get_variable_value("${shellPrompt}")
    ssh.set_client_configuration(prompt=var)
    #logger.info(cmd,also_console=True)
    pmxcmd = "pmx subshell hadoop_yarn %s"%cmd
    logger.info(pmxcmd,also_console=True)
    ssh.write(pmxcmd)
    output = ssh.read_until_prompt()
    if pmxcmd.find("stop") != -1: 
        for line in output.splitlines():
            if line.find("Stopping JournalNode on Host:") != -1:
                match = re.search('.*:\s(.*)$',line)
                if match:
                    nodes = str(match.group(1))
                    journalnodes.append(nodes)
                else:
                    logger.error("Journal nodes cannt be stopped from Subshell commands")
            #logger.console(host_mapping)
        #logger.console(host_mapping["EIGHTY-DN82"])
            #logger.info(host_mapping[journalnodes[0]], also_console = True)
        logger.console(journalnodes,stream='stdout')
        for i in journalnodes:
            output = executeRemote("ps -aef | grep -i journalnode | grep -v grep | awk '{print $2 \":\" $9 \":\"  $12 \":\"  $22}'", host_mapping[i])
            #logger.info(output,also_console=True)
            for line in output.splitlines():
                if line.find("Dproc_journalnode") != -1:
                    logger.warn("Journal Nodes are still UP", html=True)
                    return False
                
    
    elif pmxcmd.find("start") != -1:
        for line in output.splitlines():
            if line.find("Starting JournalNode on Host:") != -1:
                match = re.search('.*:\s(.*)$',line)
                if match:
                    nodes = str(match.group(1))
                    journalnodes.append(nodes)
                else:
                    logger.error("Journal nodes cannot be stopped from Subshell commands")
        logger.console(journalnodes,stream='stdout')
        for i in journalnodes:
            #logger.info(i,also_console=True)
            #logger.info(host_mapping[i],also_console=True)
            output = executeRemote("ps -aef | grep -i journalnode | grep -v grep | awk '{print $2 \":\" $9 \":\"  $12 \":\"  $22}'", host_mapping[i])
            #logger.info(output,also_console=True)
            for line in output.splitlines():
                if line.find("Dproc_journalnode") != -1:
                    logger.warn("Journal Nodes are Running", html=True)
                    return True
Esempio n. 36
0
    def add_policy(self, *args, **kwargs):
        banner("PCC.Create Policy")
        self._load_kwargs(kwargs)
        conn = BuiltIn().get_variable_value("${PCC_CONN}")
        logger.console("Kwargs: {}".format(kwargs))
        print("Kwargs in create policy are: {}".format(kwargs))
        if 'appId' not in kwargs:
            return "Provide a valid appName/appId to create policy"
        if 'appId' in kwargs:
            if type(kwargs['appId']) == str:
                print("I am here")
                if kwargs['appId'].isnumeric():
                    self.appId = ast.literal_eval(kwargs['appId'])
                else:
                    print("I am in else1")
                    self.appId = kwargs['appId']
            else:
                print("I am in else2")
                self.appId = int(kwargs['appId'])
        print("app id is: {}".format(self.appId))
        if 'inputs' in kwargs:
            user_inputs = ast.literal_eval(kwargs['inputs'])
            default_inputs = self.get_policy_inputs_from_apps(**kwargs)
            if default_inputs == "Provide a valid appName/appId to create policy":
                return "Provide a valid appName/appId to create policy"
            for user_input in user_inputs:
                for default_input in default_inputs:
                    if user_input['name'] == default_input['name']:
                        default_input['value'] = user_input['value']

            self.inputs = default_inputs
        else:
            self.inputs = self.get_policy_inputs_from_apps(**kwargs)
            if self.inputs == "Provide a valid appName/appId to create policy":
                return "Provide a valid appName/appId to create policy"
        if 'scopeIds' in kwargs:
            self.scopeIds = ast.literal_eval(self.scopeIds)

        print("Kwargs in create policy are:{}".format(kwargs))
        print(
            "inputs is :{} and appId is {} and scopeID is {} and description is {}"
            .format(self.inputs, self.appId, self.scopeIds, self.description))
        payload = {
            "appId": self.appId,
            "scopeIDs": self.scopeIds,
            "description": self.description,
            "inputs": self.inputs,
            "owner": self.owner
        }

        print("Payload is :{}".format(payload))

        logger.console("payload:-" + str(payload))
        return pcc.add_policy(conn, payload)
Esempio n. 37
0
 def __on_response_remote_config(self, client, userdata, msgtop):
     """ on_response_remote_config """
     logger.console(self._tag + "on_response_remote_config called")
     if self._msg_id != msgtop.message_head.message_id:
         logger.warn(self._tag + "on_response_remote_config: Not expected msg_id")
         return
     if msgtop.HasField("remote_config_result"):
         # TODO: Handle receive mulit-config_items
         for config in msgtop.remote_config_result.config_results:
             self._result = config.result
         self._event.set()
 def write_msg(self, basic):
     msg = TPCANMsg()
     msg.ID = basic.get_id()
     msg.LEN = basic.get_length()
     msg.MSGTYPE = PCAN_MESSAGE_STANDARD
     data = basic.encode()
     for i in range(msg.LEN):
         msg.DATA[i] = int(data[i], 16)
     result = self._pcanbasic.Write(self._channel, msg)
     if result != PCAN_ERROR_OK:
         logger.console("write_msg: " + self.__get_formated_error(result))
Esempio n. 39
0
    def execute_command(self, sandbox_id, resource_name, command_name, params):

        logger.console(resource_name)
        headers = self._get_headers(self.auth_token)
        component_url = self._get_component_url(self.api_v2, headers,
                                                sandbox_id, resource_name)
        execution_url = self._start_execution(self.api_v2, headers,
                                              component_url, command_name,
                                              params)
        return self._get_execution_result(self.api_v2, headers,
                                          execution_url)['output']
Esempio n. 40
0
def get_variables(environment, on_demand, browser):
    variables = {"Environment": environment,
                 "On Demand": on_demand,
                 "Browser": browser
                 }

    passedENV = str(environment).upper()
    print passedENV
    ondem = str(on_demand).upper()
    # browser= str(browser).upper()
    print ondem
    print browser

    if (passedENV.upper() == 'LOCAL'):
        url = 'localhost:10088'
        adminurl = 'localhost:9090'

    elif(passedENV == 'PROD'):
         url = 'https://arcade.rally.com'

    else:
        url = 'https://' + passedENV.lower() + '-arcade.werally.in'

    print   "url is" +url


    ENVS = {

        'RALLY_TEST_URL': url
    }

    print   url
    # Checks to see if the Environment and OnDemand variables are used
    if re.match('\\$\\{.*\\}', ondem) != None:
        env = COMMON.keys()[0]
        logger.info(msg_prefix + 'Unresolved variable passed in, defaulting to ' + ondem)
    if not COMMON.has_key(ondem):
        raise Exception(
            'Undefined on demand: ' + str(on_demand) + '. Try one of these: ' + ', '.join(
                sorted(COMMON.keys())))

    logger.info(msg_prefix + 'Defining arcade web variables for environment ' + passedENV)
    logger.console(msg_prefix + 'Defining arcade web variables for environment ' + passedENV)

    if  ondem == 'FALSE':
       print    "ondem" +ondem
       print        dict(list(COMMON[ondem].items()))
       print        list(ENVS.items())
       return       dict(list(COMMON[ondem].items()) +list(ENVS.items()))
    else:
        print    "ondem" +ondem
        print     dict(list(COMMON[ondem][browser].items()) +list(ENVS.items()))
        return    dict(list(COMMON[ondem][browser].items()) +list(ENVS.items()))
Esempio n. 41
0
 def init_serialrobot(self,port,baudrate=115200,timeout=0.5):
     '''open serialcom and init serialrobot'''
     ret = 0
     try:
         port = str(port)
         baudrate = int(baudrate)
         super(serialrobot,self).__init__(port, baudrate,timeout=timeout)
     except (serial.SerialException,serial.portNotOpenError),e:
         logger.console("%s cant't be opened" % port)
         print "port %s" % port,type(port)
         print "baudrate %s" % baudrate, type(baudrate)
         ret = -1
Esempio n. 42
0
    def setup_framework(self, nodes):
        """Pack the whole directory and extract in temp on each node."""

        tarball = self.__pack_framework_dir()
        logger.console('Framework packed to {0}'.format(tarball))
        remote_tarball = "/tmp/{0}".format(basename(tarball))

        for node in nodes.values():
            self.__copy_tarball_to_node(tarball, node)
            self.__extract_tarball_at_node(remote_tarball, node)

        logger.trace('Test framework copied to all topology nodes')
        self.__delete_local_tarball(tarball)
Esempio n. 43
0
    def __extract_tarball_at_node(self, tarball, node):
        logger.console('Extracting tarball to {0} on {1}'.format(
            con.REMOTE_FW_DIR, node['host'])) 
        ssh = SSH()
        ssh.connect(node)

        cmd = 'rm -rf {1}; mkdir {1} ; sudo -Sn tar -zxf {0} -C {1};'.format(
                tarball, con.REMOTE_FW_DIR)
        (ret_code, stdout, stderr) = ssh.exec_command(cmd, timeout=30)
        if 0 != ret_code:
            logger.error('Unpack error: {0}'.format(stderr))
            raise Exception('Failed to unpack {0} at node {1}'.format(
                tarball, node['host']))
Esempio n. 44
0
    def send_command(self,command,pass_args=[],fail_args=[],timeout=0,wait_idle=1):
        """
        send command

        cmd: command will send to serialcom. It represents key maps if starting with '@'

        exec_env: command running environment. LINUX or UBOOT

        pass_arg: serilrobot will return index+1,successful,when detect these
        strings.Multiple strings separated by ';'. "SKIP" means skip this field.

        fail_arg: serilrobot will return -(index+1),fail,when detect these strings.
        Multiple strings separated by ';'."SKIP" means skip  this field.

        timeout_arg: serialrobot will interrupt command after timeout
        """

        if not self.port_valid:
            logger.console("port isn't available,skip command: %s" % command)
            raise RuntimeError

        cmd = command.encode('ascii','ignore')
        pass_args = pass_args.encode('ascii','ignore')
        fail_args = fail_args.encode('ascii','ignore')
        timeout = timeout if isinstance(timeout,int) else int(timeout)
        wait_idle = wait_idle if isinstance(wait_idle,int) else int(wait_idle)
        if pass_args.upper() == "SKIP" or pass_args == "":
            pset = []
        else:
            pset = pass_args.split(';')

        if fail_args.upper() == "SKIP" or fail_args == "":
            fset = []
        else:
            fset = fail_args.split(';')

        print "-" * 20
        print "[%s]" % cmd
        print pset
        print fset
        print "timeout = %d" % timeout
        print "wait  = %d" % wait_idle

        if wait_idle:
            self._wait_port_idle()
        ret = self._send_cmd(cmd, pset, fset, timeout)
        if ret == 0:
            logger.info("command:%s timeout;send ctrl + c to stop!!" % cmd)
            self.send_ctrl_c()

        return ret
Esempio n. 45
0
    def run_task(self, task_name, **options):
        """ Runs a named CumulusCI task for the current project with optional
            support for overriding task options via kwargs.

            Examples:
            | =Keyword= | =task_name= | =task_options=             | =comment=                        |
            | Run Task  | deploy      |                            | Run deploy with standard options |
            | Run Task  | deploy      | path=path/to/some/metadata | Run deploy with custom path      |
        """
        task_config = self.project_config.get_task(task_name)
        class_path = task_config.class_path
        logger.console("\n")
        task_class, task_config = self._init_task(class_path, options, task_config)
        return self._run_task(task_class, task_config)
Esempio n. 46
0
def ColOutputDirect():
    Login_To(NN_IP,un="admin",pw="admin@123")
    var = robo.get_variable_value("${shellPrompt}")
    ssh.set_client_configuration(prompt=var)
    adaptors = []
    ssh.write("echo 'show running-config'|/opt/tms/bin/cli -m config")
    output = ssh.read_until_prompt() 
    for line in output.splitlines():
        line = line.strip()
        if line.find("collector modify-instance 1 add-adaptor ipfix") != -1:
           logger.console("Got ipfix as adaptors")
           items = line.split(" ")
           if items[4] == "ipfix":
               
               logger.console(adaptors)
               if "ipfix" in adaptors:
                   logger.console("Ipfix configured")
                   if line.find("collector modify-instance 1 modify-adaptor ipfix output-directory") != -1:
                      items = line.split(" ")
                      output_directory = items[6]
        else:
            adaptors.append(items[4])
            logger.console("Inside else part")
            if "ipfix" in adaptors == -1:
                   #ConfigureCollector()
                output_directory = "/data/collector"
    print output_directory
    return output_directory
    def AppStart(self,appName):
        if appName == "Acume":
           ssh.write("pm process rubix restart")
           ssh.write("rubix status")
           output = ssh.read_until_prompt()
           logger.console(output)
           
        
        
    
        #print ssh.close_connection()               
#if  __name__ == "__main__":
#    a = RPMSetupConfigure()
#    a.cleanRPMmachine()
    def get_port_pid(self, port):
        """根据参数中的端口号查找对应使用该端口号的进程ID,并返回该进程的PID号。
        """

        get_pid_cmd = "netstat -ano | findstr  LISTENING | findstr " + str(port)
        appium_pid_str = os.popen(get_pid_cmd).read()
        
        if appium_pid_str:
            appium_g = appium_pid_str.split(' ')
            logger.console("Process about port " + str(port) + " have existed, is " + appium_g[-1] + ".", True, 'stdout')
            return appium_g[-1]
        else:
            logger.console("No process about port " + str(port) + "!", True, 'stdout')
            return None
    def stop_tookit(self, toolniki):
        """停止测试工具,例如本地 Appium
        """

        if "appium" == toolniki:
            pid = self.get_port_pid(config.APPIUMPORT)
            logger.info("Going to stop local appium, pid: ."+str(pid), also_console=True)
            stop_appium_cmd = "tskill " + str(pid)
            child = subprocess.Popen(stop_appium_cmd, shell=True)

            child.wait()
            return child.pid
        else:
            logger.console("No other tools to use.")
Esempio n. 50
0
 def connect_to_target(self, host, username, password):
     target = _Target(host, username, password)
     i = 0
     while not target.conn_open:
         try:
             target.conn.open_connection(target.host, "cla", target.properties['port'])
             target.conn_open = True
         except Exception, error:
             i += 1
             msg = 'Opening connection to %s  failed: ' % HOST + str(error)
             if error[0] == self.CONNECTION_REFUSED and i < target.properties['max_conn_attempts']:
                 logger.console("Trying to reconnect in 5 seconds")
                 time.sleep(5)
             else:
                 raise AssertionError(msg)
Esempio n. 51
0
def hadoopEpochValue():
    Login_To(NN_IP,un="admin",pw="admin@123")
    var = robo.get_variable_value("${shellPrompt}")
    ssh.set_client_configuration(prompt=var)
    conf = HAdoopConf()
    host_mapping = IpHostName()
    EpochValues = {}
    for i in conf["journal"]:
                output = executeRemote("cat /data/yarn/journalnode/%s/current/last-promised-epoch"%conf["nameservice"], host_mapping[i])
                match = re.search(r'^(\d).*',output)
                lastPromisedEpoch = match.group(1)
                logger.console(i)
                EpochValues[i] = lastPromisedEpoch
    epochValue_nodes = set(tuple(str(k)) for k in EpochValues.values())
    logger.console(epochValue_nodes)
Esempio n. 52
0
    def get_webdriver_remote(self):
        remote_url = self.get_remote_url()
        session_id = self.get_session_id()

        s = 'from selenium import webdriver;' \
            'd=webdriver.Remote(command_executor="%s",' \
            'desired_capabilities={});' \
            'd.session_id="%s"' % (
                remote_url,
                session_id
            )

        logger.console("\nDEBUG FROM CONSOLE\n%s\n" % (s))
        logger.info(s)

        return s
Esempio n. 53
0
    def run_task_class(self, class_path, **options):
        """ Runs a CumulusCI task class with task options via kwargs.

            Use this keyword to run logic from CumulusCI tasks which have not
            been configured in the project's cumulusci.yml file.  This is
            most useful in cases where a test needs to use task logic for
            logic unique to the test and thus not worth making into a named
            task for the project

            Examples:
            | =Keyword=      | =task_class=                     | =task_options=                            |
            | Run Task Class | cumulusci.task.utils.DownloadZip | url=http://test.com/test.zip dir=test_zip |
        """
        logger.console("\n")
        task_class, task_config = self._init_task(class_path, options, TaskConfig())
        return self._run_task(task_class, task_config)
 def ConfigureOozie(self):
     self.LoginTo(self.oozie_ip)
     print self.Namenode_ip[0]
     #if self.oozie_ip == self.Namenode_ip[0]:
     #self.CreateReflexUser(self.oozie_ip)
     ssh.write("rpm -qa | grep reflex-workflowmanager")
     output = ssh.read_until_prompt(loglevel="DEBUG")
     if output.find("reflex-workflowmanager") == -1:
         ssh.write("yum install -y reflex-workflowmanager")
         output = ssh.read_until_prompt(loglevel="DEBUG")
         logger.console(output)
     self.SwitchToReflex()
     logger.info("Configuring oozie on %s"%self.oozie_ip,also_console=True)
     ssh.write("pmx register oozie")
     output = ssh.read_until_prompt()
     logger.info(output , html=True, also_console=True)
Esempio n. 55
0
def conf():
    var = robo.get_variable_value("${shellPrompt}")
    ssh.set_client_configuration(prompt=var)
    ssh.write("echo 'show hosts'|/opt/tms/bin/cli -m config ")
    output = ssh.read_until_prompt()
    ip_mapping = {}
    hadoop_conf = {}
    clients = []
    journalnodes = []
    slaves = []
    for i in output.splitlines():
        match = re.search('(?P<ipAddress>\d{0,3}\.\d{0,3}\.\d{0,3}\.\d{0,3})\s+-->(?P<hostname>.*)$',i)
        if match:
            ip_mapping[match.group("hostname")] = match.group("ipAddress")
    ssh.write("echo 'internal query iterate subtree  /tps/process/hadoop_yarn/attribute'|/opt/tms/bin/cli -m config")
    output = ssh.read_until_prompt()
    for line in output.splitlines():
        if line.find("/tps/process/hadoop_yarn/attribute/client/values") != -1:
            client = line.split("=")[1].strip("(string)").strip()
            clients.append(client)
        elif line.find("/tps/process/hadoop_yarn/attribute/config_ha/value") != -1:
            value = line.split("=")[1].strip("(string)").strip()
            hadoop_conf["config_ha"] = value
        elif line.find("/tps/process/hadoop_yarn/attribute/journalnodes/values") != -1:
            journal = line.split("=")[1].strip("(string)").strip()
            journalnodes.append(journal)
        elif line.find("/tps/process/hadoop_yarn/attribute/namenode1/value") != -1:
            value = line.split("=")[1].strip("(string)").strip()
            hadoop_conf["namenode1"] = value
        elif line.find("/tps/process/hadoop_yarn/attribute/namenode2/value") != -1:
            value = line.split("=")[1].strip("(string)").strip()
            hadoop_conf["namenode2"] = value
        elif line.find("/tps/process/hadoop_yarn/attribute/nameservice/value") != -1:
            value = line.split("=")[1].strip("(string)").strip()
            hadoop_conf["nameservice"] = value
        elif line.find("/tps/process/hadoop_yarn/attribute/slave/values") != -1:
            slave = line.split("=")[1].strip("(string)").strip()
            slaves.append(slave)
        elif line.find("/tps/process/hadoop_yarn/attribute/state/value") != -1:
            value = line.split("=")[1].strip("(string)").strip()
            hadoop_conf["state"] = value
            
    hadoop_conf["client"] = clients
    hadoop_conf["journal"] = journalnodes
    hadoop_conf["slaves"] = slaves
    logger.console(hadoop_conf)
Esempio n. 56
0
    def send_command_get_output(self,command,timeout=2,wait_idle=0):
        """
        hello
        """

        if not self.port_valid:
            logger.console("port isn't available,skip command: %s" % command)
            raise RuntimeError

        cmd = command.encode('ascii','ignore')
        timeout = timeout if isinstance(timeout,int) else int(timeout)
        wait_idle = wait_idle if isinstance(wait_idle,int) else int(wait_idle)

        if wait_idle:
            self._wait_port_idle()
        ret = self._send_cmd_get_output(cmd, timeout)

        return ret
 def ConfigureCluster(self): 
     logger.console(self.clusterNodes)
     ClusterNodes_ip  = self.clusterNodes  
     for node in ClusterNodes_ip:
         self.LoginTo(node)
         logger.info("Configuring Cluster on %s"%node,also_console=True)
         ssh.write("id")
         line = ssh.read_until_prompt()
         logger.console(line)
         self.CreateReflexUser(node)
         self.SwitchToReflex()
         self.cliPrompt(cluster="no")
         ssh.write("cluster expected-nodes 2")
         ssh.write("cluster interface eth0")
         ssh.write("cluster id %s"%self.clusterid)
         ssh.write("cluster name %s"%self.clusterid)
         ssh.write("cluster master address vip %s /24"%self.cluster_vip)
         ssh.write("cluster master interface eth0")
         ssh.write("cluster enable")
 def ConfigureNN(self):
     logger.console("Configuring Namenode on %s"%self.configs["Namenode_IP"])
     Namenodes_ip = self.configs["Namenode_IP"]
     for node in Namenodes_ip:
         #logger.info(node,also_console=True)
         #self.cleanRPMmachine(node)
         self.LoginTo(node)
         logger.info("Now installing rpms and configuring Namenode Machine on %s"%node,also_console=True)
         ssh.write("id")
         line = ssh.read_until_prompt()
         logger.console(line)
         
         self.CreateReflexUser(self.gms_ip)
                 
         #self.SwitchToReflex()
         #logger.console()
         logger.info("Installing reflex-etc-tmo on %s"%node,also_console=True)
         ssh.write("yum install -y reflex-etc-tmo")
         output = ssh.read_until_prompt()
         logger.info("Installing reflex-hadoop-namenode on %s"%node,also_console=True)
         ssh.write("yum install -y reflex-hadoop-namenode")
         #ssh.write("yum install -y hadoop")
         output = ssh.read_until_prompt()
         
         self.SwitchToReflex()
         self.ReflexKeysGeneration()
         logger.info("Configuring Yarn on %s"%node,also_console=True)
         ssh.write("pmx register hadoop_yarn")
         ssh.write("pmx set hadoop_yarn config_ha False")
         ssh.write("pmx set hadoop_yarn monitor ON")
         ssh.write("pmx set hadoop_yarn namenode1 rpm-nn-102")
         ssh.write("pmx set hadoop_yarn state UNINIT")
         ssh.write("pmx set hadoop_yarn client %s"%self.collector_ip)
         ssh.write("pmx set hadoop_yarn slave %s"%self.datanodes_ip[0])
         ssh.write("pmx set hadoop_yarn slave %s"%self.datanodes_ip[1])
         ssh.write("pmx set hadoop_yarn dnprofile compute_RPM_NN")
         output = ssh.read_until_prompt()
         logger.console(output)
         ssh.write("pmx set hadoop_yarn queue.default.capacity 50") 
         output = ssh.read_until_prompt()
         logger.console(output)     
         ssh.write("pmx set hadoop_yarn queue.default.maximum_capacity 100")
         ssh.write("pmx set hadoop_yarn queue.query.capacity 20")        
         ssh.write("pmx set hadoop_yarn queue.query.maximum_capacity 100")  
         ssh.write("pmx set hadoop_yarn queue.rge.capacity  30")          
         ssh.write("pmx set hadoop_yarn queue.rge.maximum_capacity 100")    
         ssh.write("pmx set hadoop_yarn yarn.scheduler.maximum-allocation-mb 81920")
         ssh.write("pmx subshell hadoop_yarn set config dnprofile compute_RPM_NN attribute property yarn.nodemanager.resource.cpu-vcores 40")
         ssh.write("pmx subshell hadoop_yarn set config dnprofile compute_RPM_NN attribute property yarn.nodemanager.vmem-pmem-ratio 4")
         ssh.write("pmx subshell hadoop_yarn set config dnprofile compute_RPM_NN attribute property yarn.nodemanager.resource.memory-mb 81920")
         output = ssh.read_until_prompt()
         logger.info(output) 
         ssh.write("exit")
    def load_fixture(self, fixture):
        """Load a Django fixture into the database.
        """
        args = [
            'python',
            self.manage,
            'loaddata',
            '%s' % (fixture),
            '--settings=%s' % self.settings,
        ]

        out = subprocess.Popen(
            args,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
        )
        stdout, stderr = out.communicate()
        if stderr:
            logger.console(stderr)
        else:
            logger.console(stdout)