<staplerFork>true</staplerFork>
<stapler.version>1.250</stapler.version>

/**
    * This method serves static resources in the plugin under <tt>hudson/plugin/SHORTNAME</tt>.
**/
public void doDynamic(StaplerRequest req, StaplerResponse rsp) throws IOException, ServletException {
    String path = req.getRestOfPath();

    String pathUC = path.toUpperCase(Locale.ENGLISH);
    if (path.isEmpty() || path.contains("..") || path.startsWith(".") || path.contains("%") || pathUC.contains("META-INF") || pathUC.contains("WEB-INF")) {
        LOGGER.warning("rejecting possibly malicious " + req.getRequestURIWithQueryString());
        rsp.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return;
    }

    // Stapler routes requests like the "/static/.../foo/bar/zot" to be treated like "/foo/bar/zot"
    // and this is used to serve long expiration header, by using Jenkins.VERSION_HASH as "..."
    // to create unique URLs. Recognize that and set a long expiration header.
    String requestPath = req.getRequestURI().substring(req.getContextPath().length());
    boolean staticLink = requestPath.startsWith("/static/");

    long expires = staticLink ? TimeUnit2.DAYS.toMillis(365) : -1;

    // use serveLocalizedFile to support automatic locale selection
    rsp.serveLocalizedFile(req, new URL(wrapper.baseResourceURL, '.' + path), expires);
}

public void serveLocalizedFile(StaplerRequest request, URL res, long expiration) throws ServletException, IOException {
    if(!stapler.serveStaticResource(request, this, stapler.selectResourceByLocale(res,request.getLocale()), expiration))
        sendError(SC_NOT_FOUND);
}

@Override
public Locale getLocale()
{
    ...

    if (size > 0)
    {
        String language = (String)acceptLanguage.get(0);
        language = HttpFields.valueParameters(language,null);
        String country = "";
        int dash = language.indexOf('-');
        if (dash > -1)
        {
            country = language.substring(dash + 1).trim();
            language = language.substring(0,dash).trim();
        }
        return new Locale(language,country);
    }

    return Locale.getDefault();
}

OpenConnection selectResourceByLocale(URL url, Locale locale) throws IOException {
    // hopefully HotSpot would be able to inline all the virtual calls in here
    return urlLocaleSelector.open(url.toString(),locale,url);
}

private final LocaleDrivenResourceSelector urlLocaleSelector = new LocaleDrivenResourceSelector() {
    @Override
    URL map(String url) throws IOException {
        return new URL(url);
    }
};

private abstract class LocaleDrivenResourceSelector {
    /**
        * The 'path' is divided into the base part and the extension, and the locale-specific
        * suffix is inserted to the base portion. {@link #map(String)} is used to convert
        * the combined path into {@link URL}, until we find one that works.
        *
        * <p>
        * The syntax of the locale specific resource is the same as property file localization.
        * So Japanese resource for <tt>foo.html</tt> would be named <tt>foo_ja.html</tt>.
        *
        * @param path
        *      path/URL-like string that represents the path of the base resource,
        *      say "foo/bar/index.html" or "file:///a/b/c/d/efg.png"
        * @param locale
        *      The preferred locale
        * @param fallback
        *      The {@link URL} representation of the {@code path} parameter
        *      Used as a fallback.
        */
    OpenConnection open(String path, Locale locale, URL fallback) throws IOException {
        String s = path;
        int idx = s.lastIndexOf('.');
        if(idx<0)   // no file extension, so no locale switch available
            return openURL(fallback);
        String base = s.substring(0,idx);
        String ext = s.substring(idx);
        if(ext.indexOf('/')>=0) // the '.' we found was not an extension separator
            return openURL(fallback);

        OpenConnection con;

        // try locale specific resources first.
        con = openURL(map(base + '_' + locale.getLanguage() + '_' + locale.getCountry() + '_' + locale.getVariant() + ext));
        if(con!=null)   return con;
        con = openURL(map(base+'_'+ locale.getLanguage()+'_'+ locale.getCountry()+ext));
        if(con!=null)   return con;
        con = openURL(map(base+'_'+ locale.getLanguage()+ext));
        if(con!=null)   return con;
        // default
        return openURL(fallback);
    }

    /**
        * Maps the 'path' into {@link URL}.
        */
    abstract URL map(String path) throws IOException;
}