def is_online(self):
     try:
         self.new_db_connection()
         return True
     except Exception, e:
         log_exception(e)
         return False

 def is_online(self):
     try:
         ping(self.get_mongo_client())
         return True
     except (OperationFailure, AutoReconnect), ofe:
         log_exception(ofe)
         return "refused" not in str(ofe)

 def is_local(self):
     try:
         server_host = self.get_host_address()
         return server_host is None or is_host_local(server_host)
     except Exception, e:
         log_exception(e)
         log_error("Unable to resolve address '%s' for server '%s'."
                   " Cause: %s" %
                   (self.get_host_address(), self.id, e))

 def get_rs_status(self):
     try:
         rs_status_cmd = SON([('replSetGetStatus', 1)])
         rs_status =  self.db_command(rs_status_cmd, 'admin')
         return rs_status
     except (Exception,RuntimeError), e:
         log_debug("Cannot get rs status from server '%s'. cause: %s" %
                     (self.id, e))
         log_exception(e)
         return None

 def is_online(self):
     log_debug("(BEGIN) is_online() for %s" % self.id)
     start_date = datetime.datetime.now()
     result = False
     try:
         self.new_default_mongo_client()
         result = True
     except (OperationFailure, AutoReconnect), ofe:
         log_exception(ofe)
         result = "refused" not in str(ofe)

 def get_rs_config(self):
     try:
         return self.get_db("local")["system.replset"].find_one()
     except (Exception, RuntimeError), e:
         log_exception(e)
         if type(e) == MongoctlException:
             raise e
         else:
             log_verbose("Cannot get rs config from server '%s'. " "cause: %s" % (self.id, e))
             return None

    def has_connectivity_on(self, address):

        try:
            log_verbose("Checking if server '%s' is accessible on " "address '%s'" % (self.id, address))
            self.make_db_connection(address)
            return True
        except Exception, e:
            log_exception(e)
            log_verbose("Check failed for server '%s' is accessible on " "address '%s': %s" % (self.id, address, e))
            return False

def make_db_connection(address):

    try:
        return Connection(address,
                          socketTimeoutMS=CONN_TIMEOUT,
                          connectTimeoutMS=CONN_TIMEOUT)
    except Exception, e:
        log_exception(e)
        error_msg = "Cannot connect to '%s'. Cause: %s" % \
                    (address, e)
        raise MongoctlException(error_msg, cause=e)

    def prefer_use_ssl(self):
        if self.get_client_ssl_mode() != ClientSslMode.PREFER:
            return False

        log_debug("prefer_use_ssl() Checking if we prefer ssl for '%s'" %
                  self.id)
        try:
            self.new_ssl_test_mongo_client()
            return True
        except (OperationFailure, AutoReconnect), ofe:
            log_exception(ofe)
            return True

 def timeout_maybe_db_command(self, cmd, dbname):
     try:
         result = self.db_command(cmd, dbname)
         return result
     except Exception, e:
         log_exception(e)
         if "timed out" in str(e):
             log_warning("Command %s is taking a while to complete. "
                         "This is not necessarily bad. " %
                         document_pretty_string(cmd))
         else:
             raise

    def prefer_use_ssl(self):
        if self.get_client_ssl_mode() != ClientSslMode.PREFER:
            return False

        log_debug("prefer_use_ssl() Checking if we prefer ssl for '%s'" %
                  self.id)
        try:
            ping(self.new_mongo_client(ssl=True, **DEFAULT_CLIENT_OPTIONS))
            return True
        except (OperationFailure, AutoReconnect), ofe:
            log_exception(ofe)
            return True

    def prefer_use_ssl(self):
        if self.get_client_ssl_mode() != ClientSslMode.PREFER:
            return False

        log_debug("prefer_use_ssl() Checking if we prefer ssl for '%s'" % self.id)
        try:
            self.make_ssl_db_connection(self.get_connection_address())
            return True
        except Exception, e:
            if not "SSL handshake failed" in str(e):
                log_exception(e)
            return None

    def has_connectivity_on(self, address):

        try:
            log_verbose("Checking if server '%s' is accessible on "
                        "address '%s'" % (self.id, address))
            ping(pymongo.MongoClient(address, **DEFAULT_CLIENT_OPTIONS))
            return True
        except Exception, e:
            log_exception(e)
            log_verbose("Check failed for server '%s' is accessible on "
                        "address '%s': %s" % (self.id, address, e))
            return False

 def get_replication_info(self):
     try:
         ol = self.get_db("local")["oplog.rs"]
         first_op = ol.find(sort=[("$natural", 1)], limit=1).next()
         last_op = ol.find(sort=[("$natural", -1)], limit=1).next()
         first_ts = first_op["ts"]
         last_ts = last_op["ts"]
         return {
             "timeDiff": last_ts.time - first_ts.time,
             "timeDiffHours": (last_ts.time - first_ts.time) / 3600
         }
     except Exception, ex:
         log_exception("Error during get_replication_info()")

    def get_member_rs_status(self):
        rs_status =  self.get_rs_status()
        if rs_status:
            try:
                for member in rs_status['members']:
                    if 'self' in member and member['self']:
                        return member
            except (Exception,RuntimeError), e:
                log_debug("Cannot get member rs status from server '%s'."
                          " cause: %s" % (self.id, e))
                log_exception(e)

                return None

 def get_rs_config(self):
     try:
         return self.get_db('local')['system.replset'].find_one()
     except (Exception,RuntimeError), e:
         log_debug("Error whille trying to read rs config from "
                   "server '%s': %s" % (self.id, e))
         log_exception(e)
         if type(e) == MongoctlException:
             raise e
         else:
             log_verbose("Cannot get rs config from server '%s'. "
                         "cause: %s" % (self.id, e))
             return None

def push_mongodb(repo_name, mongodb_version, mongodb_edition=None,
                 access_key=None, secret_key=None):
    """

    :param repo_name:
    :param mongodb_version:
    :param mongodb_edition:
    :return:
    """
    mongodb_edition = mongodb_edition or MongoDBEdition.COMMUNITY
    repo = get_binary_repository(repo_name)

    if access_key and isinstance(repo, S3MongoDBBinaryRepository):
        repo.access_key = access_key
        repo.secret_key = secret_key
        repo.validate()

    version_info = make_version_info(mongodb_version, mongodb_edition)
    mongodb_install_dir = get_mongo_installation(version_info)


    if not mongodb_install_dir:
        raise MongoctlException("No mongodb installation found for '%s'" %
                                version_info)

    mongodb_install_home = os.path.dirname(mongodb_install_dir)
    target_archive_name = repo.get_archive_name(mongodb_version,
                                                mongodb_edition)

    target_archive_path = os.path.join(mongodb_install_home,
                                       target_archive_name)

    mongodb_install_dir_name = os.path.basename(mongodb_install_dir)
    log_info("Taring MongoDB at '%s'" % mongodb_install_dir_name)

    tar_exe = which("tar")
    tar_cmd = [tar_exe, "-cvzf", target_archive_name, mongodb_install_dir_name]
    call_command(tar_cmd, cwd=mongodb_install_home)

    log_info("Uploading tar to repo")

    repo.upload_file(mongodb_version, mongodb_edition, target_archive_path)

    # cleanup
    log_info("Cleanup")
    try:
        os.remove(target_archive_path)
    except Exception, e:
        log_error(str(e))
        log_exception(e)

 def needs_to_auth(self, dbname):
     """
     Determines if the server needs to authenticate to the database.
     NOTE: we stopped depending on is_auth() since its only a configuration
     and may not be accurate
     """
     log_debug("Checking if server '%s' needs to auth on  db '%s'...." % (self.id, dbname))
     try:
         conn = self.new_db_connection()
         db = conn[dbname]
         db.collection_names()
         result = False
     except (RuntimeError, Exception), e:
         log_exception(e)
         result = "authorized" in str(e)

 def get_server_build_info(self):
     """
     issues a buildinfo command
     """
     if self.is_online():
         try:
             return self.get_mongo_client().server_info()
         except OperationFailure, ofe:
             log_exception(ofe)
             if "there are no users authenticated" in str(ofe):
                 # this is a pymongo 3.6.1 regression where the buildinfo command fails on non authenticated client
                 # fall-back to an authenticated client
                 admin_db = self.get_db("admin", no_auth=False)
                 return admin_db.command("buildinfo")
         except Exception, e:
             log_exception(e)

 def needs_to_auth(self, dbname):
     """
     Determines if the server needs to authenticate to the database.
     NOTE: we stopped depending on is_auth() since its only a configuration
     and may not be accurate
     """
     log_debug("Checking if server '%s' needs to auth on  db '%s'...." %
               (self.id, dbname))
     try:
         client = self.get_mongo_client()
         db = client.get_database(dbname)
         db.collection_names()
         result = False
     except (RuntimeError,Exception), e:
         log_exception(e)
         # updated for to handle auth failures from mongodb 3.6
         result = "authorized" in str(e) or "there are no users authenticated" in str(e)