if len(proxy) > 0 {
		proxyURL, err = xnet.ParseHTTPURL(proxy)
		if err != nil {
			return cfg, err
		}

	}

	cfg.License = strings.TrimSpace(env.Get(config.EnvMinIOSubnetLicense, kvs.Get(config.License)))
	cfg.APIKey = strings.TrimSpace(env.Get(config.EnvMinIOSubnetAPIKey, kvs.Get(config.APIKey)))
	cfg.Proxy = proxy

	if transport == nil {
		// when transport is nil, it means we are just validating the

		for _, v := range strings.Split(strings.TrimSpace(headerVal), ",") {
			if v != "" {
				attributes[v] = struct{}{}
			}
		}
	}

	return
}

func parseIntHeader(bucket, object string, h http.Header, headerName string) (value int, err error) {
	stringInt := strings.TrimSpace(h.Get(headerName))
	if stringInt == "" {
		return
	}

        this.fieldRuleMap = fieldRuleMap;
    }

    /**
     * @return the trimSpace
     */
    public boolean isTrimSpace() {
        return trimSpaceEnabled;
    }

    /**
     * @param trimSpace the trimSpace to set
     */
    public void setTrimSpace(final boolean trimSpace) {
        trimSpaceEnabled = trimSpace;
    }

    /**
     * @return the charsetName
     */

        this.fieldRuleMap = fieldRuleMap;
    }

    public boolean isTrimSpace() {
        return trimSpaceEnabled;
    }

    public void setTrimSpace(final boolean trimSpace) {
        trimSpaceEnabled = trimSpace;
    }

    public String getCharsetName() {
        return charsetName;
    }

    public void setCharsetName(final String charsetName) {
        this.charsetName = charsetName;

			logger := clog.NewConsoleLogger(&outBuf, &errBuf, nil)
			IsK8VersionSupported(k8sClient, logger)

			errMsgTrim := strings.TrimSpace(c.logMsg)
			outBufTrim := strings.TrimSpace(outBuf.String())

			if !c.isValid && strings.Compare(errMsgTrim, outBufTrim) != 0 {
				t.Fatalf("\nwanted: %v \nbut found: %v", errMsgTrim, outBufTrim)
			}

func parsEnvEntry(envEntry string) (envKV, error) {
	envEntry = strings.TrimSpace(envEntry)
	if envEntry == "" {
		// Skip all empty lines
		return envKV{
			Skip: true,
		}, nil
	}
	if strings.HasPrefix(envEntry, "#") {
		// Skip commented lines
		return envKV{
			Skip: true,
		}, nil
	}
	envTokens := strings.SplitN(strings.TrimSpace(strings.TrimPrefix(envEntry, "export")), config.EnvSeparator, 2)

	// Read certificate file.
	var data []byte
	if data, err = os.ReadFile(certFile); err != nil {
		return nil, err
	}

	// Trimming leading and tailing white spaces.
	data = bytes.TrimSpace(data)

	// Parse all certs in the chain.
	current := data
	for len(current) > 0 {
		var pemBlock *pem.Block
		if pemBlock, current = pem.Decode(current); pemBlock == nil {

		typeName = polymorphic + "Type"
		typeId   = polymorphic + "ID"
	)

	if value, ok := field.TagSettings["POLYMORPHICTYPE"]; ok {
		typeName = strings.TrimSpace(value)
	}

	if value, ok := field.TagSettings["POLYMORPHICID"]; ok {
		typeId = strings.TrimSpace(value)
	}

	relation.Polymorphic.PolymorphicType = relation.FieldSchema.FieldsByName[typeName]

}

const ipv6DisabledLo = "/proc/sys/net/ipv6/conf/lo/disable_ipv6"

func ReadSysctl(key string) (string, error) {
	data, err := os.ReadFile(key)
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(string(data)), nil
}

func forEachLoopbackRoute(cfg *Config, operation string, f func(*netlink.Route) error) error {
	loopbackLink, err := netlink.LinkByName("lo")
	if err != nil {

	}
	return err
}

// returns 'true' if either string has space in the
// - beginning of a string
// OR
// - end of a string
func hasSpaceBE(s string) bool {
	return strings.TrimSpace(s) != s
}

func request2BucketObjectName(r *http.Request) (bucketName, objectName string) {
	path, err := getResource(r.URL.Path, r.Host, globalDomainNames)
	if err != nil {
		logger.CriticalIf(GlobalContext, err)