Returns a List of GitlabRunners.

@param scope Can be null. Defines type of Runner to retrieve.
@return List of GitLabRunners
@throws IOException on Gitlab API call error
548628
public List<GitlabRunner> getRunners(GitlabRunner.RunnerScope scope) throws IOException {
        return getRunnersWithPagination(scope, null);
    }
1152810
public List<GitlabProject> getProjectsViaSudoWithPagination(GitlabUser user, Pagination pagination) throws IOException {
        StringBuilder tailUrl = new StringBuilder(GitlabProject.URL);

        Query query = new Query()
                .appendIf(PARAM_SUDO, user.getId());

        if (pagination != null) {
            query.mergeWith(pagination.asQuery());
        }

        tailUrl.append(query.toString());
        return Arrays.asList(retrieve().method(GET).to(tailUrl.toString(), GitlabProject[].class));
    }
106702
@RequestMapping(value = "/scope", method = GET, produces = APPLICATION_JSON_VALUE)
	public List<Scope> allScopes() {
		return this.scopeService.getAllScopes();
	}
746451
public List<List<String>> getAllScopes() {
    this.checkInitialized();
    final ImmutableList.Builder<List<String>> builder = ImmutableList.<List<String>>builder();
    final Consumer<Integer> _function = (Integer it) -> {
      List<String> _get = this.scopes.get(it);
      StringConcatenation _builder = new StringConcatenation();
      _builder.append("No scopes are available for index: ");
      _builder.append(it);
      builder.add(Preconditions.<List<String>>checkNotNull(_get, _builder));
    };
    this.scopes.keySet().forEach(_function);
    return builder.build();
  }
639122
public function getScopes()
    {
        $scopes = array();
        $repositories = $this->getEntityRepositories($this->_scope_identifier);

        foreach ($repositories as $repository) {
            $scopes[] = array('repository' => $repository,'type' => $this->_scope_type);
        }

        return $scopes;
    }
939152
public String doGetRunners()
    {
		if (!isServerReady())
		{
			addActionError(ConfluenceGreenPepper.SERVER_NOCONFIGURATION);
			return SUCCESS;
		}
		
		try
        {
        	envTypes = getService().getAllEnvironmentTypes();
            runners = getService().getAllRunners();
            if(!StringUtil.isEmpty(selectedRunnerName))
            {
                for(Runner runner : runners)
                {
                    if(runner.getName().equals(selectedRunnerName))
                    {
                        selectedRunner = runner;
                        return SUCCESS;
                    }
                }
            }

            editPropertiesMode = false;
            editClasspathsMode = false;
            selectedRunnerName = NONE_SELECTED;
        }
        catch (GreenPepperServerException e)
        {
            addActionError(e.getId());
        }
        
        return SUCCESS;
    }
283495
public GitlabRunner getRunnerDetail(int id) throws IOException {
        String tailUrl = String.format("%s/%d", GitlabRunner.URL, id);
        return retrieve().to(tailUrl, GitlabRunner.class);
    }
257993
public List<GitlabSSHKey> getSSHKeys(Integer targetUserId) throws IOException {
        String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + GitlabSSHKey.KEYS_URL;
        return Arrays.asList(retrieve().to(tailUrl, GitlabSSHKey[].class));
    }
1248357
public List<GitlabProjectMember> getNamespaceMembers(Integer namespaceId) throws IOException {
        String tailUrl = GitlabGroup.URL + "/" + namespaceId + GitlabProjectMember.URL;
        return Arrays.asList(retrieve().to(tailUrl, GitlabProjectMember[].class));
    }
123345
public Observable<Page<RoleAssignmentInner>> listForScopeAsync(final String scope) {
        return listForScopeWithServiceResponseAsync(scope)
            .map(new Func1<ServiceResponse<Page<RoleAssignmentInner>>, Page<RoleAssignmentInner>>() {
                @Override
                public Page<RoleAssignmentInner> call(ServiceResponse<Page<RoleAssignmentInner>> response) {
                    return response.body();
                }
            });
    }
1328735
public List<GitlabBuildVariable> getBuildVariables(Integer projectId)
            throws IOException {
        String tailUrl = GitlabProject.URL + "/" + projectId + GitlabBuildVariable.URL;
        GitlabBuildVariable[] variables = retrieve().to(tailUrl, GitlabBuildVariable[].class);
        return Arrays.asList(variables);
    }
1080650
public static Collection<IAction> getRegisteredActions(ActionScope scope) {
        Map<String, IAction> actions = new HashMap<>();
        
        if (scope == ActionScope.BOTH || scope == ActionScope.GLOBAL) {
            actions.putAll(getRegistry(true).map);
        }
        
        if (scope == ActionScope.BOTH || scope == ActionScope.LOCAL) {
            actions.putAll(getRegistry(false).map);
        }
        
        return actions.values();
    }
869027
public Observable<Page<DenyAssignmentInner>> listForScopeAsync(final String scope) {
        return listForScopeWithServiceResponseAsync(scope)
            .map(new Func1<ServiceResponse<Page<DenyAssignmentInner>>, Page<DenyAssignmentInner>>() {
                @Override
                public Page<DenyAssignmentInner> call(ServiceResponse<Page<DenyAssignmentInner>> response) {
                    return response.body();
                }
            });
    }
954599
public List<GitlabAward> getAllAwards(GitlabIssue issue) {
        String tailUrl = GitlabProject.URL + "/" + issue.getProjectId() + GitlabIssue.URL + "/" + issue.getId()
                + GitlabAward.URL + PARAM_MAX_ITEMS_PER_PAGE;

        return retrieve().getAll(tailUrl, GitlabAward[].class);
    }
369811
private Set<Scope> getScopeList(ObjectId collectorId) {
        Set<Scope> projects = new HashSet<>();
        if(featureSettings.isCollectorItemOnlyUpdate()){
            for(FeatureBoard featureBoard: enabledFeatureBoards(collectorId)){
                Scope scope = projectRepository.findByCollectorIdAndPId(collectorId, featureBoard.getProjectId());
                if(scope != null){
                    projects.add(scope);
                }
            }
        }else {
            projects = new HashSet<>(projectRepository.findByCollectorId(collectorId));
        }
        return projects;
    }
72852
protected List<Class< ? extends ScopedAssociation>> getAvailableScopedAssociationClasses() {
    ArrayList<Class< ? extends ScopedAssociation>> scopeTypes = new ArrayList<Class< ? extends ScopedAssociation>>();
    scopeTypes.add(ConversationScopedAssociation.class);
    scopeTypes.add(RequestScopedAssociation.class);
    return scopeTypes;
  }
555177
public static List<ScopeListExtension> findAll(Collection<? extends Extension> extensions)
    {
        List<ScopeListExtension> result = new ArrayList<ScopeListExtension>();
        for (Extension extension : extensions)
        {
            if (SCOPE_LIST_EXTENSION_ID == extension.getId())
                result.add((ScopeListExtension)extension);
        }
        return result;
    }