Retrieve all currently paused trigger groups
@param jedis a thread-safe Redis connection
@return a set containing the names of all currently paused trigger groups
779395
public Set<String> getPausedTriggerGroups(T jedis){
        final Set<String> triggerGroupSetKeys = jedis.smembers(redisSchema.pausedTriggerGroupsSet());
        Set<String> names = new HashSet<>(triggerGroupSetKeys.size());
        for (String triggerGroupSetKey : triggerGroupSetKeys) {
            names.add(redisSchema.triggerGroup(triggerGroupSetKey));
        }
        return names;
    }
884943
public ICommonsSet <JobKey> getJobKeys (final GroupMatcher <JobKey> matcher) throws SchedulerException
  {
    validateState ();

    return m_aResources.getJobStore ().getJobKeys (_getOrDefault (matcher));
  }
106420
@Override
    public Trigger.TriggerState getTriggerState(final TriggerKey triggerKey) throws JobPersistenceException {
        return doWithLock(new LockCallback<Trigger.TriggerState>() {
            @Override
            public Trigger.TriggerState doWithLock(JedisCommands jedis) throws JobPersistenceException {
                return storage.getTriggerState(triggerKey, jedis);
            }
        }, "Could not retrieve trigger state.");
    }
410930
protected long getLastTriggersReleaseTime(T jedis){
        final String lastReleaseTime = jedis.get(redisSchema.lastTriggerReleaseTime());
        if(lastReleaseTime == null){
            return 0;
        }
        return Long.parseLong(lastReleaseTime);
    }
496123
def list_members(trigger_id, orphans = false)
      ret = http_get "triggers/groups/#{trigger_id}/members?includeOrphans=#{orphans}"
      ret.collect { |t| Trigger.new(t) }
    end
1291797
protected Set<AggregatedGroupMapping> getGroupsForEvent(PortalEvent event) {
        final Set<AggregatedGroupMapping> groupMappings =
                new LinkedHashSet<AggregatedGroupMapping>();

        if (event instanceof LoginEvent) {
            for (final String groupKey : ((LoginEvent) event).getGroups()) {
                final AggregatedGroupMapping groupMapping =
                        this.aggregatedGroupLookupDao.getGroupMapping(groupKey);
                if (groupMapping != null) {
                    groupMappings.add(groupMapping);
                }
            }
        } else {
            final String userName = event.getUserName();
            final IGroupMember groupMember =
                    this.compositeGroupService.getGroupMember(userName, IPerson.class);
            for (@SuppressWarnings("unchecked")
                    final Iterator<IEntityGroup> containingGroups =
                            this.compositeGroupService.findParentGroups(groupMember);
                    containingGroups.hasNext(); ) {
                final IEntityGroup group = containingGroups.next();
                final AggregatedGroupMapping groupMapping =
                        this.aggregatedGroupLookupDao.getGroupMapping(
                                group.getServiceName().toString(), group.getName());
                groupMappings.add(groupMapping);
            }
        }

        return groupMappings;
    }
1124741
public static List<TriggerDefinition> fromSchema(Row serializedTriggers)
    {
        List<TriggerDefinition> triggers = new ArrayList<>();
        String query = String.format("SELECT * FROM %s.%s", Keyspace.SYSTEM_KS, SystemKeyspace.SCHEMA_TRIGGERS_CF);
        for (UntypedResultSet.Row row : QueryProcessor.resultify(query, serializedTriggers))
        {
            String name = row.getString(TRIGGER_NAME);
            String classOption = row.getMap(TRIGGER_OPTIONS, UTF8Type.instance, UTF8Type.instance).get(CLASS);
            triggers.add(new TriggerDefinition(name, classOption));
        }
        return triggers;
    }
29321
@Override
    public OperableTrigger retrieveTrigger(final TriggerKey triggerKey) throws JobPersistenceException {
        return doWithLock(new LockCallback<OperableTrigger>() {
            @Override
            public OperableTrigger doWithLock(JedisCommands jedis) throws JobPersistenceException {
                return storage.retrieveTrigger(triggerKey, jedis);
            }
        }, "Could not retrieve trigger.");
    }
2528
def get_action_group_names(self):
        """"""
        return self.get_group_names(
            list(itertools.chain(
                *[self._get_array('add'),
                  self._get_array('remove'),
                  self._get_array('isolation-group')])))
1302404
public List<ScheduledFlowTrigger> getScheduledFlowTriggerJobs() {
    try {
      final Scheduler quartzScheduler = this.scheduler.getScheduler();
      final List<String> groupNames = quartzScheduler.getJobGroupNames();

      final List<ScheduledFlowTrigger> flowTriggerJobDetails = new ArrayList<>();
      for (final String groupName : groupNames) {
        final JobKey jobKey = new JobKey(FlowTriggerQuartzJob.JOB_NAME, groupName);
        ScheduledFlowTrigger scheduledFlowTrigger = null;
        try {
          final JobDetail job = quartzScheduler.getJobDetail(jobKey);
          final JobDataMap jobDataMap = job.getJobDataMap();

          final String flowId = jobDataMap.getString(FlowTriggerQuartzJob.FLOW_ID);
          final int projectId = jobDataMap.getInt(FlowTriggerQuartzJob.PROJECT_ID);
          final FlowTrigger flowTrigger = (FlowTrigger) jobDataMap
              .get(FlowTriggerQuartzJob.FLOW_TRIGGER);
          final String submitUser = jobDataMap.getString(FlowTriggerQuartzJob.SUBMIT_USER);
          final List<? extends Trigger> quartzTriggers = quartzScheduler.getTriggersOfJob(jobKey);
          final boolean isPaused = this.scheduler
              .isJobPaused(FlowTriggerQuartzJob.JOB_NAME, groupName);
          final Project project = projectManager.getProject(projectId);
          final Flow flow = project.getFlow(flowId);
          scheduledFlowTrigger = new ScheduledFlowTrigger(projectId,
              this.projectManager.getProject(projectId).getName(),
              flowId, flowTrigger, submitUser, quartzTriggers.isEmpty() ? null
              : quartzTriggers.get(0), isPaused, flow.isLocked());
        } catch (final Exception ex) {
          logger.error("Unable to get flow trigger by job key {}", jobKey, ex);
          scheduledFlowTrigger = null;
        }

        flowTriggerJobDetails.add(scheduledFlowTrigger);
      }
      return flowTriggerJobDetails;
    } catch (final Exception ex) {
      logger.error("Unable to get scheduled flow triggers", ex);
      return new ArrayList<>();
    }
  }
1333075
public List<String> getGroups(final DirContext dirContext) throws NamingException {
        LOGGER.debug("Retrieving all groups");
        final List<String> groupDns = new ArrayList<>();
        final SearchControls sc = new SearchControls();
        sc.setSearchScope(SearchControls.SUBTREE_SCOPE);
        final NamingEnumeration<SearchResult> ne = dirContext.search(BASE_DN, GROUPS_FILTER, sc);
        while (hasMoreEnum(ne)) {
            final SearchResult result = ne.next();
            groupDns.add(result.getNameInNamespace());
            LOGGER.debug("Found group: " + result.getNameInNamespace());
        }
        closeQuietly(ne);
        return groupDns;
    }
572753
public static List<AbstractWarningsParser> getParsers(final Collection<String> parserGroups) {
        List<AbstractWarningsParser> actualParsers = new ArrayList<AbstractWarningsParser>();
        for (String name : parserGroups) {
            for (AbstractWarningsParser warningsParser : getAllParsers()) {
                if (warningsParser.isInGroup(name)) {
                    actualParsers.add(warningsParser);
                }
            }
        }
        return actualParsers;
    }
590376
public void resumeJob(JobKey jobKey, T jedis) throws JobPersistenceException {
        for (OperableTrigger trigger : getTriggersForJob(jobKey, jedis)) {
            resumeTrigger(trigger.getKey(), jedis);
        }
    }
330217
public List<String> getCalendarNames(T jedis){
        final Set<String> calendarsSet = jedis.smembers(redisSchema.calendarsSet());
        List<String> calendars = new ArrayList<>(calendarsSet.size());
        for (String group : calendarsSet) {
            calendars.add(redisSchema.calendarName(group));
        }
        return calendars;
    }
964653
private AsyncConnections getConnections(Iterable<RedisURI> redisURIs) {

        AsyncConnections connections = new AsyncConnections();

        for (RedisURI redisURI : redisURIs) {
            if (redisURI.getHost() == null || connections.connectedNodes().contains(redisURI) || !isEventLoopActive()) {
                continue;
            }

            try {
                SocketAddress socketAddress = clientResources.socketAddressResolver().resolve(redisURI);

                ConnectionFuture<StatefulRedisConnection<String, String>> connectionFuture = nodeConnectionFactory
                        .connectToNodeAsync(CODEC, socketAddress);

                CompletableFuture<StatefulRedisConnection<String, String>> sync = new CompletableFuture<>();

                connectionFuture.whenComplete((connection, throwable) -> {

                    if (throwable != null) {

                        String message = String.format("Unable to connect to %s", socketAddress);
                        if (throwable instanceof RedisConnectionException) {
                            if (logger.isDebugEnabled()) {
                                logger.debug(throwable.getMessage(), throwable);
                            } else {
                                logger.warn(throwable.getMessage());
                            }
                        } else {
                            logger.warn(message, throwable);
                        }

                        sync.completeExceptionally(new RedisConnectionException(message, throwable));
                    } else {
                        connection.async().clientSetname("lettuce#ClusterTopologyRefresh");
                        sync.complete(connection);
                    }
                });

                connections.addConnection(redisURI, sync);
            } catch (RuntimeException e) {
                logger.warn(String.format("Unable to connect to %s", redisURI), e);
            }
        }

        return connections;
    }
819834
public List<OperableTrigger> getTriggersForJob(JobKey jobKey, T jedis) throws JobPersistenceException {
        final String jobTriggerSetKey = redisSchema.jobTriggersSetKey(jobKey);
        final Set<String> triggerHashKeys = jedis.smembers(jobTriggerSetKey);
        List<OperableTrigger> triggers = new ArrayList<>();
        for (String triggerHashKey : triggerHashKeys) {
            triggers.add(retrieveTrigger(redisSchema.triggerKey(triggerHashKey), jedis));
        }
        return  triggers;
    }
1169011
public java.util.List<Trigger> getTriggers() {
        if (triggers == null) {
            triggers = new com.amazonaws.internal.SdkInternalList<Trigger>();
        }
        return triggers;
    }