import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
private void initiateDownloadsAtWorkspace(
    final GoogleRobotCredentials credentials,
    final Run run, final List<StorageObjectId> objects,
    final FilePath localDir, final TaskListener listener,
    final String version, final String resolvedPrefix)
    throws IOException, InterruptedException {
  try {
    // Use remotable credential to access the storage service from the
    // remote machine.
    final GoogleRobotCredentials remoteCredentials =
        checkNotNull(credentials).forRemote(module.getRequirement());

    localDir.act(
        new Callable<Void, IOException>() {
          @Override
          public Void call() throws IOException {
            performDownloads(remoteCredentials, localDir, objects, listener,
                version, resolvedPrefix);
            return (Void) null;
          }

          @Override
          public void checkRoles(RoleChecker checker)
              throws SecurityException {
            // We know by definition that this is the correct role;
            // the callable exists only in this method context.
          }
        });
  } catch (GeneralSecurityException e) {
    throw new IOException(
        Messages.AbstractUpload_RemoteCredentialError(), e);
  }
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker roleChecker) throws SecurityException {
    // normally parameters will be executed on the master, but in the
    // future we may start evaluating on slaves as well, with a custom
    // classpath as in dynamic-parameter-plugin
    roleChecker.check((RoleSensitive) this, Role.UNKNOWN);
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker)
{
	// Implementation required by interface, but not using
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker arg0) throws SecurityException {}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker) throws SecurityException {
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker) throws SecurityException {
    // OK to execute it anywhere
    checker.check(this, Arrays.asList(Roles.MASTER, Roles.SLAVE));
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
/**
 * List model to choose the ZAP session to use. It's called on the remote machine (if present)
 * to load all session files in the build's workspace.
 * 
 * @return a {@link ListBoxModel}. It can be empty if the workspace doesn't contain any ZAP sessions.
 * @throws InterruptedException 
 * @throws IOException 
 */
public ListBoxModel doFillFilenameLoadSessionItems() throws IOException, InterruptedException {
	ListBoxModel items = new ListBoxModel();
	
	// No workspace before the first build, so workspace is null
	if(workspace != null) {
		Collection<String> sessionsInString = workspace.act(new FileCallable<Collection<String>>() {
			private static final long serialVersionUID = 1328740269013881941L;
	
			public Collection<String> invoke(File f, VirtualChannel channel) {
				
				// List all files with FILE_SESSION_EXTENSION on the machine where the workspace is located
				Collection<File> colFiles = FileUtils.listFiles(f,
						FileFilterUtils.suffixFileFilter(FILE_SESSION_EXTENSION),
						TrueFileFilter.INSTANCE);
				
				Collection<String> colString = new ArrayList<String>();
				
				// "Transform" File into String
				for (File file : colFiles) {
					colString.add(file.getAbsolutePath());
					// The following line is to remove the full path to the workspace,
					// keep just the relative path to the session
					//colString.add(file.getAbsolutePath().replace(workspace.getRemote() + File.separatorChar, ""));
				}
				return colString;
			}
	
			@Override
			public void checkRoles(RoleChecker checker) throws SecurityException {
				// Nothing to do
			}
		});
	
		items.add(""); // To not load a session, add a blank choice
		
		for (String s : sessionsInString) {
			items.add(s);
		}
	}
	
	return items;
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker) throws SecurityException {
	// Nothing to do
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker roleChecker) throws SecurityException {
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
public void checkRoles(RoleChecker arg0) throws SecurityException {
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker roleChecker) throws SecurityException {
    //ignore for now
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker roleChecker) throws SecurityException {
    //We don't require any roles to be checked?
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker) throws SecurityException {
    // TODO Auto-generated method stub

}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
public void checkRoles(RoleChecker checker) throws SecurityException {
	checker.check((RoleSensitive) this, Roles.SLAVE);
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker) throws SecurityException {
	checker.check((RoleSensitive) this, Roles.SLAVE);
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker checker) throws SecurityException {
	// TODO Auto-generated method stub
	
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker arg0) throws SecurityException {
}
 

import org.jenkinsci.remoting.RoleChecker; //导入依赖的package包/类
@Override
public void checkRoles(RoleChecker arg0) throws SecurityException
{
  // TODO Auto-generated method stub
  
}