if err != nil {
			return err
		}

		c.healBucket(ctx, objAPI, bucket, info)

		if bi.Deleted.IsZero() || (!bi.Created.IsZero() && bi.Deleted.Before(bi.Created)) {
			c.healVersioningMetadata(ctx, objAPI, bucket, info)
			c.healOLockConfigMetadata(ctx, objAPI, bucket, info)
			c.healSSEMetadata(ctx, objAPI, bucket, info)
			c.healBucketReplicationConfig(ctx, objAPI, bucket, info, &opts)

	}

	ctx = lkctx.Context()
	defer locker.Unlock(lkctx)

	// Perform callhome once and then keep running it at regular intervals.
	performCallhome(ctx)

	callhomeTimer := time.NewTimer(globalCallhomeConfig.FrequencyDur())
	defer callhomeTimer.Stop()

	for {
		if !globalCallhomeConfig.Enabled() {
			// Stop the processing as callhome got disabled
			return false
		}

		select {
		case <-ctx.Done():

        pool = new SmbTransportPoolImpl();

        // Setup default mock behaviors
        when(ctx.getConfig()).thenReturn(config);
        when(ctx.getNameServiceClient()).thenReturn(nameSvc);
        when(ctx.getCredentials()).thenReturn(creds);
        when(ctx.getTransportPool()).thenReturn(pool);

        // Default config values
        when(config.getLocalAddr()).thenReturn(null);

}

func (S Tracer) Error(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Error(ctx, s, i...)
}

func (S Tracer) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
	S.Logger.Trace(ctx, begin, fc, err)
	S.Test(ctx, begin, fc, err)

	}
	return buf, r.ObjInfo, nil
}

func readConfig(ctx context.Context, store objectIO, configFile string) ([]byte, error) {
	buf, _, err := readConfigWithMetadata(ctx, store, configFile, ObjectOptions{})
	return buf, err
}

type objectDeleter interface {
	DeleteObject(ctx context.Context, bucket, object string, opts ObjectOptions) (ObjectInfo, error)
}

func deleteConfig(ctx context.Context, objAPI objectDeleter, configFile string) error {

	}
	return false
}

func readAllXL(ctx context.Context, disks []StorageAPI, bucket, object string, readData, inclFreeVers bool) ([]FileInfo, []error) {
	rawFileInfos, errs := readAllRawFileInfo(ctx, disks, bucket, object, readData)
	return pickLatestQuorumFilesInfo(ctx, rawFileInfos, errs, bucket, object, readData, inclFreeVers)
}

		return
	}

	var state madmin.SRStateEditReq
	if err := parseJSONBody(ctx, r.Body, &state, ""); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
	if err := globalSiteReplicationSys.PeerStateEditReq(ctx, state); err != nil {
		adminLogIf(ctx, err)
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
}

func (c *lockRESTClient) RLock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCRLock, &args)
}

// Lock calls lock REST API.
func (c *lockRESTClient) Lock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	return c.call(ctx, lockRPCLock, &args)
}

// RUnlock calls read unlock REST API.

	}

	return updatedAt, sys.save(ctx, meta)
}

func (sys *BucketMetadataSys) save(ctx context.Context, meta BucketMetadata) error {
	objAPI := newObjectLayerFn()
	if objAPI == nil {
		return errServerNotInitialized
	}

	if isMinioMetaBucketName(meta.Name) {
		return errInvalidArgument
	}

	if err := meta.Save(ctx, objAPI); err != nil {
		return err
	}

		return err
	}
	globalBackgroundHealState.updateHealStatus(h)
	return h.disk.WriteAll(ctx, minioMetaBucket,
		pathJoin(bucketMetaPrefix, healingTrackerFilename),
		htrackerBytes)
}

// delete the tracker on disk.
func (h *healingTracker) delete(ctx context.Context) error {
	return h.disk.Delete(ctx, minioMetaBucket,
		pathJoin(bucketMetaPrefix, healingTrackerFilename),
		DeleteOptions{
			Recursive: false,