Esempio n. 1
0
    def i_get_the_first_search_record_containing_keyword(
            self, keyword
    ):
        assert isinstance(
            self.search_results_page, SearchResultsPage
        ), 'The search results page is displayed'

        bag_of_keywords = str.split(
            self.search_results_page.text_of_first_record.lower()
        )

        if (bag_of_keywords[0] in keyword.lower()) or (
                bag_of_keywords[-1] in keyword.lower()
        ):
            logger.info(
                'Succeed on searching keyword within bing.com',
                # html=True
            )
        else:
            logger.error(
                '"{}" not in "{}"'.format(
                    keyword,
                    self.search_results_page.text_of_first_record
                ),
                html=True
            )
    def reset_android(self, pro_alias=None, remote_url=None ):
        """重置android设备"""

        # 重启android设备
        ret_reb = os.popen("adb shell reboot").read()
        is_null = (len(ret_reb) == 0)
        if is_null:
                logger.info(self._getcurtm()+": Succeed rebooting android device.", also_console=True)
        else:
            logger.error(ret_reb)
            return -1
            
        # 等待android设备重新连接

        ret_val = subprocess.Popen("adb wait-for-device", shell=True)
        ret_val.wait()

        if ret_val.stdout is None:
            ret_dev = os.popen('adb devices').read()
            logger.info(self._getcurtm() + ": Android device named: "+ ret_dev.split('\n')[1].split('\t')[0] +
                        " connected.", also_console=True)
            time.sleep(15)
            logger.info(self._getcurtm() + ": Sleep 10 to wait return.", also_console=True)
            return None
        else:
            # logger.error(pro_alias + " "+ test_str(adbPid[4]) + " process fail to kill!")
            logger.error(self._getcurtm() + ": Android device connected timeout.")
            return -1
    def image_self_check(self):
        if os.path.isfile(self.get_convert_path):
            logger.info("Convert file exits path, path used :" + self.get_convert_path)
        else:
            message = "Missing file convert.exe"
            raise AssertionError(message)

        if os.path.isfile(self.get_compare_path):
            logger.info("Compare file exits , path used :" + self.get_compare_path)
        else:
            message = "Missing file compare.exe"
            raise AssertionError(message)

        if os.path.isfile(self.get_identify_path):
            logger.info("Identify file exits, path used :" + self.get_identify_path)
        else:
            message = "Missing file identify.exe"
            raise AssertionError(message)

        argument_list = [self.get_convert_path, "--version"]
        try:
            procces = subprocess.Popen(argument_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE)  # , shell=True
            procces.wait()
            output = procces.communicate()
            logger.info("returnCode \t:" + str(procces.returncode))
            if procces.returncode != 0:
                message = "processing failed msg= %s" % str(output)
                raise AssertionError(message)
            logger.info("stdout \t:" + str(output[0]))
            logger.info("stderr \t:" + str(output[1]))

        except OSError as e:
            logger.error(e)
 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 _quit(self, driver, error):
     try:
         driver.quit()
     except Exception as exception:
         logger.error('When closing browser, received exception: %s' % exception)
         error = exception
     return error
Esempio n. 6
0
 def clico_boton_iniciar_sesion(self):
     """ Hace click sobre el botón 'Iniciar Sesion' ubicado en la cabecera de la página principal """
     try:
         boton_sesion = self.driver.find_element_by_xpath("//span[@class='icono iniciarSesion']")
         boton_sesion.click()
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format("Icono iniciar sesion"))
         raise Exception(e.msg)
Esempio n. 7
0
 def clico_sobre_boton_descargar(self):
     """ Clica directamente sobre el botón descargar """
     try:
         area_detalle = self.driver.find_element_by_xpath("//div[@class='listadoElementos programas grande']")
         area_detalle.click()
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format("Descargar"))
         raise Exception(e.msg)
Esempio n. 8
0
 def aparece_mensaje_texto_que_dice(self, texto):
     """ Busca una coincidencia con el mensaje que aparece justo después de la cabecera """
     try:
         mensaje = self.driver.find_element_by_xpath("//h1")
         assert texto in mensaje.text, "'%s' no coincide con el texto encontrado '%s'" %(texto, mensaje)
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format('Texto: ' + texto))
         raise Exception(e.msg)
Esempio n. 9
0
 def clico_sobre_link_con_texto(self, nombre_link):
     """ Clica sobre el link con el texto que indica el usuario """
     try:
         enlace = self.driver.find_element_by_link_text(nombre_link)
         enlace.click()
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format('Link: ' + nombre_link))
         raise Exception(e.msg)
Esempio n. 10
0
 def activo_el_check_con_nombre(self, nombre):
     """ Activa un check dado su nombre """
     try:
         checkbox = self.driver.find_element_by_name(nombre)
         checkbox.click()
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format('Name: ' + nombre))
         raise Exception(e.msg)
    def check_if_key_not_exits(self, db_name, proto_id):
        global mom
        global proto

        db = db_name_convert(db_name)
        if mom[db_name].exists(db, proto[proto_id]) == 0:
            logger.error("Key " + proto_id + " exist in Redis.")
            raise AssertionError
Esempio n. 12
0
	def connect_to_database(self, dbServer, dbUser, dbPass, dbDatabase, dbPort=1433, dbQTimeout=0, dbLoginTimeout=60, charSet='UTF-8'):
		'''
			Connect to database. Must be called before calling any query actions.
		'''
		try:
			self._dbconnection = pymssql.connect(server=dbServer, user=dbUser, password=dbPass, database=dbDatabase, port=int(dbPort), timeout=int(dbQTimeout), login_timeout=int(dbLoginTimeout), charset=charSet, as_dict=False)
			return self._dbconnection
		except Exception as e: logger.error(e)
Esempio n. 13
0
    def clico_en_salir(self):
	""" Cierra sesión de usuario mediante URL """
        try:
            url = 'http://www.portalprogramas.com/comunidad/cerrarSesion'
            self.driver.get(url)
        except (TimeoutException, NoSuchElementException) as e:
            logger.error(ELEMENT_NOT_FOUND.format(url))
            raise Exception(e.msg)
Esempio n. 14
0
 def clico_sobre_icono_lupa(self):
     """ Clica sobre el botón con icono lupa """
     try:
         form = self.driver.find_element_by_xpath("//form")
         barra_busqueda = form.find_element_by_xpath("//input[@class='botonBuscar busb']")
         barra_busqueda.click()
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format("Lupa/Buscar"))
         raise Exception(e.msg)
Esempio n. 15
0
 def compruebo_que_aparece_mensaje_despues_de_busqueda(self, mensaje):
     """ Localiza mensaje que aparece justo después de la barra de búsqueda sea igual al que buscamos """
     try:
         # cabecera = self.driver.find_element_by_xpath("//div[contains(@class, 'grid_12 tituloSEO inner mini vertical')]/descendant::h1")
         cabecera = self.driver.find_element_by_xpath("//div[@class='inner mini mobileMarginTop']/descendant::h1")
         assert mensaje.lower() in cabecera.text.lower(), ELEMENT_NOT_FOUND.format(mensaje)
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format(mensaje))
         raise Exception(e.msg)
Esempio n. 16
0
 def compruebo_texto_registro_incorrecto(self):
     """ Localiza el cuadro de texto que aparece cuando se ha producido un registro correcto """
     try:
         mensaje = 'No se encuentra cuadro de texto'
         cabecera = self.driver.find_element_by_xpath("//div[contains(@class, 'alert')]")
         assert cabecera.is_displayed(), ELEMENT_NOT_FOUND.format(mensaje)
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format(mensaje))
         raise Exception(e.msg)
    def sismember_to_redis(self, db_name, proto_id):
        global mom
        global proto

        db = db_name_convert(db_name)
        result = mom[db_name].sismember(db, proto[proto_id], 1)
        if result is None:
            logger.error(result)
        return result
Esempio n. 18
0
 def clico_boton_con_nombre(self, nombre_boton):
     """ Dado el nombre de un botón lo localiza y hace click sobre él """
     try:
         boton = self.driver.find_element_by_xpath("//input[@value='" + nombre_boton + "']")
         boton.submit()
         time.sleep(1)
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(ELEMENT_NOT_FOUND.format("Boton: " + nombre_boton))
         raise Exception(e.msg)
Esempio n. 19
0
 def relleno_campo_busqueda_con_el_texto(self, texto):
     """ Rellena el campo de búsqueda con el texto dado """
     try:
         form = self.driver.find_element_by_xpath('//form')
         campo_busqueda = form.find_element_by_xpath("//input[@id='busqueda']")
         campo_busqueda.clear()
         campo_busqueda.send_keys(str(texto))
     except (TimeoutException, NoSuchElementException) as e:
         logger.error(FIELD_NOT_FOUND.format('Busqueda'))
         raise Exception(e.msg)
Esempio n. 20
0
 def hago_click_sobre_icono_seleccionar_plataforma(self):
     """ Hace click directamente sobre el icono de los sistemas operativos de la barra de búsqueda"""
     try:
         form = self.driver.find_element_by_xpath("//form")
         barra_busqueda = form.find_element_by_xpath(
             ".//input[@id='opcionMenuSelected_mac'] and //span[@class='icono verMas']"
         )
         barra_busqueda.click()
     except TimeoutException as e:
         logger.error(PLATFORM_NOT_FOUND.format(str("Busqueda")))
         raise Exception(e.msg)
Esempio n. 21
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. 22
0
 def aparece_mensaje_error_mail(self, texto_error):
     """ Localiza el mensaje de error que devuelve el campo del email"""
     try:
         label_error = self.driver.find_element_by_xpath("//p[@class='colorRojo']")
         assert texto_error in label_error.text, "Textos no coinciden %s != %s" % (texto_error, label_error.text)
     except (TimeoutException, NoSuchElementException) as e:
         fichero = 'email_incorrecto' + str(randint(0, 9999)) + '.png'
         self.driver.get_screenshot_as_file(fichero)
         # si hay algún error cerramos sesión del usuario logueado para que no afecte al resto de pruebas
         self.driver.get('http://www.portalprogramas.com/comunidad/cerrarSesion')
         logger.error(ELEMENT_NOT_FOUND.format('class: colorRojo'))
         raise Exception('Compruebe captura pantalla con el error: ' + fichero)
Esempio n. 23
0
    def setup_dut(self, node):
        ssh = SSH()
        ssh.connect(node)

        ssh.scp('resources/libraries/bash/dut_setup.sh', '/tmp/dut_setup.sh')
        (ret_code, stdout, stderr) = \
            ssh.exec_command('sudo -Sn bash /tmp/dut_setup.sh')
        logger.trace(stdout)
        if 0 != int(ret_code):
            logger.error('DUT {0} setup script failed: "{1}"'.
                    format(node['host'], stdout + stderr))
            raise Exception('DUT test setup script failed at node {}'.
                    format(node['host']))
Esempio n. 24
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']))
 def get_from_redis(self, db_name, proto_id, dict_fields):
     global mom
     global proto
     
     db = db_name_convert(db_name)
     result = mom[db_name].get(db, proto[proto_id], 1)
     GETPROTO[proto_id] = result
     if result is None:        
         logger.error(result)
         return {}
     else:
         for field in dict_fields:
             dict_fields[field] = analyse_result(result, field, dict_fields)
         return dict_fields
    def setup_xml(self, test_name="", user_pin="123456", so_pin="12345678", loop_times="", data_len=""):
        """
        Setup the xml file:data.xml, config param include test_name, user_pin, so_pin, loop_times,
        data_len.
        example:
        | setup xml | test_name | user_pin | so_pin | loop_times | data_len |
        | setup xml | 101 | 123456 | 12345678 | 50 | 32 |
        """

        if os.path.exists(PATH(r"../res/data.xml")):
            os.remove(PATH(r"../res/data.xml"))

        doc = minidom.Document()
        doc.standalone = True
        root_node = doc.createElement("root")
        doc.appendChild(root_node)
        test_node = doc.createElement("Test")
        # book_node.setAttribute("isbn", "34909023")
        root_node.appendChild(test_node)
        test_name_node = doc.createElement("Testname")
        user_pin_node = doc.createElement("Userpin")
        so_pin_node = doc.createElement('Sopin')
        loop_times_node = doc.createElement('Looptimes')
        data_len_node = doc.createElement('Datalen')
        test_node.appendChild(test_name_node)
        test_node.appendChild(user_pin_node)
        test_node.appendChild(so_pin_node)
        test_node.appendChild(loop_times_node)
        test_node.appendChild(data_len_node)
        test_name_text_node = doc.createTextNode(test_name)
        test_name_node.appendChild(test_name_text_node)
        user_pin_text_node = doc.createTextNode(user_pin)
        user_pin_node.appendChild(user_pin_text_node)
        so_pin_text_node = doc.createTextNode(so_pin)
        so_pin_node.appendChild(so_pin_text_node)
        loop_times_text_node = doc.createTextNode(loop_times)
        loop_times_node.appendChild(loop_times_text_node)
        data_len_text_node = doc.createTextNode(data_len)
        data_len_node.appendChild(data_len_text_node)
        # doc.writexml(f, "/t", "/t", "/n", "utf-8")
        f = open(PATH(r"../res/data.xml"), "w")
        test_node.toprettyxml(encoding="utf-8")
        doc.writexml(f, encoding="utf-8")
        f.close()

        if os.path.exists(PATH(r"../res/data.xml")):
            logger.info("Setup xml file successfully.")
        else:
            logger.error("Failed to setup xml file.")
            return -1
 def ConfigureGMS(self):
     logger.console(self.configs["gms_ip"])
     self.LoginTo(self.configs["gms_ip"])
     #self.cleanRPMmachine()
     logger.info("Now installing rpms and configuring gms-server on %s"%self.gms_ip, also_console=True)
     ssh.write("id")
     line = ssh.read_until_prompt()
     #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)
         line = ssh.read_until_prompt()
         #ssh.write("yum install -y reflex-tm")
         #ssh.write("yum install -y reflex-gms")
         line = ssh.read_until_prompt()
         logger.info(line,also_console=True)
     else:
     '''
     self.CreateReflexUser(self.gms_ip)
     ssh.write("yum install -y reflex-gms")
     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-gms already installed", newline="yes", stream="stdout")
         elif line.find("failed") != -1:
                 logger.console("reflex-gms 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-GMS installed successfully",also_console=True)
     
     #logger.info("Switching to reflex user on %s"%self.gms_ip, also_console=True)
     #check reflex rpm also. Not remembered why ??
     ssh.write("service httpd restart")
     output = ssh.read_until_prompt()
     logger.info(output, html=True, also_console=False)
     self.SwitchToReflex()
     self.ReflexKeysGeneration()
     self.cliPrompt()
     ssh.write("pgsql mode external")
     ssh.write("pm process pgsqld restart")
     ssh.write("pm process gms_server restart")
 def connect_to_redis(self, db_name):
     global mom
     global glb
     
     try:
         if glb == None:
             glb = RgGlobal('RF_demo')
         db = db_name_convert(db_name)
         if glb.connect_sync(db) != 0:
             sys.exit()
         mom[db_name] = RgMomSync(glb)
     except Exception as ex:
         logger.error(str(ex))
         raise Exception(str(ex))
Esempio n. 29
0
 def get_net_settings(self, port):
     if port.upper() == "LAN":
         s = self.pwc.get_lan_status()
     elif port.upper() == "WAN":
         s = self.pwc.get_wan_status()
     else:
         logger.error("port: %s not defined." % (port))
         raise ValueError
     settings = super(APWL_PortalWebBase, self)._DS_Net_Settings(
         connection_status=s['connection_status'],
         ip_address=s['ip_address'],
         subnet_mask=s['subnet_mask'],
         mac_address=s['mac_address'],
         dns_server=s['dns_server'])
     return settings
    def _get_info_for_image(self, file_name):
        argument_list = [self.get_identify_path, "-quiet", "-format", "%[fx:w]\\n%[fx:h]", file_name]
        try:
            procces = subprocess.Popen(argument_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE)  # , shell=True
            procces.wait()
            output = procces.communicate()
            if procces.returncode != 0:
                message = "processing failed msg= %s" % str(output)
                raise AssertionError(message)

            # logger.info("file Name \t:" + file_name+str(output))
            table_results = output[0].split()
            return table_results[0], table_results[1]
        except OSError as e:
            logger.error(e)
Esempio n. 31
0
    def scp_and_execute_script(self,
                               vat_name,
                               node,
                               timeout=15,
                               json_out=True):
        """Copy vat_name script to node, execute it and return result.

        :param vat_name: Name of the vat script file.
        Full path and name of the script is required.
        :param node: Node to execute the VAT script on.
        :param timeout: Seconds to allow the script to run.
        :param json_out: Require JSON output.
        :type vat_name: str
        :type node: dict
        :type timeout: int
        :type json_out: bool
        :returns: Status code, stdout and stderr of executed VAT script.
        :rtype: tuple
        :raises RuntimeError: If VAT script execution failed.
        """

        ssh = SSH()
        try:
            ssh.connect(node)
        except:
            raise SSHException("Cannot open SSH connection to execute VAT "
                               "command(s) from template {0}".format(vat_name))

        ssh.scp(vat_name, vat_name)

        cmd = "sudo -S {vat} {json} in {input} script".format(
            json="json" if json_out is True else "",
            vat=Constants.VAT_BIN_NAME,
            input=vat_name)

        try:
            (ret_code, stdout, stderr) = ssh.exec_command(cmd, timeout)
        except SSHTimeout:
            logger.error("VAT script execution timeout: {0}".format(cmd))
            raise
        except:
            raise RuntimeError("VAT script execution failed: {0}".format(cmd))

        self._ret_code = ret_code
        self._stdout = stdout
        self._stderr = stderr

        self._delete_files(node, vat_name)
Esempio n. 32
0
def exec_cmd(node, cmd, timeout=600, sudo=False, disconnect=False):
    """Convenience function to ssh/exec/return rc, out & err.

    Returns (rc, stdout, stderr).

    :param node: The node to execute command on.
    :param cmd: Command to execute.
    :param timeout: Timeout value in seconds. Default: 600.
    :param sudo: Sudo privilege execution flag. Default: False.
    :param disconnect: Close the opened SSH connection if True.
    :type node: dict
    :type cmd: str or OptionString
    :type timeout: int
    :type sudo: bool
    :type disconnect: bool
    :returns: RC, Stdout, Stderr.
    :rtype: tuple(int, str, str)
    """
    if node is None:
        raise TypeError(u"Node parameter is None")
    if cmd is None:
        raise TypeError(u"Command parameter is None")
    if not cmd:
        raise ValueError(u"Empty command parameter")

    ssh = SSH()

    try:
        ssh.connect(node)
    except SSHException as err:
        logger.error(f"Failed to connect to node {node[u'host']}\n{err!r}")
        return None, None, None

    try:
        if not sudo:
            ret_code, stdout, stderr = ssh.exec_command(cmd, timeout=timeout)
        else:
            ret_code, stdout, stderr = ssh.exec_command_sudo(
                cmd, timeout=timeout
            )
    except SSHException as err:
        logger.error(repr(err))
        return None, None, None
    finally:
        if disconnect:
            ssh.disconnect()

    return ret_code, stdout, stderr
Esempio n. 33
0
    def create_new_vulnerability(self, vul_dict):
        url = "{}/api/vulnerability/create".format(self.threatplaybook)
        if 'scan' not in vul_dict and 'name' not in vul_dict:
            raise Exception("Mandatory fields 'scan' and 'name' not in Result")

        vul_push = {
            "scan": vul_dict.get('scan'),
            "name": vul_dict.get('name'),
            "cwe": vul_dict.get('cwe', 0),
            "severity": int(vul_dict.get('severity', 0)),
        }

        if 'description' in vul_dict:
            vul_push['description'] = vul_dict.get('description')

        if 'observation' in vul_dict:
            vul_push['observation'] = vul_dict.get('observation')

        if 'remediation' in vul_dict:
            vul_push['remediation'] = vul_dict.get('remediation')

        evid = []
        if 'evidences' in vul_dict:
            if not isinstance(vul_dict.get('evidences'), list):
                raise Exception("Evidences have to be list definition")
            else:
                for single_evid in vul_dict.get('evidences'):
                    svid = {
                        "url": single_evid.get('url', ''),
                    }
                    if 'param' in single_evid:
                        svid['param'] = single_evid.get('param')

                    if 'log' in single_evid:
                        svid["log"] = b64encode(
                            single_evid.get('log').encode()).decode()

                    evid.append(svid)
        if evid:
            vul_push['evidences'] = evid

        resp = requests.post(url,
                             json=vul_push,
                             headers={"Authorization": self.token})
        if resp.status_code != 200:
            logger.error(resp.content())

        logger.info("Successfully pushed Vulnerability Data")
Esempio n. 34
0
    def check_service(self, pro_alias):
        adb_cmd = "adb shell \"ps | grep " + str(pro_alias) + "\""
        print "adb_cmd: ", adb_cmd
        pro_details = os.popen(adb_cmd).read()
        print "pro_details: ", pro_details
        # print "proDetails: "+ proDetails
        # logger.info(proDetails, also_console=True)
        is_null = (len(pro_details) == 0)

        if is_null:
            logger.error(pro_alias + " is not alive.")
            return -1
        elif pro_details.endswith("./ServerCenter"):
            logger.info(pro_alias + " is alive.")
        else:
            return pro_details
Esempio n. 35
0
 def get_individual_response_field(self, field_to_get):
     """
     Returns the specified data field from the first record on the response, if available.
     Otherwise, an error is thrown.
     """
     if not self.response:
         logger.error("No data matching query conditions was returned.")
         raise AssertionError(
             "Failed to retrieve data required for this test.")
     try:
         data = self.response[field_to_get]
     except KeyError:
         raise AssertionError(
             "Field not found in response from {table}: {field}".format(
                 table=self.query_table, field=field_to_get))
     return data
 def load_json_from_file(self, file_name):
     """Load JSON from file.
     Return json as a dictionary object.
     Arguments:
         - file_name: absolute json file name
     Return json object (list or dictionary)
     Examples:
     | ${result}=  |  Load Json From File  | /path/to/file.json |
     """
     logger.debug("Check if file exists")
     if os.path.isfile(file_name) is False:
         logger.error("JSON file: " + file_name + " not found")
         raise IOError
     with open(file_name) as json_file:
         data = json.load(json_file)
     return data
Esempio n. 37
0
    def _open_csv_file_for_write(filename,
                                 data,
                                 csv_writer=csv.writer,
                                 **kwargs):
        with open(filename, 'ab') as csv_handler:
            writer = csv_writer(csv_handler, **kwargs)
            try:
                if isinstance(writer, csv.DictWriter) and 'fieldnames' in list(
                        kwargs.keys()):
                    csv_handler.truncate()
                    writer.writeheader()

                writer.writerows(data)
            except csv.Error as e:
                logger.error('file %s, line %d: %s' %
                             (filename, writer.line_num, e))
Esempio n. 38
0
def connect_to_redis_cluster(redis_host, redis_port): # pragma: no cover
        """Connect To Redis Cluster.
        Arguments:
            - redis_host: hostname or IP address of the Redis server.
            - redis_port: Redis port number (default=6379)
        Return redis connection object
        Examples:
        | ${redis_conn}=   | Connect To Redis Cluster |  redis-dev.com | 6379 |
        """
        startup_nodes = [{"host":redis_host, "port":redis_port}]
        try:
            redis_conn = redis.StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True, skip_full_coverage_check=True)
        except Exception as ex:
            logger.error(str(ex))
            raise Exception(str(ex))
        return redis_conn
Esempio n. 39
0
    def relleno_campo_texto_con_etiqueta_con_texto(self, etiqueta, texto):
        """ Rellena un campo de texto buscando su etiqueta como nombre """
        try:
            # localizamos la etiqueta del text box que buscamos
            form = self.driver.find_element_by_xpath('//form')
            label = form.find_element_by_xpath('//*[contains(@class, "ocultarUsuarios")]'
                                               '//strong[normalize-space(text())="' + etiqueta + '"]')

            # después de localizar la etiqueta del text box buscamos su hermano más inmediato que es donde
            # se ubica el text box input
            textbox = label.find_element_by_xpath('./following::input')
            textbox.clear()
            textbox.send_keys(texto)
        except (TimeoutException, NoSuchElementException) as e:
            logger.error(FIELD_NOT_FOUND.format(etiqueta))
            raise Exception(e.msg)
Esempio n. 40
0
    def wait_for_success(self):
        """

        Summary: Waits for success message in the UI

        """
        try:
            myElem = WebDriverWait(self.driver, 5).until(
                EC.presence_of_element_located(
                    (By.XPATH, 'id("content")/div[2]/article[1]/div[1]')))
            e = self.driver.find_element(
                By.XPATH, 'id("content")/div[2]/article[1]/div[1]')
            info = str(e.text)
            logger.console('{}'.format(info), newline=False)
        except:
            logger.error('ERROR')
Esempio n. 41
0
 def check_vdlog(self):
     if not TBoxCore.is_connected():
         raise TBoxCoreError(
             "Exception on querying vdlog file(Please insert the ADB cable)"
         )
     (status, output) = Utils.getstatusoutput("adb shell ls /data")
     try:
         if not status:
             vdlog = re.findall('vdlog', output)[0]
             logger.info(self._tag + "vdlog is existed: True")
     except IndexError:
         logger.error(self._tag + "vdlog is existed: False")
         logger.info(self._tag + "Creating vdlog file...")
         Utils.getstatusoutput('adb shell touch /data/vdlog')
         if not status:
             logger.info(self._tag + "Succeed to create vdlog file")
def end_suite(data, result):
    """Called at the end of a test suite"""
    logger.info('Start of end_suite listener')
    try:
        json_data = '['
        for item in SUITE_ANNOTATIONS:
            json_data = json_data + json.dumps(item.__dict__) + ','
        json_data = json_data.rstrip(',') + ']'
        robot_out = os.environ.get('ROBOTOUT')
        file_path = os.path.join(robot_out, ANNOTATIONS_FILE)
        with open(file_path, 'w') as json_file:
            json_file.write(json_data)
        logger.info('Annotations file created at: %s' % file_path)
    except Exception as e:
        logger.error('Unable to generate annotations file')
        logger.error(e)
Esempio n. 43
0
def reset_simulator_reading_count():
    try:
        logger.info('▶ Reset simulator reading count.', also_console=True)
        conn = http.client.HTTPConnection(host=configuration.SIMULATOR_HOST,
                                          port=1503,
                                          timeout=10)
        conn.request(method="GET", url="/reading/count/reset")
        r = conn.getresponse()
    except Exception as e:
        logger.debug('▶ Fail to reset simulator reading count. {}'.format(e))
        raise e
    if int(r.status) == 200:
        logger.info('▶ Reset simulator reading count to 0', also_console=True)
    else:
        logger.error('▶ Fail to reset simulator reading count.')
        raise Exception('Fail to reset simulator reading count.')
Esempio n. 44
0
    def async_get(self, handle):
        """
        Blocks until the thread created by async_run returns
        Use:
            Async get  ${handle}
        """
        assert handle in self._thread_pool, 'Invalid async call handle'
        try:
            result = self._thread_pool[handle].result_queue.get(True,
                                                                timeout=15)
        except Empty:
            logger.error(f"Async get keyword didn't retrieve result")
            return

        del self._thread_pool[handle]
        return result
Esempio n. 45
0
    def manage_npmaudit_results(self, result_file):
        severity_dict = {'moderate': 2, 'low': 1, 'critical': 3, 'high': 3}
        url = "{}/api/vulnerability/create".format(self.threatplaybook)
        with open(result_file, 'r') as jfile:
            results = json.loads(jfile.read())
        if results:
            create_scan_query = self.create_scan("npmaudit")
            if 'data' in create_scan_query:
                scan = create_scan_query.get('data').get('name')
                if 'advisories' not in results:
                    logger.info("No Advisories in report")
                    pass
                else:
                    for sl, vul_result in results.get('advisories').items():
                        vul_dict = {
                            'name':
                            vul_result.get('title'),
                            'description':
                            vul_result.get('overview', ''),
                            'scan':
                            scan,
                            'cwe':
                            int(vul_result.get('cwe').split('-')[1], 0),
                            'severity':
                            int(
                                severity_dict.get(
                                    vul_result.get('severity', 'low'))),
                        }

                        evidences = []
                        for finding in vul_result.get('findings'):
                            evid = {
                                "param": finding.get('version', '0.0'),
                                "url": ":".join(finding.get('paths'))
                            }
                            evidences.append(evid)
                        vul_dict['evidences'] = evidences
                        resp = requests.post(
                            url,
                            json=vul_dict,
                            headers={"Authorization": self.token})
                        if resp.status_code != 200:
                            raise Exception(
                                "Unable to create NPM Audit Finding")

            else:
                logger.error("Unable to create scan for NPM Audit")
Esempio n. 46
0
    def get_attached_devices(self, band, iface_type):
        s = ""
        xpath = "table"
        if band == "wired":
            s = "Wired Devices"
            xpath = "div/" + xpath
        elif "2.4" in band:
            if iface_type == "guest":
                s = "2.4 GHz Guest Wireless Devices"
            else:
                s = "2.4 GHz Wireless Devices"
        elif "5" in band:
            if iface_type == "guest":
                s = "5 GHz Guest Wireless Devices"
            else:
                s = "5 GHz Wireless Devices"
        else:
            logger.error("Attached device for %s %s not exist" %
                         (band, iface_type))
            raise ValueError

        logger.debug("Checking attached devices\t on: %s" % (s))

        self._linkElement("Status")
        time.sleep(2)
        self._linkElement("Attached Devices")
        time.sleep(15)
        msg = self._captureWebInfo(
            "//h4[contains(.,'%s')]/following-sibling::%s/tbody" % (s, xpath))
        dl = msg.split("\n")
        list_info = []
        if len(dl) <= 1:
            return None
        else:
            del dl[0]
            for d in dl:
                logger.debug("device:%s." % d)
                di = d.split(" ")
                info = {
                    'ip': str(di[1]),
                    'mac': str(di[2]),
                    'name': str(di[3]),
                    'alias': str(di[4])
                }
                list_info.append(info)

        return list_info
Esempio n. 47
0
    def __init__(self, project_name, default_connection=True):
        '''
        Initialize the ThreatPlaybook API

        By default, the param ``default_connection`` is set to true. This means that ThreatPlaybook will attempt to connect to
        the local MongoDB instance on DB ``threat_playbook`` with no authentication or other params

        If you want to connect to a mongoDB instance with authentication and other params, you need to enable Environment Variables:
        ``TP_MONGO_USER`` => Mongo Username
        ``TP_MONGO_PASS`` => Mongo Password
        ``TP_MONGO_HOST`` => Mongo Host IP
        ``TP_MONGO_PORT`` => Mongo Port

        All these params have to be set if the default_connection is initialized with `False`

        | ThreatPlaybook  | project_name | default_connection=True/False |

        '''

        try:
            if not default_connection:
                logger.warn(
                    "Running MongoDB without Authentication. Highly recommend running MongoDB with Authentication"
                )
                connect('threat_playbook')
            else:
                mongo_user = os.getenv("TP_MONGO_USER", None)
                mongo_pass = os.getenv("TP_MONGO_PASS", None)
                mongo_host = os.getenv("TP_MONGO_HOST", None)
                mongo_port = os.getenv("TP_MONGO_PORT", None)
                connect(db='threat_playbook',
                        username=mongo_user,
                        password=mongo_pass,
                        host=mongo_host,
                        port=mongo_port)
        except:
            logger.error("Unable to connect to DB. Disconnecting")
            exit(1)

        Project.objects(name=project_name).update_one(name=project_name,
                                                      upsert=True)
        self.project = Project.objects.get(name=project_name)

        new_session = Session(project=self.project)
        new_session.save()
        self.session = new_session
Esempio n. 48
0
def create_env_directory_at_node(node):
    """Create fresh virtualenv to a directory, install pip requirements."""
    logger.console('Extracting virtualenv, installing requirements.txt '
                   'on {0}'.format(node['host']))
    ssh = SSH()
    ssh.connect(node)
    (ret_code, stdout, stderr) = ssh.exec_command(
        'cd {0} && rm -rf env && '
        'virtualenv --system-site-packages --never-download env && '
        '. env/bin/activate && '
        'pip install -r requirements.txt'.format(con.REMOTE_FW_DIR),
        timeout=100)
    if ret_code != 0:
        logger.error('Virtualenv creation error: {0}'.format(stdout + stderr))
        raise Exception('Virtualenv setup failed')
    else:
        logger.console('Virtualenv created on {0}'.format(node['host']))
Esempio n. 49
0
 def __JsonList(self, Real_data, Expect_data):
     try:
         logger.debug('调用JsonList函数 实响应数据: %s 预期数据:%s' %
                      (Real_data, Expect_data))
         if len(Real_data) < len(Expect_data):
             return '0', 'List Values are not equal! ' + 'Real_data: ' + str(
                 Real_data) + '  Expect_data: ' + str(Expect_data)
         for single_Real_data in Real_data:
             single_Real_data_index = Real_data.index(single_Real_data)
             if single_Real_data_index > len(Expect_data) - 1:
                 return '0', str(
                     single_Real_data) + ' in Expect_data not found!'
             single_Expect_data = Expect_data[
                 single_Real_data_index]  # 期望返回的数据
             logger.debug('实响应数据 %s' % single_Real_data)
             logger.debug('预期数据 %s' % single_Expect_data)
             if single_Expect_data != single_Real_data:  # 如果列表的中字典不相同,则判断具体那里不同
                 if isinstance(single_Expect_data, dict) and isinstance(
                         single_Real_data, dict):  # 字典类型
                     State, Info = self.__JsonDict(single_Real_data,
                                                   single_Expect_data)
                     if State == '0':
                         logger.info('数据匹配失败.详情:%s' % Info)
                         return State, Info
                     continue
                 elif isinstance(single_Expect_data, list) and isinstance(
                         single_Real_data, list):  # 字典类型
                     State, Info = self.__JsonList(single_Real_data,
                                                   single_Expect_data)
                     if State == '0':
                         logger.info('数据匹配失败.详情:%s' % Info)
                         return State, Info
                     continue
                 else:  # 判断普通类型
                     return '0', 'Values are not equal! Real: ' + str(
                         single_Real_data) + '  Expect: ' + str(
                             single_Expect_data)
             elif single_Expect_data == single_Real_data:
                 logger.debug('匹对成功退出当次循环')
                 continue
             else:
                 return '0', 'unknown error'
         return '1', None  # 数据正确
     except KeyError, e:
         logger.error('发生异常!!!错误信息%s' % e)
         return '0', 'KeyError:' + e
Esempio n. 50
0
def update_device_service_admin_state(admin_state):
    conn = http.client.HTTPConnection(host=SettingsInfo().constant.BASE_URL,
                                      port=59881,
                                      timeout=5)
    conn.request(method="PUT",
                 url="/api/v1/deviceservice/name/{}/adminstate/{}".format(
                     configuration.SERVICE_NAME, admin_state))
    try:
        r1 = conn.getresponse()
    except Exception as e:
        raise e
    if int(r1.status) == 200:
        logger.debug(
            '▶ Update device service admin state to {}'.format(admin_state))
    else:
        logger.error('▶ Fail to update the admin state.')
        raise Exception('Fail to update the admin state')
Esempio n. 51
0
    def execute_script(self, vat_name, node, timeout=15, json_out=True):
        """Copy local_path script to node, execute it and return result.

        :param vat_name: Name of the vat script file. Only the file name of
        the script is required, the resources path is prepended automatically.
        :param node: Node to execute the VAT script on.
        :param timeout: Seconds to allow the script to run.
        :param json_out: Require JSON output.
        :type vat_name: str
        :type node: dict
        :type timeout: int
        :type json_out: bool
        :returns: Status code, stdout and stderr of executed VAT script.
        :rtype: tuple
        :raises RuntimeError: If VAT script execution failed.
        """

        ssh = SSH()
        try:
            ssh.connect(node)
        except:
            raise SSHException("Cannot open SSH connection to execute VAT "
                               "command(s) from template {0}".format(vat_name))

        remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
                                                Constants.RESOURCES_TPL_VAT,
                                                vat_name)
        # TODO this overwrites the output if the vat script has been used twice
        # remote_file_out = remote_file_path + ".out"

        cmd = "sudo -S {vat} {json} in {input} script".format(
            vat=Constants.VAT_BIN_NAME,
            json="json" if json_out is True else "",
            input=remote_file_path)

        try:
            (ret_code, stdout, stderr) = ssh.exec_command(cmd, timeout)
        except SSHTimeout:
            logger.error("VAT script execution timeout: {0}".format(cmd))
            raise
        except:
            raise RuntimeError("VAT script execution failed: {0}".format(cmd))

        self._ret_code = ret_code
        self._stdout = stdout
        self._stderr = stderr
Esempio n. 52
0
 def _acquire_value_set(self, *tags):
     if self._remotelib:
         try:
             while True:
                 self._setname, self._valueset = self._remotelib.run_keyword('acquire_value_set',
                                                     [self._my_id]+list(tags), {})
                 if self._setname:
                     logger.info('Value set "%s" acquired' % self._setname)
                     return self._setname
                 time.sleep(PabotLib._pollingSeconds)
                 if PabotLib._polling_logging: logger.debug('waiting for a value set')
         except RuntimeError as err:
             logger.error("RuntimeError catched in remote _acquire_value_set execution. Maybe there is no connection - is pabot called with --pabotlib option? ErrorDetails: {0}".format(repr(err)))
             self.__remotelib = None
             raise
     self._setname, self._valueset = _PabotLib.acquire_value_set(self, self._my_id, *tags)
     return self._setname
Esempio n. 53
0
 def acquire_lock(self, name):
     """
     Wait for a lock with name.
     [https://pabot.org/PabotLib.html?ref=log#acquire-lock|Open online docs.]
     """
     if self._remotelib:
         try:
             while not self._remotelib.run_keyword('acquire_lock',
                                                   [name, self._my_id], {}):
                 time.sleep(PabotLib._pollingSeconds)
                 if PabotLib._polling_logging: logger.debug('waiting for lock to release')
             return True
         except RuntimeError as err:
             logger.error("RuntimeError catched in remote acquire_lock execution. Maybe there is no connection - is pabot called with --pabotlib option? ErrorDetails: {0}".format(repr(err)))
             self.__remotelib = None
             raise
     return _PabotLib.acquire_lock(self, name, self._my_id)
Esempio n. 54
0
    def _validate_mandatory_values(self):
        """Validate that mandatory profile values satisfy their constraints

        :returns: whether mandatory values are acceptable
        :rtype: bool
        """
        # Level 3: Mandatory params: Check if urls is a list:
        is_valid = True
        if not isinstance(self.traffic_profile[u"urls"], list):
            logger.error(u"The parameter 'urls' must be a list.")
            is_valid = False

        # Level 3: Mandatory params: Check if integers are not below minimum
        for param, minimum in self.INTEGER_PARAMS:
            if not self._validate_int_param(param, minimum):
                is_valid = False
        return is_valid
 def new_proto_object(self, proto_id, proto_name, message, dict_fields):
     global proto
     proto[proto_id] = eval(proto_name + '.' + message + '()')
     for field in dict_fields:
         #logger.error(type(dict_fields[field]))
         if isinstance(dict_fields[field], list ):
             for i in range(len(dict_fields[field])):
                 exec('proto[proto_id].'+ field + '.add()')
                 if isinstance(dict_fields[field][i], (dict, type(DotDict))):
                     for sub in dict_fields[field][i]:
                         logger.error('proto[proto_id].' + field + '['+ str(i)+'].'+sub+' = ' + dict_fields[field][i][sub])
                         exec('proto[proto_id].' + field + '['+ str(i)+'].'+sub+' = ' + dict_fields[field][i][sub])
                 else:
                     exec('proto[proto_id].'+ field +'['+ str(i)+']='+ str(dict_fields[field][i]))
         else:
             exec('proto[proto_id].' + field + ' = ' + dict_fields[field])
     return proto[proto_id]
 def _open_csv_file_for_read(filename, csv_reader=csv.reader, line_numbers=None, **kwargs):
     if line_numbers is not None and isinstance(line_numbers, list):
         line_numbers = map(int, line_numbers)
     with open(filename, 'r') as csv_handler:
         reader = csv_reader(csv_handler, **kwargs)
         try:
             for line_number, row in enumerate(reader):
                 if line_numbers is None:
                     yield row
                 elif isinstance(line_numbers, list):
                     if line_number in line_numbers:
                         yield row
                         line_numbers.remove(line_number)
                         if len(line_numbers) == 0:
                             break
         except csv.Error as e:
             logger.error('file %s, line %d: %s' % (filename, reader.line_num, e))
Esempio n. 57
0
File: ssh.py Progetto: preym17/csit
def raise_from(raising, excepted):
    """Function to be replaced by "raise from" in Python 3.

    Neither "six" nor "future" offer good enough implementation right now.
    chezsoi.org/lucas/blog/displaying-chained-exceptions-stacktraces-in-python-2

    Current implementation just logs excepted error, and raises the new one.

    :param raising: The exception to raise.
    :param excepted: The exception we excepted and want to log.
    :type raising: BaseException
    :type excepted: BaseException
    :raises: raising
    """
    logger.error("Excepted: {exc!r}\nRaising: {rai!r}".format(
        exc=excepted, rai=raising))
    raise raising
def decrypt_and_extract_the_dump_file(src_dir, decryptor_path):
    logger.console('Extracting the support dump file')
    i = 1
    for filename in os.listdir(src_dir):
        while filename.endswith(".part"):
            logger.console("waiting %s seconds for the download to complete" % (i * 30))
            time.sleep(30)
            i = i + 1
            if i >= 240:
                logger.error("Took more than 2 hours to download , so failing the test case")
            if not os.path.isfile(src_dir + "//" + filename):
                logger.console("Download completed")
                break
    if (platform.system() == 'Windows'):
        decryptor_extractor(r"decrypt-support-dump.bat", src_dir, decryptor_path)
    else:  # (platform.system() == 'Linux'):
        decryptor_extractor(r"decrypt-support-dump.sh", src_dir, decryptor_path, "linux")
Esempio n. 59
0
 def samba_download(self, usb_id, download_file):
     director = urllib2.build_opener(SMBHandler)
     fh = None  # prevent reference before assignment
     try:
         fh = director.open('smb://*****:*****@192.168.8.1/usb-' +
                            str(usb_id) + '/' + download_file)
         #feng add 20170126
         time.sleep(10)
     except urllib2.URLError:
         logger.error("URLError in samba download, usb id: " + str(usb_id) +
                      ", download file: " + str(download_file) +
                      ". USB probably not detected correctly")
     if fh:
         print type(fh)
         save_file = open(download_file, 'w')
         save_file.write(fh)
         fh.close()
Esempio n. 60
0
 def upload_file_ftp(self, usb_id, filename, username, password):
     local_f = open(filename, 'rb')
     try:
         ftp = FTP(self.host_ip, username, password)
         ftp.cwd('usb-' + str(usb_id))
         ftp.storbinary('STOR %s' % filename, local_f)
     except ftplib.error_perm:
         logger.error("550 Failed to change directory, usb id: " +
                      str(usb_id) + " filename: " + str(filename) +
                      " usr:pass: "******":" + password +
                      ". USB probably not detected correctly")
         #--feng add 20170202
         logger.console("550 Failed to change directory, usb id: " +
                        str(usb_id) + " filename: " + str(filename) +
                        " usr:pass: "******":" + password +
                        ". USB probably not detected correctly")
     ftp.close()