text: """
  test_bilog_trimmming - Test  trimming feature
  
  Usage: test_bilog_trimming.py -c <input_yaml>
  
  <input_yaml>
      Note: Following yaml can be used
      test_bilog_trimming.yaml
  
  Operation:
      Create an user
      Create a bucket with user credentials
      Upload obects to bucket
      Verify bucket index log is not empty after creating objects
      Wait for default interval of 20 minutes
      Verify bucket index log is empty
      
  """
  
  import os
  import sys
  
  sys.path.append(os.path.abspath(os.path.join(__file__, "../../../..")))
  import argparse
  import json
  import logging
  import time
  import traceback
  
  import v2.lib.resource_op as s3lib
  import v2.utils.utils as utils
  from v2.lib.exceptions import TestExecError
  from v2.lib.s3.auth import Auth
  from v2.lib.s3.write_io_info import BasicIOInfoStructure, IOInfoInitialize
  from v2.tests.s3_swift import reusable
  from v2.utils.log import configure_logging
  from v2.utils.test_desc import AddTestInfo
  
  log = logging.getLogger()
  TEST_DATA_PATH = None
  
  
  def test_exec(config):
  
      io_info_initialize = IOInfoInitialize()
      basic_io_structure = BasicIOInfoStructure()
      io_info_initialize.initialize(basic_io_structure.initial())
  
      # create user
      all_users_info = s3lib.create_users(config.user_count)
      for each_user in all_users_info:
          # authenticate
          auth = Auth(each_user, ssl=config.ssl)
          rgw_conn = auth.do_auth()
  
          if config.test_ops["create_bucket"] is True:
              log.info("no of buckets to create: %s" % config.bucket_count)
              for bc in range(config.bucket_count):
                  bucket_name_to_create = utils.gen_bucket_name_from_userid(
                      each_user["user_id"], rand_no=bc
                  )
                  log.info("creating bucket with name: %s" % bucket_name_to_create)
                  bucket = reusable.create_bucket(
                      bucket_name_to_create, rgw_conn, each_user
                  )
                  if config.test_ops["create_object"] is True:
                      # uploading data
                      log.info("s3 objects to create: %s" % config.objects_count)
                      for oc, size in list(config.mapped_sizes.items()):
                          config.obj_size = size
                          s3_object_name = utils.gen_s3_object_name(
                              bucket_name_to_create, oc
                          )
                          log.info("s3 object name: %s" % s3_object_name)
                          s3_object_path = os.path.join(TEST_DATA_PATH, s3_object_name)
                          log.info("s3 object path: %s" % s3_object_path)
  
                          log.info("upload type: normal")
                          reusable.upload_object(
                              s3_object_name,
                              bucket,
                              TEST_DATA_PATH,
                              config,
                              each_user,
                          )
  
                  # Verify bilog list is not empty after creating objects
                  cmd = f"radosgw-admin bilog list --bucket {bucket_name_to_create}"
                  output1 = json.loads(utils.exec_shell_cmd(cmd))
                  if len(output1) > 0:
                      log.info("Bucket index log is not empty")
                  else:
                      raise TestExecError("Bucket index log is empty")
  
                  # Setting interval to default time of 20 minutes
                  time.sleep(1260)
  
                  # Verify bilog list is empty after the interval of creating objects
                  output2 = json.loads(utils.exec_shell_cmd(cmd))
  
                  if len(output2) == 0:
                      log.info("Bucket index log is empty after the interval")
                  else:
                      raise TestExecError(
                          "Bucket index log is not empty after the interval"
                      )
  
  
  if __name__ == "__main__":
      test_info = AddTestInfo("test bilog trimming")
  
      try:
          project_dir = os.path.abspath(os.path.join(__file__, "../../.."))
          test_data_dir = "test_data"
          TEST_DATA_PATH = os.path.join(project_dir, test_data_dir)
          log.info(f"TEST_DATA_PATH: {TEST_DATA_PATH}")
          if not os.path.exists(TEST_DATA_PATH):
              log.info("test data dir not exists, creating.. ")
              os.makedirs(TEST_DATA_PATH)
          parser = argparse.ArgumentParser(description="test bilog trimming")
          parser.add_argument(
              "-c", dest="config", help="test bilog trimming yaml configuration"
          )
          parser.add_argument(
              "-log_level",
              dest="log_level",
              help="Set Log Level [DEBUG, INFO, WARNING, ERROR, CRITICAL]",
              default="info",
          )
          args = parser.parse_args()
          yaml_file = args.config
          log_f_name = os.path.basename(os.path.splitext(yaml_file)[0])
          configure_logging(f_name=log_f_name, set_level=args.log_level.upper())
          config = s3lib.Config(yaml_file)
          config.read()
          if config.mapped_sizes is None:
              config.mapped_sizes = utils.make_mapped_sizes(config)
  
          test_exec(config)
          test_info.success_status("test passed")
          sys.exit(0)
  
      except (TestExecError, Exception) as e:
          log.info(e)
          log.info(traceback.format_exc())
          test_info.failed_status("test failed")
          sys.exit(1)
  