#### Shared reader thread

// unless that metadata is needed in order to allow a subsequent data retrieval
// to  be  correctly  handled.   For example, changes to st_atime or st_mtime
// (respectively, time of last access and time of last modification; see inode(7))
// do not require flushing because they are not necessary for a subsequent data
// read to be handled correctly. On the other hand, a change to the file size

    append("-----BEGIN CERTIFICATE-----\n")
    encodeBase64Lines(encoded.toByteString())
    append("-----END CERTIFICATE-----\n")
  }
}

internal fun StringBuilder.encodeBase64Lines(data: ByteString) {
  val base64 = data.base64()
  for (i in 0 until base64.length step 64) {
    append(base64, i, minOf(i + 64, base64.length)).append('\n')
  }

Exec Time:  /*pmb.webFsIndexExecTime:orElse('-')*/ ms
Num of Doc: /*pmb.webFsIndexSize:orElse('-')*/ docs

--- Data Store Crawler ---
Start Time: /*pmb.dataCrawlStartTime:orElse('-')*/
End Time:   /*pmb.dataCrawlEndTime:orElse('-')*/
Exec Time:  /*pmb.dataCrawlExecTime:orElse('-')*/ ms

--- Data Store Indexer ---
Exec Time:  /*pmb.dataIndexExecTime:orElse('-')*/ ms
Num of Doc: /*pmb.dataIndexSize:orElse('-')*/ docs

)

boto3_session = Session(botocore_session=bc_session)
s3 = boto3_session.resource('s3', endpoint_url='http://localhost:9000')

with open('/etc/hosts', 'rb') as data:
    s3.meta.client.upload_fileobj(data,
                                  'testbucket',
                                  'hosts',
                                  ExtraArgs={'ServerSideEncryption': 'AES256'})

		} else {
			var data []byte
			if data, err = json.Marshal(struct{ Records []event.Event }{[]event.Event{eventData}}); err != nil {
				return err
			}

			_, err = conn.Do("HSET", target.args.Key, key, data)
		}
		if err != nil {
			return err
		}
	}

	if target.args.Format == event.AccessFormat {

You declare the "shape" of the data as classes with attributes.

And each attribute has a type.

Then you create an instance of that class with some values and it will validate the values, convert them to the appropriate type (if that's the case) and give you an object with all the data.

And you get all the editor support with that resulting object.

		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL)
		return
	}
	data, err := io.ReadAll(r.Body)
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL)
		return
	}
	reader := bytes.NewReader(data)
	zr, err := zip.NewReader(reader, int64(len(data)))
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL)

    /**
     * @param responseType
     * @return decoded data
     * @throws SmbException
     */
    @SuppressWarnings ( "unchecked" )
    public <T extends Decodable> T getOutputData ( Class<T> responseType ) throws SmbException {

        Decodable out = getOutputData();

        if ( out == null ) {
            throw new SmbException("Failed to decode output data");
        }

lifecycle transition rules and becomes eligible for tiering. MinIO scanner (which runs at one minute intervals, each time scanning one sixteenth of the namespace), picks up the object for tiering. The data is moved to the remote tier in entirety, leaving only the object metadata on MinIO.

The data on the backend is stored under the `bucket/prefix` specified in the tier configuration with a custom name derived from a randomly generated uuid - e.g. `0b/c4/0bc4fab7-2daf-4d2f-8e39-5c6c6fb7e2d3`....