Examples with ExtensionComponent hudson.ExtensionComponent used on opensource projects

Example 1 with ExtensionComponent

use of hudson.ExtensionComponent in project hudson-2.x by hudson.

the class CLIRegisterer method discover.

private List<ExtensionComponent<CLICommand>> discover(final Hudson hudson) {
    LOGGER.fine("Listing up @CLIMethod");
    List<ExtensionComponent<CLICommand>> r = new ArrayList<ExtensionComponent<CLICommand>>();
    try {
        for (final Method m : Util.filter(Index.list(CLIMethod.class, hudson.getPluginManager().uberClassLoader), Method.class)) {
            try {
                // command name
                final String name = m.getAnnotation(CLIMethod.class).name();
                final ResourceBundleHolder res = loadMessageBundle(m);
                // make sure we have the resource, to fail early
                res.format("CLI." + name + ".shortDescription");
                r.add(new ExtensionComponent<CLICommand>(new CloneableCLICommand() {

                    @Override
                    public String getName() {
                        return name;
                    }

                    public String getShortDescription() {
                        // format by using the right locale
                        return res.format("CLI." + name + ".shortDescription");
                    }

                    @Override
                    public int main(List<String> args, Locale locale, InputStream stdin, PrintStream stdout, PrintStream stderr) {
                        this.stdout = stdout;
                        this.stderr = stderr;
                        this.locale = locale;
                        this.channel = Channel.current();
                        registerOptionHandlers();
                        CmdLineParser parser = new CmdLineParser(null);
                        try {
                            SecurityContext sc = SecurityContextHolder.getContext();
                            Authentication old = sc.getAuthentication();
                            try {
                                //  build up the call sequence
                                Stack<Method> chains = new Stack<Method>();
                                Method method = m;
                                while (true) {
                                    chains.push(method);
                                    if (Modifier.isStatic(method.getModifiers()))
                                        // the chain is complete.
                                        break;
                                    // the method in question is an instance method, so we need to resolve the instance by using another resolver
                                    Class<?> type = method.getDeclaringClass();
                                    method = findResolver(type);
                                    if (method == null) {
                                        stderr.println("Unable to find the resolver method annotated with @CLIResolver for " + type);
                                        return 1;
                                    }
                                }
                                List<MethodBinder> binders = new ArrayList<MethodBinder>();
                                while (!chains.isEmpty()) binders.add(new MethodBinder(chains.pop(), parser));
                                // authentication
                                CliAuthenticator authenticator = Hudson.getInstance().getSecurityRealm().createCliAuthenticator(this);
                                new ClassParser().parse(authenticator, parser);
                                // fill up all the binders
                                parser.parseArgument(args);
                                Authentication auth = authenticator.authenticate();
                                if (auth == Hudson.ANONYMOUS)
                                    auth = loadStoredAuthentication();
                                // run the CLI with the right credential
                                sc.setAuthentication(auth);
                                hudson.checkPermission(Hudson.READ);
                                // resolve them
                                Object instance = null;
                                for (MethodBinder binder : binders) instance = binder.call(instance);
                                if (instance instanceof Integer)
                                    return (Integer) instance;
                                else
                                    return 0;
                            } catch (InvocationTargetException e) {
                                Throwable t = e.getTargetException();
                                if (t instanceof Exception)
                                    throw (Exception) t;
                                throw e;
                            } finally {
                                // restore
                                sc.setAuthentication(old);
                            }
                        } catch (CmdLineException e) {
                            stderr.println(e.getMessage());
                            printUsage(stderr, parser);
                            return 1;
                        } catch (Exception e) {
                            e.printStackTrace(stderr);
                            return 1;
                        }
                    }

                    protected int run() throws Exception {
                        throw new UnsupportedOperationException();
                    }
                }));
            } catch (ClassNotFoundException e) {
                LOGGER.log(SEVERE, "Failed to process @CLIMethod: " + m, e);
            }
        }
    } catch (IOException e) {
        LOGGER.log(SEVERE, "Failed to discvoer @CLIMethod", e);
    }
    return r;
}

Example 2 with ExtensionComponent

use of hudson.ExtensionComponent in project hudson-2.x by hudson.

the class TestExtensionLoader method find.

@Override
public <T> Collection<ExtensionComponent<T>> find(Class<T> type, Hudson hudson) {
    TestEnvironment env = TestEnvironment.get();
    List<ExtensionComponent<T>> result = new ArrayList<ExtensionComponent<T>>();
    ClassLoader cl = hudson.getPluginManager().uberClassLoader;
    for (IndexItem<TestExtension, Object> item : Index.load(TestExtension.class, Object.class, cl)) {
        try {
            AnnotatedElement e = item.element();
            Class<?> extType;
            if (e instanceof Class) {
                extType = (Class) e;
                if (!isActive(env, extType))
                    continue;
            } else if (e instanceof Field) {
                Field f = (Field) e;
                if (!f.getDeclaringClass().isInstance(env.testCase))
                    // not executing the enclosing test
                    continue;
                extType = f.getType();
            } else if (e instanceof Method) {
                Method m = (Method) e;
                if (!m.getDeclaringClass().isInstance(env.testCase))
                    // not executing the enclosing test
                    continue;
                extType = m.getReturnType();
            } else
                throw new AssertionError();
            String testName = item.annotation().value();
            if (testName.length() > 0 && !env.testCase.getName().equals(testName))
                // doesn't apply to this test
                continue;
            if (type.isAssignableFrom(extType)) {
                Object instance = item.instance();
                if (instance != null)
                    result.add(new ExtensionComponent<T>(type.cast(instance)));
            }
        } catch (InstantiationException e) {
            LOGGER.log(Level.WARNING, "Failed to load " + item.className(), e);
        }
    }
    return result;
}