Collect {@link ApiCallMonitoringEvent} per request.
435847
private ApiCallMonitoringEvent generateApiCallMonitoringEvent(Request<?> request) {
        String apiName = request.getHandlerContext(HandlerContextKey.OPERATION_NAME);
        String serviceId = request.getHandlerContext(HandlerContextKey.SERVICE_ID);
        String region = request.getHandlerContext(HandlerContextKey.SIGNING_REGION);
        ApiCallAttemptMonitoringEvent lastApiCallAttempt = request.getHandlerContext(LAST_CALL_ATTEMPT);

        Long timestamp = null;
        Long latency = null;
        Integer requestCount = 0;
        AWSRequestMetrics metrics = request.getAWSRequestMetrics();

        if (metrics != null) {
            TimingInfo timingInfo = metrics.getTimingInfo();
            requestCount = timingInfo.getCounter(AWSRequestMetrics.Field.RequestCount.name()) == null ? 0 :
                           timingInfo.getCounter(AWSRequestMetrics.Field.RequestCount.name()).intValue();

            TimingInfo latencyTimingInfo = timingInfo.getSubMeasurement(AwsClientSideMonitoringMetrics.ApiCallLatency.name());
            if (latencyTimingInfo != null) {
                latency = convertToLongIfNotNull(latencyTimingInfo.getTimeTakenMillisIfKnown());
                timestamp = latencyTimingInfo.getStartEpochTimeMilliIfKnown();
            }
        }

        ApiCallMonitoringEvent event = new ApiCallMonitoringEvent()
                .withApi(apiName)
                .withVersion(VERSION)
                .withRegion(region)
                .withService(serviceId)
                .withClientId(clientId)
                .withAttemptCount(requestCount)
                .withLatency(latency)
                .withUserAgent(trimValueIfExceedsMaxLength(USER_AGENT_KEY, getDefaultUserAgent(request)))
                .withTimestamp(timestamp);

        if (lastApiCallAttempt != null) {
            event.withFinalAwsException(lastApiCallAttempt.getAwsException())
                 .withFinalAwsExceptionMessage(lastApiCallAttempt.getAwsExceptionMessage())
                 .withFinalSdkException(lastApiCallAttempt.getSdkException())
                 .withFinalSdkExceptionMessage(lastApiCallAttempt.getSdkExceptionMessage())
                 .withFinalHttpStatusCode(lastApiCallAttempt.getHttpStatusCode());
        }

        return event;
    }
897508
def _getUpcomingEvents(self, request):
        """"""
        home = request.site.root_page
        return getAllUpcomingEvents(request, home=home)
755512
public BoxRequestsEvent.GetEnterpriseEvents getEnterpriseEventsRequest() {
        BoxRequestsEvent.GetEnterpriseEvents request = new BoxRequestsEvent.GetEnterpriseEvents(getEventsUrl(), mSession);
        return request;
    }
748399
public java.util.List<StackEvent> getStackEvents() {
        if (stackEvents == null) {
            stackEvents = new com.amazonaws.internal.SdkInternalList<StackEvent>();
        }
        return stackEvents;
    }
507823
public void runEventProcessingLoop() {
        final long port = this.completionPort;
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "runEventProcessingLoop: " + port + " " + Thread.currentThread());
        }

        final IAsyncProvider provider = AsyncLibrary.getInstance();
        final int size = this.batchSize;
        final int jitSize = 8192;
        final int timeout = AsyncProperties.completionTimeout;
        final WsByteBufferPoolManager wsByteBufferManager = ChannelFrameworkFactory.getBufferManager();
        final boolean jitCapable = provider.hasCapability(IAsyncProvider.CAP_JIT_BUFFERS);
        final boolean batchCapable = (1 < size);

        long[] compKeyAddrs = new long[size];
        long[] jitBufferAddressBatch = new long[size];
        WsByteBuffer[] wsBBBatch = new WsByteBuffer[size];

        int keysReady = 0;
        CompletionKey completionKey = null;

        AsyncFuture future;
        int rc = 0;
        long numBytes = 0L;

        CompletionKey[] compKeys = new CompletionKey[size];
        for (int i = 0; i < size; i++) {
            compKeys[i] = (CompletionKey) AsyncLibrary.completionKeyPool.get();
            if (compKeys[i] != null) {
                // Initialize the IOCB obtained from the pool
                compKeys[i].initializePoolEntry(0, 0);

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Handler got CompletionKey from Pool:" + compKeys[i]);
                }
            } else {
                compKeys[i] = new CompletionKey();

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Handler newed up CompletionKey:" + compKeys[i]);
                }
            }
            compKeyAddrs[i] = compKeys[i].getAddress();
        }

        try {
            // loop until we should not do any more
            while (true) {
                // see if we are shutting down, access directly for better performance
                if (AsyncLibrary.aioInitialized == AsyncLibrary.AIO_SHUTDOWN) {
                    // leave immediately if we are shutting down
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "AIO library is shutdown, ending loop");
                    }
                    break;
                }

                future = null;
                keysReady = 0;

                this.handlersWaiting.getAndIncrement();

                // get the completion keys ready for use
                if (jitCapable) {
                    for (int i = 0; i < size; i++) {
                        // reset the completionKey for next request.  Commenting this out
                        // for performance reasons.  It is driving 4 put calls per IOCD.
                        // The native code will now reset() between calls.
                        //compKeys[i].reset();

                        // see if we need to allocate a jit buffer
                        if (jitBufferAddressBatch[i] == 0) {
                            wsBBBatch[i] = wsByteBufferManager.allocateDirect(jitSize);
                            ByteBuffer bb = wsBBBatch[i].getWrappedByteBufferNonSafe();
                            jitBufferAddressBatch[i] = AbstractAsyncChannel.getBufAddress(bb);

                            compKeys[i].setJITBufferUsed();
                            compKeys[i].setBuffer(jitBufferAddressBatch[i], jitSize, 0);
                        }
                    }
                }

                // Blocks until an async call completes, or the timeout occurs
                try {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "waiting for native event port=" + port);
                    }

                    if (batchCapable) {
                        keysReady = provider.getCompletionData3(compKeyAddrs, size, timeout, port);

                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "(batch) events: " + keysReady);
                        }
                    } else {
                        boolean gotData = provider.getCompletionData2(compKeyAddrs[0], timeout, port);

                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "(no batch) events: " + gotData);
                        }

                        if (gotData) {
                            keysReady = 1;

                            // Not used below...Commenting out for performance
                            //compKeys[0].setReturnStatus(1);
                        } else {
                            keysReady = 0;

                            // Not used below...Commenting out for performance
                            //compKeys[0].setReturnStatus(0);
                        }
                    }

                } catch (AsyncException exception) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "Error getting IO completion event: " + exception);
                    }
                    FFDCFilter.processException(exception, getClass().getName() + ".runEventProcessingLoop", "331", this);
                } finally {
                    this.handlersWaiting.getAndDecrement();
                }

                // if we didn't get data, go back to the top of the loop and try again
                if (keysReady == 0) {
                    // make sure this completion port didn't get closed, and then AIO
                    // restarted while this thread was in the native AIO code
                    if ((AsyncLibrary.aioInitialized != AsyncLibrary.AIO_SHUTDOWN)) {
                        if (!provider.isCompletionPortValid(port)) {
                            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                Tr.debug(tc, "Completion port not valid");
                            }
                            break;
                        }
                    } else {
                        // AIO shutdown, so break out now
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "AIO Shutdown detected, break out");
                        }
                        break;
                    }

                    // Timeout path. Just loop back.
                    continue;
                } // end-no-events-received
                else if (this.handlersWaiting.get() == 0) {
                    // if we have work to process and nobody else is currently
                    // calling into the native code, start an extra handler now
                    // (if allowed)
                    startHandler();
                }

                this.numItemsFromNative += keysReady;

                for (int j = keysReady - 1; j >= 0; j--) {
                    completionKey = compKeys[j];

                    // if we get here (no timeout and no exception), we should have a
                    // valid completion key
                    completionKey.postNativePrep();
                    long callid = completionKey.getCallIdentifier();

                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "batch index: " + j + " call id: " + Long.toHexString(callid) + " channel id: " + completionKey.getChannelIdentifier());
                        Tr.debug(tc, "completionKey: " + completionKey);
                    }

                    int channelIndex = (int) (callid & 0x00000000FFFFFFFF);
                    int futureIndex = (int) (callid >> 32);
                    AbstractAsyncChannel theChannel = AbstractAsyncChannel.getChannelFromIndex(channelIndex);

                    if (theChannel == null) {
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "Could not find channel, possibly closed " + completionKey);
                        }
                        continue;
                    }

                    future = theChannel.getFutureFromIndex(futureIndex);

                    if (future == null) {
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "Completion event could not find future " + completionKey);
                        }
                        AsyncException exception = new AsyncException("Future not found");
                        FFDCFilter.processException(exception, getClass().getName() + ".runEventProcessingLoop", "142", this);
                        continue;
                    }

                    if (jitCapable && completionKey.wasJITBufferUsed()) {
                        // set the JIT buffer value in the future
                        future.setJITBuffer(wsBBBatch[j]);
                        jitBufferAddressBatch[j] = 0;
                        // reset so new jit buffer will be allocated for next call
                    } else {
                        future.setJITBuffer(null);
                    }
                    rc = completionKey.getReturnCode();
                    numBytes = completionKey.getBytesAffected();

                    // check the event to see if it is for synchronous request
                    if (futureIndex == AbstractAsyncChannel.SYNC_READ_FUTURE_INDEX || futureIndex == AbstractAsyncChannel.SYNC_WRITE_FUTURE_INDEX) {
                        // notify waiting sync request

                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                            Tr.debug(tc, "Processing Sync Request rc: " + rc);
                        }

                        if (rc == 0) {
                            // Defend against erroneous combination of values returned from
                            // native
                            if (numBytes == 0L) {
                                IOException ioe = new IOException("Async IO operation failed, internal error");
                                future.completed(ioe);
                                continue;
                            }
                            // Mark the future as completed
                            future.setCancelInProgress(0);
                            future.completed(numBytes);
                        } else {
                            if (future.getCancelInProgress() == 1) {
                                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                    Tr.debug(tc, "Cancel is in progress, ignoring");
                                }
                                future.setCancelInProgress(0);
                            } else {
                                future.completed(AsyncLibrary.getIOException("Async IO operation failed (3), reason: ", rc));
                            }
                        }
                        continue; // sync response has been processed
                    }

                    // signal the IO completion
                    // Check to see if the IO operation succeeded
                    if (rc == 0) {
                        future.setCancelInProgress(0);
                        future.completed(numBytes);
                    } else {
                        if (future.getCancelInProgress() == 1) {
                            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                                Tr.debug(tc, "Cancel is in progress, ignoring");
                            }
                            future.setCancelInProgress(0);
                        } else {
                            future.completed(AsyncLibrary.getIOException("Async IO operation failed (2), reason: ", rc));
                        }
                    }

                } // end the batch loop
            } // end of "while (true) {"
        } catch (Throwable t) {
            if (AsyncLibrary.aioInitialized != AsyncLibrary.AIO_SHUTDOWN) {
                FFDCFilter.processException(t, getClass().getName() + ".runEventProcessingLoop", "792", this);
                throw new RuntimeException(t);
            }
        } finally {

            // Decrement the number of in flight handlers, since this one is exiting
            this.numHandlersInFlight.decrementInt();

            // The completion processing thread is being shut down or failed
            // if jit buffer was allocated, release it
            for (int k = 0; k < size; k++) {
                if (jitBufferAddressBatch[k] != 0) {
                    wsBBBatch[k].release();
                }
            }

            // Put the CompletionKeys into the pool for reuse.   They contain a DirectByteBuffer (WsByteBuffer).
            for (int i = 0; i < size; i++) {
                if (compKeys[i] != null) {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "Handler ending, pooling CompletionKey:\n" + compKeys[i]);
                    }
                    AsyncLibrary.completionKeyPool.put(compKeys[i]);
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "runEventProcessingLoop: " + port + " " + Thread.currentThread());
        }
    }
864662
public Set<Event<?>> completionEvents() {
        return completionEvents == null ? Collections.emptySet()
            : Collections.unmodifiableSet(completionEvents);
    }
1354969
private void submitRecordsCountsEvent() {
    long lateOutputRecordCount = this.datasetHelper.getLateOutputRecordCount();
    long outputRecordCount = this.datasetHelper.getOutputRecordCount();

    try {
      CompactionSlaEventHelper
          .getEventSubmitterBuilder(this.dataset, Optional.<Job> absent(), this.fs)
          .eventSubmitter(this.eventSubmitter)
          .eventName(CompactionSlaEventHelper.COMPACTION_RECORD_COUNT_EVENT)
          .additionalMetadata(CompactionSlaEventHelper.DATASET_OUTPUT_PATH, this.dataset.outputPath().toString())
          .additionalMetadata(
              CompactionSlaEventHelper.LATE_RECORD_COUNT,
              Long.toString(lateOutputRecordCount))
          .additionalMetadata(
              CompactionSlaEventHelper.REGULAR_RECORD_COUNT,
              Long.toString(outputRecordCount))
          .additionalMetadata(CompactionSlaEventHelper.NEED_RECOMPACT, Boolean.toString(this.dataset.needToRecompact()))
          .build().submit();
    } catch (Throwable e) {
      LOG.warn("Failed to submit late event count:" + e, e);
    }
  }
620008
private void collectReceiver(final Class<?> eventClass, final Collection<ReceiverDescriptor> receiverCollection) {

		if (this.receiverMap.get(eventClass) != null) {
			receiverCollection.addAll(this.receiverMap.get(eventClass));
		}
		if (!eventClass.isInterface() && eventClass.getSuperclass() != Object.class) {
			this.collectReceiver(eventClass.getSuperclass(), receiverCollection);
		}
		for (final Class interfaceClass : eventClass.getInterfaces()) {
			this.collectReceiver(interfaceClass, receiverCollection);
		}
	}
1019674
private void getSuperEventSets(Class eventSet, List<Class> superEventSets)
    {
        Class[] superInterfaces = eventSet.getInterfaces();
        if (superInterfaces != null)
        {
            for (int i=0; i < superInterfaces.length; i++)
            {
                Class superInterface = superInterfaces[i];
                if (superInterface.isAnnotationPresent(EventSet.class))
                {
                    superEventSets.add(superInterface);

                    // Continue traversing up the EventSet inheritance hierarchy
                    getSuperEventSets(superInterface, superEventSets);
                }
            }
        }
    }
411029
public BoxRequestsCollections.GetCollections getCollectionsRequest() {
        BoxRequestsCollections.GetCollections request = new BoxRequestsCollections.GetCollections(getCollectionsUrl(), mSession);
        return request;
    }
706954
private Events<Event> getEvents(CanalEventStore eventStore, Position start, int batchSize, Long timeout,
                                    TimeUnit unit) {
        if (timeout == null) {
            return eventStore.tryGet(start, batchSize);
        } else {
            try {
                if (timeout <= 0) {
                    return eventStore.get(start, batchSize);
                } else {
                    return eventStore.get(start, batchSize, timeout, unit);
                }
            } catch (Exception e) {
                throw new CanalServerException(e);
            }
        }
    }
217424
public static List<EventSubscriptionEntity> collectCompensateEventSubscriptionsForActivity(ActivityExecution execution, String activityRef) {

    final List<EventSubscriptionEntity> eventSubscriptions = collectCompensateEventSubscriptionsForScope(execution);
    final String subscriptionActivityId = getSubscriptionActivityId(execution, activityRef);

    List<EventSubscriptionEntity> eventSubscriptionsForActivity = new ArrayList<EventSubscriptionEntity>();
    for (EventSubscriptionEntity subscription : eventSubscriptions) {
      if (subscriptionActivityId.equals(subscription.getActivityId())) {
        eventSubscriptionsForActivity.add(subscription);
      }
    }
    return eventSubscriptionsForActivity;
  }
243282
synchronized void requestCompleted(ClientWorldModelInterface worldModel,
      AbstractRequestMessage message) {
    Long ticket = Long.valueOf(message.getTicketNumber());
    log.debug("Request {} completed.", ticket);

    Response resp = this.outstandingSnapshots.remove(ticket);
    // Snapshot request
    if (resp != null) {
      log.debug("Retrieved {} for Tix#{}", resp, ticket);
      WorldState ws = this.outstandingStates.get(ticket);
      if (ws == null) {
        log.error("Unknown ticket number {} for request.", ticket, message);
        return;
      }
      resp.setState(ws);
      return;
    }

    StepResponse sResp = this.outstandingSteps.remove(ticket);
    // Range/Streaming request
    if (sResp != null) {
      log.debug("Retrieved {} for Tix#{}", resp, ticket);
      sResp.setComplete();
      return;
    }

    log.error("Couldn't find response for ticket {}.", ticket);
  }
934191
def getAllEvents(request, *, home=None):
    
    qrys = [SimpleEventPage.events(request).all(),
            MultidayEventPage.events(request).all(),
            RecurringEventPage.events(request).all()]
    # Does not return exceptions
    if home is not None:
        qrys = [qry.descendant_of(home) for qry in qrys]
    events = sorted(chain.from_iterable(qrys),
                    key=attrgetter('_first_datetime_from'))
    return events
166277
private void submitVerificationSuccessSlaEvent(Results.Result result) {
    try {
      CompactionSlaEventHelper.getEventSubmitterBuilder(result.dataset(), Optional.<Job> absent(), this.fs)
      .eventSubmitter(this.eventSubmitter).eventName(CompactionSlaEventHelper.COMPLETION_VERIFICATION_SUCCESS_EVENT_NAME)
      .additionalMetadata(Maps.transformValues(result.verificationContext(), Functions.toStringFunction())).build()
      .submit();
    } catch (Throwable t) {
      LOG.warn("Failed to submit verification success event:" + t, t);
    }
  }
63096
public void processRequest(RequestEvent requestEvent) {
        // This will be invoked only by external endpoint
    	BalancerAppContent content=(BalancerAppContent)requestEvent.getSource();
    	boolean isIpv6 = content.isIpv6();
        final SipProvider sipProvider = content.getProvider();
        final Request request = requestEvent.getRequest();
        final String requestMethod = request.getMethod();

        if(logger.isDebugEnabled()) {
            logger.debug("got request:\n"+request);
        }
        
        if((requestMethod.equals(Request.OPTIONS) ||
                requestMethod.equals(Request.INFO)) &&
                request.getHeader("Mobicents-Heartbeat") != null &&
                sipProvider == balancerRunner.balancerContext.internalSipProvider) {
            byte[] bytes = (byte[]) request.getContent();
            Properties prop = new Properties();
            try {
                prop.load(new ByteArrayInputStream(bytes, 0, bytes.length));
                Node node = new Node(prop.getProperty("hostname"), prop.getProperty("ip"));
                for(String id : prop.stringPropertyNames()) {
                    node.getProperties().put(id, prop.getProperty(id));
                }
                ArrayList<Node> list = new ArrayList<Node>();
                list.add(node);
                this.register.handlePingInRegister(list);
                Response response = balancerRunner.balancerContext.messageFactory.createResponse(Response.OK, request);			
                sipProvider.sendResponse(response);	
                return;
            } catch (Exception e) {
                logger.error("Failure parsing heartbeat properties from this request " + request, e);
            }
        }
        //Issue 10: https://telestax.atlassian.net/browse/LB-10
        if (request.getContent() != null || (requestMethod.equals(Request.REGISTER) && sipProvider != balancerRunner.balancerContext.internalSipProvider)) {
            SIPMessage message = (SIPMessage)request;            

            String initialRemoteAddr = message.getPeerPacketSourceAddress().getHostAddress();
            String initialRemotePort = String.valueOf(message.getPeerPacketSourcePort());

            Header remoteAddrHeader = null;
            Header remotePortHeader = null;
            try {
                remoteAddrHeader = SipFactory.getInstance().createHeaderFactory().createHeader("X-Sip-Balancer-InitialRemoteAddr", initialRemoteAddr);
                remotePortHeader = SipFactory.getInstance().createHeaderFactory().createHeader("X-Sip-Balancer-InitialRemotePort", initialRemotePort);
            } catch (PeerUnavailableException e) {
                logger.error("Unexpected exception while creating custom headers for REGISTER message ", e);
            } catch (ParseException e) {
                logger.error("Unexpected exception while creating custom headers for REGISTER message ", e);
            }
            if (remoteAddrHeader != null)
                request.addHeader(remoteAddrHeader);
            if (remotePortHeader != null)
                request.addHeader(remotePortHeader);
        } 
        try {	
            updateStats(request);
            forwardRequest(sipProvider,request, isIpv6);          						
        } catch (Throwable throwable) {
            logger.error("Unexpected exception while forwarding the request " + request, throwable);
            if(!Request.ACK.equalsIgnoreCase(requestMethod)) {
                try {
                    Response response = balancerRunner.balancerContext.messageFactory.createResponse(Response.SERVER_INTERNAL_ERROR, request);			
                    sipProvider.sendResponse(response);	
                } catch (Exception e) {
                    logger.error("Unexpected exception while trying to send the error response for this " + request, e);
                }
            }
        }
    }
735104
@SuppressWarnings({ "PMD.DataflowAnomalyAnalysis", "PMD.EmptyCatchBlock" })
    @RequestHandler(priority = 990, dynamic = true)
    public void onRequest(Request.In event) {
        @SuppressWarnings("PMD.AccessorClassGeneration")
        final Selection selection = event.associated(Session.class)
            .map(session -> (Selection) session.computeIfAbsent(
                Selection.class, newKey -> new Selection(cookieName, path)))
            .orElseGet(() -> new Selection(cookieName, path));
        selection.setCurrentEvent(event);
        event.setAssociated(Selection.class, selection);
        if (selection.isExplicitlySet()) {
            return;
        }

        // Try to get locale from cookies
        final HttpRequest request = event.httpRequest();
        Optional<String> localeNames = request.findValue(
            HttpField.COOKIE, Converters.COOKIE_LIST)
            .flatMap(cookieList -> cookieList.valueForName(cookieName));
        if (localeNames.isPresent()) {
            try {
                List<Locale> cookieLocales = LOCALE_LIST
                    .fromFieldValue(localeNames.get());
                if (!cookieLocales.isEmpty()) {
                    Collections.reverse(cookieLocales);
                    cookieLocales.stream()
                        .forEach(locale -> selection.prefer(locale));
                    return;
                }
            } catch (ParseException e) {
                // Unusable
            }
        }

        // Last resport: Accept-Language header field
        Optional<List<ParameterizedValue<Locale>>> accepted = request.findValue(
            HttpField.ACCEPT_LANGUAGE, Converters.LANGUAGE_LIST);
        if (accepted.isPresent()) {
            Locale[] locales = accepted.get().stream()
                .sorted(ParameterizedValue.WEIGHT_COMPARATOR)
                .map(value -> value.value()).toArray(Locale[]::new);
            selection.updateFallbacks(locales);
        }
    }