The group alarm call. The context on this call will be null.
346058
public void alarm(Object context)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.entry(this, tc, "alarm", context);
    
    btmLockManager.lock();
    boolean btmLocked = true;
    timeoutLockManager.lockExclusive();
    boolean timeoutLocked = true;
    try
    {
      //we won't be called unless there are alarms which have timedout but check anyway
      if (!timedout.isEmpty() && !isStopped)
      {
        btmLockManager.unlock();
        btmLocked = false;
        //see defect 280069:
        //So that we can release the exclusive lock before calling processTimedoutEntries
        //(and so avoid deadlock on streamStatus monitor) we take a local copy 
        //(which therefore cannot be modified by anyone behind us) and create 
        //a new list; this replaces holding the exclusive lock for the duration of the method
        //and then clearing the list at the end. 
        
        List tempTimeoutList = timedout; //take a local copy of the list
        
        timedout = new ArrayList<BatchedTimeoutEntry>(); //the timeout entries will be dealt with
        //presently. Meantime we empty the timedout list so that subsequent timeouts
        //can be added to it without affecting processTimedoutEntries
        
        timeoutLockManager.unlockExclusive(); //we no longer care if timedout
        timeoutLocked = false;
        //changes underneath us so we can release the exclusive lock.

        try
        {
          //call the processor with the list of timedout BTEs, which should not be changed
          handler.processTimedoutEntries(tempTimeoutList);
          
          // We had a good batch - clear any previous failures
          batchFailed = false;
          batchCleared = false;
        }
        catch(Throwable e)
        {
          // FFDC the problem with the alarm, but don't re-throw the exception
          FFDCFilter.processException(
            e,
            "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
            "1:280:1.24",
            new Object[] {this, handler, tempTimeoutList});
          
          SibTr.exception(tc, e);          
          
          // Alarms registered with the BatchedTimeoutManager are set to auto-repeat,
          // if we simply report the failure in an alarm it'll probably happen again
          // and again, forever. So we need to take steps to stop that happening, by
          // removing entries and possibly even stopping the manager (athough as a manager
          // is specific to a certain object (e.g. a specific AOStream) the damage should 
          // be contained - although still serious.
          
          // We worked the previous time so we'll give the alarms one more try before
          // bombing out
          if(!batchFailed)
            batchFailed = true;
         // If we've failed before, this was our last chance, something is wrong with
          // at least one of the entries, but we can't tell which one so we'll have to
          // remove all the entries - which will stop the error happening over and over
          // again (but not fix the reason for the error!)
          else
          {
            batchFailed = false;
            
            // Remove all the entries and see if that stops the error happening
            Iterator itr = tempTimeoutList.iterator();
            while(itr.hasNext())
            {
              BatchedTimeoutEntry bte = (BatchedTimeoutEntry)itr.next();
              removeTimeoutEntry(bte);
            }

            // If we've already been here and cleared the entries but something has
            // reregistered a new alarm that caused another problem (probably the same
            // one) we just give up and stop the alarm manager to prevent new alarms
            // being registered
            if(batchCleared)
            {
              // This is serious, throw another FFDC
              SIErrorException e2 =
                new SIErrorException(
                  nls.getFormattedMessage(
                    "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                    new Object[] {
                      "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
                      "1:325:1.24" },
                    null), e);
              
              FFDCFilter.processException(
                e2,
                "com.ibm.ws.sib.processor.utils.am.BatchedTimeoutManager.alarm",
                "1:331:1.24",
                this);
              
              SibTr.exception(tc, e2);
              
              // Stop the timer
              stopTimer();
            }
            // Remember that we've just cleared up after a problem
            else
              batchCleared = true;
          }
        }
        //restart the entries
        restartEntries(tempTimeoutList);      
      }
    }
    finally
    {
      if(timeoutLocked)
        timeoutLockManager.unlockExclusive();
      if(btmLocked)
        btmLockManager.unlock();
    }
        
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    	SibTr.exit(tc, "alarm");
  }
1059698
final public void Null() throws ParseException {
                     /*@bgen(jjtree) Null */
  AstNull jjtn000 = new AstNull(JJTNULL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(NULL);
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
    }
  }
723803
@Override
    public synchronized ChainGroupData getChainGroup(String groupName) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getChainGroup: " + groupName);
        }
        if (null == groupName) {
            return null;
        }
        return this.chainGroups.get(groupName);
    }
291168
public B group(EventLoopGroup group) {
        if (group == null) {
            throw new NullPointerException("group");
        }
        if (this.group != null) {
            throw new IllegalStateException("group set already");
        }
        this.group = group;
        return self();
    }
510434
@Nullable
  private EventExecutorGroup createEventExecutorGroup(int size) {
    if (size <= 0) {
      return null;
    }

    ThreadFactory threadFactory = new ThreadFactory() {
      private final ThreadGroup threadGroup = new ThreadGroup(serviceName + "-executor-thread");
      private final AtomicLong count = new AtomicLong(0);

      @Override
      public Thread newThread(Runnable r) {
        Thread t = new Thread(threadGroup, r, String.format("%s-executor-%d", serviceName, count.getAndIncrement()));
        t.setDaemon(true);
        return t;
      }
    };

    UnorderedThreadPoolEventExecutor executor = new UnorderedThreadPoolEventExecutor(size, threadFactory,
                                                                                     rejectedExecutionHandler);
    if (execThreadKeepAliveSecs > 0) {
      executor.setKeepAliveTime(execThreadKeepAliveSecs, TimeUnit.SECONDS);
      executor.allowCoreThreadTimeOut(true);
    }
    return new NonStickyEventExecutorGroup(executor);
  }
1179343
static void scheduleWingsService(Context context, long delay) {
        Context appContext = context.getApplicationContext();

        // Create pending intent.
        Intent intent = new Intent(appContext, AlarmReceiver.class);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(appContext, 0, intent,
                PendingIntent.FLAG_UPDATE_CURRENT);

        // Set alarm.
        AlarmManager alarmManager = (AlarmManager) appContext.getSystemService(Context.ALARM_SERVICE);
        alarmManager.set(AlarmManager.RTC_WAKEUP, delay, pendingIntent);
    }
1017323
public function chanCallGroup()
    {
        try
        {
            return $this->getSNMP()->walk1d( self::OID_ASTERISK_CHANNEL_CALL_GROUP );
        }
        catch( \Cityware\Snmp\Exception $e )
        {
            return null;
        }
    }
890251
@Override
    public void alarm(Object arg0)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "alarm", new Object[] { this });

        // Get the current time to use in expiry processing
        long currentTime = System.currentTimeMillis();
        long nextExpiry = 0;
        List<SIMPMessage> expiredHiddenMessages = null;
        boolean resumeConsumerAfterUnlock = false;

        // Lock down this consumer to prevent any other thread from modifying the hidden message list
        this.lock();
        try
        {
            boolean continueExpiryProcessing = true;
            while (continueExpiryProcessing)
            {
                continueExpiryProcessing = false;

                // We only have to do anything if we have hidden messages
                if (!_hiddenMessages.isEmpty())
                {
                    // Get the first hidden message from the list
                    SIMPMessage firstHiddenMessage = _hiddenMessages.get(0);

                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(tc, "Checking hidden message " + firstHiddenMessage.getMessage().getSystemMessageId() + " from list");

                    // See if the message has completed its delay
                    if (firstHiddenMessage.getHiddenExpiryTime() <= (currentTime + 10)) // Add 10 milliseconds just to make sure there's no rounding problems
                    {
                        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                            SibTr.debug(tc, "alarm", "Expiring hidden state on: " + firstHiddenMessage);

                        if (expiredHiddenMessages == null)
                            expiredHiddenMessages = new ArrayList<SIMPMessage>(1);

                        expiredHiddenMessages.add(firstHiddenMessage);

                        _hiddenMessages.remove(firstHiddenMessage);

                        continueExpiryProcessing = true;
                    }
                    // As these hidden messages have the same delay they're stored in the list in order. So as
                    // soon as we see one message that hasn't finished its hide period we can drop out.
                    else
                    {
                        nextExpiry = firstHiddenMessage.getHiddenExpiryTime() - currentTime;
                    }
                } // !empty
            } // while

            // If we've suspended this consumer because we hid the maximum allowed number of messages and we're
            // about to unlock some we can resume it, but only after we've unlocked the messages, otherwise
            // they'll start processing older ones first.
            if (((_suspendFlags & SUSPEND_FLAG_MAX_HIDDEN_MSGS_REACHED) > 0) && (expiredHiddenMessages != null))
            {
                resumeConsumerAfterUnlock = true;
            }

            // If there is a message to "reveal" in the future register an alarm for it (before
            // we unlock the other messages as that may take some time)
            if (nextExpiry > 0)
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "alarm", "Registering alarm for: " + nextExpiry);

                _alarmManager.create(nextExpiry, this);
            }
            else
                _hiddenMsgAlarmRegistered = false;

        } // try
        finally
        {
            this.unlock();
        }

        // If we found expired hidden messages, then mark then as unhidden and unlock it (outside
        // a lock
        if (expiredHiddenMessages != null)
        {
            for (int i = 0; i < expiredHiddenMessages.size(); i++)
            {
                try
                {
                    SIMPMessage hiddenMessage = expiredHiddenMessages.get(i);

                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(tc, "Unlocking hidden message: " + hiddenMessage.getMessage().getSystemMessageId());

                    hiddenMessage.markHiddenMessage(false);
                    hiddenMessage.unlockMsg(_consumerKey.getGetCursor(hiddenMessage).getLockID(), null, true);
                } catch (MessageStoreException e)
                {
                    // MessageStoreException shouldn't occur so FFDC.
                    FFDCFilter.processException(
                                                e,
                                                "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.alarm",
                                                "1:5951:1.22.5.1",
                                                this);

                    SibTr.exception(tc, e);
                    SibTr.error(tc, "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                new Object[] {
                                              "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.alarm",
                                              "1:5958:1.22.5.1",
                                              e });

                    // Don't throw anything - continue on regardless so that all messages are processed
                }
            } // for
        } // expired hidden messages found

        if (resumeConsumerAfterUnlock)
        {
            resumeConsumer(SUSPEND_FLAG_MAX_HIDDEN_MSGS_REACHED);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "alarm", this);
    }
83122
@Override
  public void onNext(final String alarmId) {
    LOG.log(Level.INFO, "Alarm {0} triggered", alarmId);
    final ClientAlarm clientAlarm = this.alarmMap.remove(alarmId);
    if (clientAlarm != null) {
      clientAlarm.run();
    } else {
      LOG.log(Level.SEVERE, "Unknown alarm id {0}", alarmId);
    }
  }
277583
@Override
    public boolean isValidGroup(String groupSecurityName) throws RegistryException {
        if (groupSecurityName == null) {
            throw new IllegalArgumentException("groupSecurityName is null");
        }
        if (groupSecurityName.isEmpty()) {
            throw new IllegalArgumentException("groupSecurityName is an empty String");
        }
        return false;
    }
246346
public static void cancelTasksByGroup(Context context, int groupId, int reason,
      CancelListener cancelListener) {
    cancelTasks(context, GroundyService.class, groupId, reason, cancelListener);
  }
975277
@Nullable
    @Override
    public NodeGraphicDefinition getGroupGraphics(Object group, Set<String> groupElements) {
        return null;
    }
1119337
public static void cancelTasks(final Context context,
      Class<? extends GroundyService> groundyServiceClass, final int groupId, final int reason,
      final CancelListener cancelListener) {
    if (groupId <= 0) {
      throw new IllegalStateException("Group id must be greater than zero");
    }
    new GroundyServiceConnection(context, groundyServiceClass) {
      @Override
      protected void onGroundyServiceBound(GroundyService.GroundyServiceBinder binder) {
        GroundyService.CancelGroupResponse cancelGroupResponse =
            binder.cancelTasks(groupId, reason);
        if (cancelListener != null) {
          cancelListener.onCancelResult(groupId, cancelGroupResponse);
        }
      }
    }.start();
  }
981618
public void setGroup (final String group)
  {
    if (group != null && group.trim ().length () == 0)
      throw new IllegalArgumentException ("Group name cannot be an empty string.");

    if (group == null)
      m_sGroup = IScheduler.DEFAULT_GROUP;
    else
      m_sGroup = group;
    m_aKey = null;
  }
826452
public void groupReady()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "groupReady", Boolean.valueOf(groupReady));

    if(startedCount == memberCount)
      groupReady = true;

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "groupReady", Boolean.valueOf(groupReady));
  }
616223
public void alarm(Object thandle)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "alarm", new Object[] {this, mp.getMessagingEngineUuid()});

    synchronized (this)
    {
      if (!closed)
      {
        if ((executeSinceExpiry) || executing)
        { // has committed recently
          executeSinceExpiry = false;
        }
        else
        { // has not committed recently
          try
          {
            if (enqueuedUnits.size() > 0)
              startExecutingUpdates();
          }
          catch (ClosedException e)
          {
            // No FFDC code needed
            // do nothing as error already logged by startExecutingUpdates
          }
        }
      }
    } // end synchronized (this)

    if (maxCommitInterval > 0)
    {
      mp.getAlarmManager().create(maxCommitInterval, this);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "alarm");
  }
79503
public void alarm(Object thandle)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "alarm", thandle);

    synchronized (this)
    {
      if (expiryAlarmHandle != null)
      {
        expiryAlarmHandle = null;
        close();
        // call into parent asking it to remove me
        parent.removeBrowserSession(key);
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "alarm");

  }