if !ok {
		return
	}
	for _, t := range tgts {
		delete(sys.arnRemotesMap, t.Arn)
	}
	delete(sys.targetsMap, bucket)
}

// SetTarget - sets a new minio-go client target for this bucket.
func (sys *BucketTargetSys) SetTarget(ctx context.Context, bucket string, tgt *madmin.BucketTarget, update bool) error {
	if !tgt.Type.IsValid() && !update {
		return BucketRemoteArnTypeInvalid{Bucket: bucket}
	}

        setLastUpdated(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());
        setJobStatus(Constants.RUNNING);
        final String myName = ComponentUtil.getFessConfig().getSchedulerTargetName();
        setTarget(StringUtil.isNotBlank(myName) ? myName : Constants.DEFAULT_JOB_TARGET);
    }

    public ScheduledJob getScheduledJob() {
        return scheduledJob;
    }

    public String getId() {

        if (in.read(buffer, bufferIndex, length) != length) {
            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        retargetAddress = new NbtAddress(null, addr, false, NbtAddress.B_NODE);

            result.setScriptType(DfTypeUtil.toString(source.get("scriptType")));
            result.setSortOrder(DfTypeUtil.toInteger(source.get("sortOrder")));
            result.setTarget(DfTypeUtil.toString(source.get("target")));
            result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));
            result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));

            result.setScriptType(DfTypeUtil.toString(source.get("scriptType")));
            result.setStartTime(DfTypeUtil.toLong(source.get("startTime")));
            result.setTarget(DfTypeUtil.toString(source.get("target")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {

        checkVertex(vFrom);
        checkVertex(vTo);

        checkVertices();

        checkEdge(e);
        checkEdges();

        e.setSource(vFrom);
        e.setTarget(vTo);

        vFrom.setCompareVersion(versionedVertices);
        vFrom.setCompareScope(scopedVertices);

        List<MetadataGraphEdge> exList = excidentEdges.computeIfAbsent(vFrom, k -> new ArrayList<>());

	target.ResetBeforeDate = UTCNow().AddDate(0, 0, -1*int(days/24))
	target.ResetID = resetID
	rinfo.Targets = append(rinfo.Targets, ResyncTarget{Arn: tgtArns[0], ResetID: target.ResetID})
	if err = globalBucketTargetSys.SetTarget(ctx, bucket, &target, true); err != nil {
		switch err.(type) {
		case RemoteTargetConnectionErr:
			writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrReplicationRemoteConnectionError, err), r.URL)
		default:

                entity.setGenerator(task.getValue1());
                entity.setThumbnailId(task.getValue2());
                entity.setPath(task.getValue3());
                entity.setTarget(target);
                entity.setCreatedBy(Constants.SYSTEM_USER);
                entity.setCreatedTime(systemHelper.getCurrentTimeAsLong());
                list.add(entity);
            }
        });

	if target.BandwidthLimit > 0 && target.BandwidthLimit < 100*1000*1000 {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrReplicationBandwidthLimitError, err), r.URL)
		return
	}
	if err = globalBucketTargetSys.SetTarget(ctx, bucket, &target, update); err != nil {
		switch err.(type) {
		case RemoteTargetConnectionErr:
			writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrReplicationRemoteConnectionError, err), r.URL)
		default:

				targetToUpdate.ReplicationSync = (peer.SyncState == madmin.SyncEnabled)
			}
			if updateBW {
				targetToUpdate.BandwidthLimit = int64(peer.DefaultBandwidth.Limit)
			}
			err := globalBucketTargetSys.SetTarget(ctx, bucket, &targetToUpdate, true)
			if err != nil {
				return c.annotatePeerErr(peer.Name, "Bucket target update error", err)
			}
			targets, err := globalBucketTargetSys.ListBucketTargets(ctx, bucket)