Example #1
0
def runAgent(passPhrase, expected_hostname, user_run_as, verbose, ret=None):
    os.environ[AMBARI_PASSPHRASE_VAR] = passPhrase
    vo = ""
    if verbose:
        vo = " -v"
    cmd = [
        'su', user_run_as, '-l', '-c',
        '/usr/sbin/ambari-agent restart --expected-hostname=%1s %2s' %
        (expected_hostname, vo)
    ]
    log = ""
    p = subprocess32.Popen(cmd, stdout=subprocess32.PIPE)
    p.communicate()
    agent_retcode = p.returncode
    for i in range(3):
        time.sleep(1)
        ret = execOsCommand(
            ["tail", "-20", "/var/log/ambari-agent/ambari-agent.log"], ret=ret)
        if (0 == ret['exitstatus']):
            try:
                log = ret['log']
            except Exception:
                log = "Log not found"
            print log
            break
    return {"exitstatus": agent_retcode, "log": log}
Example #2
0
    def run(self, script, user=None):
        import pwd

        try:
            if user is not None:
                user = pwd.getpwnam(user)[2]
            else:
                user = os.getuid()
            self._threadLocal.uid = user
        except Exception:
            _logger.warn("can not switch user for RUN_COMMAND.")

        cmd = script

        if isinstance(script, list):
            cmd = " ".join(script)

        cmd_list = ["/bin/bash", "--login", "--noprofile", "-c", cmd]
        p = subprocess.Popen(cmd_list,
                             preexec_fn=self._change_uid,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE,
                             shell=False,
                             close_fds=True)
        out, err = p.communicate()
        code = p.wait()
        _logger.debug("Exitcode for %s is %d" % (cmd, code))
        return {'exitCode': code, 'output': out, 'error': err}
Example #3
0
def swap_memory():
    sin, sout = cext.swap_mem()
    # XXX
    # we are supposed to get total/free by doing so:
    # http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/
    #     usr/src/cmd/swap/swap.c
    # ...nevertheless I can't manage to obtain the same numbers as 'swap'
    # cmdline utility, so let's parse its output (sigh!)
    p = subprocess32.Popen(['swap', '-l', '-k'], stdout=subprocess32.PIPE)
    stdout, stderr = p.communicate()
    if PY3:
        stdout = stdout.decode(sys.stdout.encoding)
    if p.returncode != 0:
        raise RuntimeError("'swap -l -k' failed (retcode=%s)" % p.returncode)

    lines = stdout.strip().split('\n')[1:]
    if not lines:
        raise RuntimeError('no swap device(s) configured')
    total = free = 0
    for line in lines:
        line = line.split()
        t, f = line[-2:]
        t = t.replace('K', '')
        f = f.replace('K', '')
        total += int(int(t) * 1024)
        free += int(int(f) * 1024)
    used = total - free
    percent = usage_percent(used, total, _round=1)
    return _common.sswap(total, used, free, percent, sin * PAGE_SIZE,
                         sout * PAGE_SIZE)
Example #4
0
    def _get_unix_sockets(self, pid):
        """Get UNIX sockets used by process by parsing 'pfiles' output."""
        # TODO: rewrite this in C (...but the damn netstat source code
        # does not include this part! Argh!!)
        cmd = "pfiles %s" % pid
        p = subprocess32.Popen(cmd,
                               shell=True,
                               stdout=subprocess32.PIPE,
                               stderr=subprocess32.PIPE)
        stdout, stderr = p.communicate()
        if PY3:
            stdout, stderr = [
                x.decode(sys.stdout.encoding) for x in (stdout, stderr)
            ]
        if p.returncode != 0:
            if 'permission denied' in stderr.lower():
                raise AccessDenied(self.pid, self._name)
            if 'no such process' in stderr.lower():
                raise NoSuchProcess(self.pid, self._name)
            raise RuntimeError("%r command error\n%s" % (cmd, stderr))

        lines = stdout.split('\n')[2:]
        for i, line in enumerate(lines):
            line = line.lstrip()
            if line.startswith('sockname: AF_UNIX'):
                path = line.split(' ', 2)[2]
                type = lines[i - 2].strip()
                if type == 'SOCK_STREAM':
                    type = socket.SOCK_STREAM
                elif type == 'SOCK_DGRAM':
                    type = socket.SOCK_DGRAM
                else:
                    type = -1
                yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE)
Example #5
0
 def genAgentCrtReq(self, keyname):
   keysdir = os.path.abspath(self.config.get('security', 'keysdir'))
   generate_script = GEN_AGENT_KEY % {
     'hostname': hostname.hostname(self.config),
     'keysdir': keysdir}
   
   logger.info(generate_script)
   if platform.system() == 'Windows':
     p = subprocess32.Popen(generate_script, stdout=subprocess32.PIPE)
     p.communicate()
   else:
     p = subprocess32.Popen([generate_script], shell=True,
                          stdout=subprocess32.PIPE)
     p.communicate()
   # this is required to be 600 for security concerns.
   os.chmod(keyname, 0600)
Example #6
0
 def run(self):
     scpcommand = [
         "scp", "-r", "-o", "ConnectTimeout=60", "-o", "BatchMode=yes",
         "-o", "StrictHostKeyChecking=no", "-P", self.sshPort, "-i",
         self.sshkey_file, self.inputFile,
         self.user + "@" + self.host + ":" + self.remote
     ]
     if DEBUG:
         self.host_log.write("Running scp command " + ' '.join(scpcommand))
     self.host_log.write("==========================")
     self.host_log.write("\nCommand start time " +
                         datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
     scpstat = subprocess32.Popen(scpcommand,
                                  stdout=subprocess32.PIPE,
                                  stderr=subprocess32.PIPE)
     log = scpstat.communicate()
     errorMsg = log[1]
     log = log[0] + "\n" + log[1]
     self.host_log.write(log)
     self.host_log.write("scp " + self.inputFile)
     self.host_log.write("host=" + self.host + ", exitcode=" +
                         str(scpstat.returncode))
     self.host_log.write("Command end time " +
                         datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
     return {
         "exitstatus": scpstat.returncode,
         "log": log,
         "errormsg": errorMsg
     }
 def run_os_command_in_shell(self, command):
     process = subprocess32.Popen(command,
                                  stdout=subprocess32.PIPE,
                                  stdin=subprocess32.PIPE,
                                  stderr=subprocess32.PIPE,
                                  shell=True)
     return process.communicate()
    def os_call(command, logoutput=None, env={}):
        shell = not isinstance(command, list)
        print_output = logoutput == True or (logoutput == None
                                             and Utils.verbose)

        if not print_output:
            stdout = subprocess32.PIPE
            stderr = subprocess32.STDOUT
        else:
            stdout = stderr = None

        logger.info("Running '{0}'".format(command))
        proc = subprocess32.Popen(command,
                                  shell=shell,
                                  stdout=stdout,
                                  stderr=stderr,
                                  env=env)

        if not print_output:
            out = proc.communicate()[0].strip('\n')
        else:
            proc.wait()
            out = None

        code = proc.returncode

        if code:
            err_msg = ("Execution of '%s'\n returned %d. %s") % (command, code,
                                                                 out)
            raise OsCallFailure(err_msg)

        return out
Example #9
0
def main(argv=None):
    scriptDir = os.path.realpath(os.path.dirname(argv[0]))
    onlyargs = argv[1:]
    if len(onlyargs) < 3:
        sys.stderr.write(
            "Usage: <comma separated hosts> "
            "<tmpdir for storage> <user> <sshPort> <sshkey_file> <agent setup script>"
            " <ambari-server name> <cluster os type> <ambari version> <ambari port> <user_run_as> <passwordFile>\n"
        )
        sys.exit(2)
        pass

    #Parse the input
    hostList = onlyargs[0].split(",")
    bootdir = onlyargs[1]
    user = onlyargs[2]
    sshPort = onlyargs[3]
    sshkey_file = onlyargs[4]
    setupAgentFile = onlyargs[5]
    ambariServer = onlyargs[6]
    cluster_os_type = onlyargs[7]
    ambariVersion = onlyargs[8]
    server_port = onlyargs[9]
    user_run_as = onlyargs[10]
    passwordFile = onlyargs[11]

    if not OSCheck.is_windows_family():
        # ssh doesn't like open files
        subprocess32.Popen(["chmod", "600", sshkey_file],
                           stdout=subprocess32.PIPE)

        if passwordFile is not None and passwordFile != 'null':
            subprocess32.Popen(["chmod", "600", passwordFile],
                               stdout=subprocess32.PIPE)

    logging.info("BootStrapping hosts " + pprint.pformat(hostList) +
                 " using " + scriptDir + " cluster primary OS: " + cluster_os_type +
                 " with user '" + user + "'with ssh Port '" + sshPort + "' sshKey File " + sshkey_file + " password File " + passwordFile +\
                 " using tmp dir " + bootdir + " ambari: " + ambariServer +"; server_port: " + server_port +\
                 "; ambari version: " + ambariVersion+"; user_run_as: " + user_run_as)
    sharedState = SharedState(user, sshPort, sshkey_file, scriptDir, bootdir,
                              setupAgentFile, ambariServer, cluster_os_type,
                              ambariVersion, server_port, user_run_as,
                              passwordFile)
    pbootstrap = PBootstrap(hostList, sharedState)
    pbootstrap.run()
    return 0  # Hack to comply with current usage
Example #10
0
def run_os_command(cmd):
    shell = (type(cmd) == str)
    process = subprocess32.Popen(cmd,
                                 shell=shell,
                                 stdout=subprocess32.PIPE,
                                 stdin=subprocess32.PIPE,
                                 stderr=subprocess32.PIPE)
    (stdoutdata, stderrdata) = process.communicate()
    return process.returncode, stdoutdata, stderrdata
Example #11
0
    def get_alternatives_desc(self, alt_name):
        command = ALT_DISP_CMD.format(alt_name)
        out = None
        try:
            p1 = subprocess32.Popen(shlex.split(command),
                                    stdout=subprocess32.PIPE)
            p2 = subprocess32.Popen(["grep", "priority"],
                                    stdin=p1.stdout,
                                    stdout=subprocess32.PIPE)
            p1.stdout.close()
            out = p2.communicate()[0]
            logger.debug('alternatives --display ' + alt_name + '\n, out = ' +
                         out)
        except:
            logger.warn('Cannot process alternative named: ' + alt_name + ',' + \
                        'error: ' + str(sys.exc_info()[0]))

        return out
Example #12
0
def launch_subprocess(command):
  """
  Process launch helper

  :param command Command to execute
  :type command list[str]|str
  :return Popen object
  """
  is_shell = not isinstance(command, (list, tuple))
  return subprocess32.Popen(command, stdout=subprocess32.PIPE, stderr=subprocess32.PIPE, shell=is_shell, close_fds=True)
Example #13
0
 def run_os_command(self, cmd, runWithSudo=True):
     if runWithSudo:
         cmd = "/var/lib/ambari-agent/" + AMBARI_SUDO_BINARY + " " + cmd
     logger.info('Executing command: ' + str(cmd))
     if type(cmd) == str:
         cmd = shlex.split(cmd)
     process = subprocess32.Popen(cmd,
                                  stdout=subprocess32.PIPE,
                                  stdin=subprocess32.PIPE,
                                  stderr=subprocess32.PIPE)
     (stdoutdata, stderrdata) = process.communicate()
     return process.returncode, stdoutdata, stderrdata
Example #14
0
 def launch_python_subprocess32(self, command, tmpout, tmperr):
     """
 Creates subprocess32 with given parameters. This functionality was moved to separate method
 to make possible unit testing
 """
     command_env = dict(os.environ)
     return subprocess32.Popen(command,
                               stdout=tmpout,
                               stderr=tmperr,
                               close_fds=True,
                               env=command_env,
                               preexec_fn=lambda: os.setpgid(0, 0))
Example #15
0
def os_run_os_command(cmd, env=None, shell=False, cwd=None):
    if type(cmd) == str:
        cmd = shlex.split(cmd)
    process = subprocess32.Popen(cmd,
                                 stdout=subprocess32.PIPE,
                                 stdin=subprocess32.PIPE,
                                 stderr=subprocess32.PIPE,
                                 env=env,
                                 cwd=cwd,
                                 shell=shell)

    (stdoutdata, stderrdata) = process.communicate()
    return process.returncode, stdoutdata, stderrdata
Example #16
0
 def run(self, script, user=None):
   logger.warn("user argument ignored on windows")
   code = 0
   if isinstance(script, list):
     cmd = " ".join(script)
   else:
     cmd = script
   p = subprocess32.Popen(cmd, stdout=subprocess32.PIPE,
                        stderr=subprocess32.PIPE, shell=False)
   out, err = p.communicate()
   code = p.wait()
   logger.debug("Exitcode for %s is %d" % (cmd, code))
   return {'exitCode': code, 'output': out, 'error': err}
Example #17
0
def exec_ams_env_cmd(options):
    ams_env_cmd = os.path.join(options.conf_dir, AMS_ENV_CMD)
    if os.path.exists(ams_env_cmd):
        cmds = ["cmd.exe", "/C", ams_env_cmd]
        procAms = subprocess32.Popen(cmds, env=os.environ)
        out, err = procAms.communicate()
        if err is not None and err is not "":
            print_warning_msg(AMS_ENV_CMD + " error output: " + err)
        if out is not None and out is not "":
            print_info_msg(AMS_ENV_CMD + " output: " + out)
    else:
        err = 'ERROR: Cannot execute "{0}"'.format(ams_env_cmd)
        raise FatalException(1, err)
Example #18
0
 def run(self, script, user=None):
   global _logger
   _logger.warn("user argument ignored on windows")
   code = 0
   if isinstance(script, list):
     cmd = " ".join(script)
   else:
     cmd = script
   p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
   out, err = p.communicate()
   code = p.wait()
   _logger.debug("Exitcode for %s is %d" % (cmd, code))
   return SubprocessCallResult(out=out, error=err, code=code)
Example #19
0
 def runPowershell(self, file=None, script_block=None, args=[]):
   logger.warn("user argument ignored on windows")
   code = 0
   cmd = None
   if file:
     cmd = ['powershell', '-WindowStyle', 'Hidden', '-File', file] + args
   elif script_block:
     cmd = ['powershell', '-WindowStyle', 'Hidden', '-Command', script_block] + args
   p = subprocess32.Popen(cmd, stdout=subprocess32.PIPE,
                        stderr=subprocess32.PIPE, shell=False)
   out, err = p.communicate()
   code = p.wait()
   logger.debug("Exitcode for %s is %d" % (cmd, code))
   return _dict_to_object({'exitCode': code, 'output': out, 'error': err})
Example #20
0
def os_run_os_command(cmd, env=None, shell=False, cwd=None):
    print_info_msg('about to run command: ' + str(cmd))
    if type(cmd) == str:
        cmd = shlex.split(cmd)
    process = subprocess32.Popen(cmd,
                                 stdout=subprocess32.PIPE,
                                 stdin=subprocess32.PIPE,
                                 stderr=subprocess32.PIPE,
                                 env=env,
                                 cwd=cwd,
                                 shell=shell)
    print_info_msg("\nprocess_pid=" + str(process.pid))
    (stdoutdata, stderrdata) = process.communicate()
    return process.returncode, stdoutdata, stderrdata
Example #21
0
  def runPowershell(self, f=None, script_block=None, args=set()):
    global _logger
    _logger.warn("user argument ignored on windows")

    cmd = None
    if f:
      cmd = ['powershell', '-WindowStyle', 'Hidden', '-File', f] + list(args)
    elif script_block:
      cmd = ['powershell', '-WindowStyle', 'Hidden', '-Command', script_block] + list(args)

    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
    out, err = p.communicate()
    code = p.wait()
    _logger.debug("Exitcode for %s is %d" % (cmd, code))
    return {'exitCode': code, 'output': out, 'error': err}
Example #22
0
def exec_ssh_cmd(hostname, cmd):
    """
  Runs the command on the remote host as gpadmin user
  """
    # Only gpadmin should be allowed to run command via ssh, thus not exposing user as a parameter
    cmd = "su - {0} -c \"ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null {1} \\\"{2} \\\" \"".format(
        hawq_constants.hawq_user, hostname, cmd)
    Logger.info("Command executed: {0}".format(cmd))
    process = subprocess32.Popen(cmd,
                                 stdout=subprocess32.PIPE,
                                 stdin=subprocess32.PIPE,
                                 stderr=subprocess32.PIPE,
                                 shell=True)
    (stdout, stderr) = process.communicate()
    return process.returncode, stdout, stderr
Example #23
0
def execOsCommand(osCommand, tries=1, try_sleep=0, ret=None, cwd=None):
    ret = _ret_init(ret)

    for i in range(0, tries):
        if i > 0:
            time.sleep(try_sleep)

        osStat = subprocess32.Popen(osCommand,
                                    stdout=subprocess32.PIPE,
                                    cwd=cwd)
        log = osStat.communicate(0)
        ret = {"exitstatus": osStat.returncode, "log": log}

        if ret['exitstatus'] == 0:
            break

    return ret
Example #24
0
def public_hostname(config):
    global cached_public_hostname
    if cached_public_hostname is not None:
        return cached_public_hostname

    out = ''
    err = ''
    try:
        if config.has_option('agent', 'public_hostname_script'):
            scriptname = config.get('agent', 'public_hostname_script')
            output = subprocess32.Popen(scriptname,
                                        stdout=subprocess32.PIPE,
                                        stderr=subprocess32.PIPE,
                                        shell=True)
            out, err = output.communicate()
            if (0 == output.returncode and 0 != len(out.strip())):
                cached_public_hostname = out.strip().lower()
                logger.info("Read public hostname '" + cached_public_hostname +
                            "' using agent:public_hostname_script")
                return cached_public_hostname
            else:
                logger.warn("Execution of '{0}' returned {1}. {2}\n{3}".format(
                    scriptname, output.returncode, err.strip(), out.strip()))
    except:
        #ignore for now.
        trace_info = traceback.format_exc()
        logger.info("Error using the scriptname:" + trace_info + " :out " +
                    out + " :err " + err)
        logger.info("Defaulting to fqdn.")

    try:
        handle = urllib2.urlopen(
            'http://169.254.169.254/latest/meta-data/public-hostname', '', 2)
        str = handle.read()
        handle.close()
        cached_public_hostname = str.lower()
        logger.info(
            "Read public hostname '" + cached_public_hostname +
            "' from http://169.254.169.254/latest/meta-data/public-hostname")
    except:
        cached_public_hostname = socket.getfqdn().lower()
        logger.info("Read public hostname '" + cached_public_hostname +
                    "' using socket.getfqdn()")
    return cached_public_hostname
Example #25
0
 def checkUsers(self, user_mask, results):
     get_users_cmd = [
         "powershell", '-noProfile', '-NonInteractive', '-nologo',
         "-Command",
         self.GET_USERS_CMD.format(user_mask)
     ]
     try:
         osStat = subprocess32.Popen(get_users_cmd,
                                     stdout=subprocess32.PIPE,
                                     stderr=subprocess32.PIPE)
         out, err = osStat.communicate()
     except:
         raise Exception("Failed to get users.")
     for user in out.split(os.linesep):
         result = {}
         result['name'] = user
         result['homeDir'] = ""
         result['status'] = "Available"
         results.append(result)
Example #26
0
    def launch_python_subprocess32(self, command, tmpout, tmperr):
        """
    Creates subprocess32 with given parameters. This functionality was moved to separate method
    to make possible unit testing
    """
        close_fds = None if OSCheck.get_os_family(
        ) == OSConst.WINSRV_FAMILY else True
        command_env = dict(os.environ)
        if OSCheck.get_os_family() == OSConst.WINSRV_FAMILY:
            command_env["PYTHONPATH"] = os.pathsep.join(sys.path)
            for k, v in command_env.iteritems():
                command_env[k] = str(v)

        return subprocess32.Popen(command,
                                  stdout=tmpout,
                                  stderr=tmperr,
                                  close_fds=close_fds,
                                  env=command_env,
                                  preexec_fn=self.preexec_fn)
Example #27
0
def getResponse(path, address, ssl_enabled):

  command = "curl"
  httpGssnegotiate = "--negotiate"
  userpswd = "-u:"
  insecure = "-k"# This is smoke test, no need to check CA of server
  if ssl_enabled:
    url = 'https://' + address + path
  else:
    url = 'http://' + address + path

  command_with_flags = [command,httpGssnegotiate,userpswd,insecure,url]

  proc = subprocess32.Popen(command_with_flags, stdout=subprocess32.PIPE, stderr=subprocess32.PIPE)
  (stdout, stderr) = proc.communicate()
  response = json.loads(stdout)
  if response == None:
    print 'There is no response for url: ' + str(url)
    raise Exception('There is no response for url: ' + str(url))
  return response
Example #28
0
  def adjust_jce_permissions(self, jdk_path):
    ambari_user = read_ambari_user()
    cmds = []
    if ambari_user:
      cmds.append(self.SET_JCE_PERMISSIONS.format(ambari_user, jdk_path, configDefaults.JDK_SECURITY_DIR))
    cmds.append(self.SET_JCE_FILE_MODE.format(jdk_path, configDefaults.JDK_SECURITY_DIR, "*"))
    cmds.append(self.SET_JCE_JAR_MODE.format(jdk_path, configDefaults.JDK_SECURITY_DIR, "*.jar"))

    cmd = " && ".join(cmds)

    process = subprocess32.Popen(cmd,
                           stdout=subprocess32.PIPE,
                           stdin=subprocess32.PIPE,
                           stderr=subprocess32.PIPE,
                           shell=True
                           )
    (stdoutdata, stderrdata) = process.communicate()

    if process.returncode != 0:
      print_warning_msg("Failed to change jce permissions. {0}\n{1}".format(stderrdata, stdoutdata))
Example #29
0
 def run(self):
     sshcommand = [
         "ssh",
         "-o",
         "ConnectTimeOut=60",
         "-o",
         "StrictHostKeyChecking=no",
         "-o",
         "BatchMode=yes",
         "-tt",  # Should prevent "tput: No value for $TERM and no -T specified" warning
         "-i",
         self.sshkey_file,
         "-p",
         self.sshPort,
         self.user + "@" + self.host,
         self.command
     ]
     if DEBUG:
         self.host_log.write("Running ssh command " + ' '.join(sshcommand))
     self.host_log.write("==========================")
     self.host_log.write("\nCommand start time " +
                         datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
     sshstat = subprocess32.Popen(sshcommand,
                                  stdout=subprocess32.PIPE,
                                  stderr=subprocess32.PIPE)
     log = sshstat.communicate()
     errorMsg = log[1]
     if self.errorMessage and sshstat.returncode != 0:
         errorMsg = self.errorMessage + "\n" + errorMsg
     log = log[0] + "\n" + errorMsg
     self.host_log.write(log)
     self.host_log.write("SSH command execution finished")
     self.host_log.write("host=" + self.host + ", exitcode=" +
                         str(sshstat.returncode))
     self.host_log.write("Command end time " +
                         datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
     return {
         "exitstatus": sshstat.returncode,
         "log": log,
         "errormsg": errorMsg
     }
Example #30
0
def hostname(config):
    global cached_hostname
    if cached_hostname is not None:
        return cached_hostname

    try:
        scriptname = config.get('agent', 'hostname_script')
        try:
            osStat = subprocess32.Popen([scriptname],
                                        stdout=subprocess32.PIPE,
                                        stderr=subprocess32.PIPE)
            out, err = osStat.communicate()
            if (0 == osStat.returncode and 0 != len(out.strip())):
                cached_hostname = out.strip()
                logger.info(
                    "Read hostname '{0}' using agent:hostname_script '{1}'".
                    format(cached_hostname, scriptname))
            else:
                logger.warn(
                    "Execution of '{0}' failed with exit code {1}. err='{2}'\nout='{3}'"
                    .format(scriptname, osStat.returncode, err.strip(),
                            out.strip()))
                cached_hostname = socket.getfqdn()
                logger.info(
                    "Read hostname '{0}' using socket.getfqdn() as '{1}' failed"
                    .format(cached_hostname, scriptname))
        except:
            cached_hostname = socket.getfqdn()
            logger.warn(
                "Unexpected error while retrieving hostname: '{0}', defaulting to socket.getfqdn()"
                .format(sys.exc_info()))
            logger.info("Read hostname '{0}' using socket.getfqdn().".format(
                cached_hostname))
    except:
        cached_hostname = socket.getfqdn()
        logger.info(
            "agent:hostname_script configuration not defined thus read hostname '{0}' using socket.getfqdn()."
            .format(cached_hostname))

    cached_hostname = cached_hostname.lower()
    return cached_hostname