Example #1
0
 public TestRMWebServicesNodeLabels()
     : base(new WebAppDescriptor.Builder("org.apache.hadoop.yarn.server.resourcemanager.webapp"
                                         ).ContextListenerClass(typeof(TestRMWebServicesNodeLabels.GuiceServletConfig)).FilterClass
                (typeof(GuiceFilter)).ContextPath("jersey-guice-filter").ServletPath("/").Build(
                ))
 {
     injector = Guice.CreateInjector(new _ServletModule_68(this));
 }
Example #2
0
 /// <summary>Create a mock injector for tests</summary>
 /// <?/>
 /// <param name="api">the interface class of the object to inject</param>
 /// <param name="impl">the implementation object to inject</param>
 /// <param name="modules">additional guice modules</param>
 /// <returns>an injector</returns>
 public static Injector CreateMockInjector <T>(T impl, params Module[] modules)
 {
     System.Type api = typeof(T);
     return(Guice.CreateInjector(new _AbstractModule_59(api, impl, modules)));
 }
Example #3
0
            public virtual WebApp Build(WebApp webapp)
            {
                if (webapp == null)
                {
                    webapp = new _WebApp_171();
                }
                // Defaults should be fine in usual cases
                webapp.SetName(name);
                webapp.SetWebServices(wsName);
                string basePath = "/" + name;

                webapp.SetRedirectPath(basePath);
                IList <string> pathList = new AList <string>();

                if (basePath.Equals("/"))
                {
                    webapp.AddServePathSpec("/*");
                    pathList.AddItem("/*");
                }
                else
                {
                    webapp.AddServePathSpec(basePath);
                    webapp.AddServePathSpec(basePath + "/*");
                    pathList.AddItem(basePath + "/*");
                }
                if (wsName != null && !wsName.Equals(basePath))
                {
                    if (wsName.Equals("/"))
                    {
                        webapp.AddServePathSpec("/*");
                        pathList.AddItem("/*");
                    }
                    else
                    {
                        webapp.AddServePathSpec("/" + wsName);
                        webapp.AddServePathSpec("/" + wsName + "/*");
                        pathList.AddItem("/" + wsName + "/*");
                    }
                }
                if (conf == null)
                {
                    conf = new Configuration();
                }
                try
                {
                    if (application != null)
                    {
                        webapp.SetHostClass(application.GetType());
                    }
                    else
                    {
                        string cls = InferHostClass();
                        Log.Debug("setting webapp host class to {}", cls);
                        webapp.SetHostClass(Sharpen.Runtime.GetType(cls));
                    }
                    if (devMode)
                    {
                        if (port > 0)
                        {
                            try
                            {
                                new Uri("http://localhost:" + port + "/__stop").GetContent();
                                Log.Info("stopping existing webapp instance");
                                Sharpen.Thread.Sleep(100);
                            }
                            catch (ConnectException e)
                            {
                                Log.Info("no existing webapp instance found: {}", e.ToString());
                            }
                            catch (Exception e)
                            {
                                // should not be fatal
                                Log.Warn("error stopping existing instance: {}", e.ToString());
                            }
                        }
                        else
                        {
                            Log.Error("dev mode does NOT work with ephemeral port!");
                            System.Environment.Exit(1);
                        }
                    }
                    string httpScheme;
                    if (this.httpPolicy == null)
                    {
                        httpScheme = WebAppUtils.GetHttpSchemePrefix(conf);
                    }
                    else
                    {
                        httpScheme = (httpPolicy == HttpConfig.Policy.HttpsOnly) ? WebAppUtils.HttpsPrefix
                                                         : WebAppUtils.HttpPrefix;
                    }
                    HttpServer2.Builder builder = new HttpServer2.Builder().SetName(name).AddEndpoint
                                                      (URI.Create(httpScheme + bindAddress + ":" + port)).SetConf(conf).SetFindPort(findPort
                                                                                                                                    ).SetACL(new AccessControlList(conf.Get(YarnConfiguration.YarnAdminAcl, YarnConfiguration
                                                                                                                                                                            .DefaultYarnAdminAcl))).SetPathSpec(Sharpen.Collections.ToArray(pathList, new string
                                                                                                                                                                                                                                            [0]));
                    bool hasSpnegoConf = spnegoPrincipalKey != null && conf.Get(spnegoPrincipalKey) !=
                                         null && spnegoKeytabKey != null && conf.Get(spnegoKeytabKey) != null;
                    if (hasSpnegoConf)
                    {
                        builder.SetUsernameConfKey(spnegoPrincipalKey).SetKeytabConfKey(spnegoKeytabKey).
                        SetSecurityEnabled(UserGroupInformation.IsSecurityEnabled());
                    }
                    if (httpScheme.Equals(WebAppUtils.HttpsPrefix))
                    {
                        WebAppUtils.LoadSslConfiguration(builder);
                    }
                    HttpServer2 server = builder.Build();
                    foreach (WebApps.Builder.ServletStruct @struct in servlets)
                    {
                        server.AddServlet(@struct.name, @struct.spec, @struct.clazz);
                    }
                    foreach (KeyValuePair <string, object> entry in attributes)
                    {
                        server.SetAttribute(entry.Key, entry.Value);
                    }
                    HttpServer2.DefineFilter(server.GetWebAppContext(), "guice", typeof(GuiceFilter).
                                             FullName, null, new string[] { "/*" });
                    webapp.SetConf(conf);
                    webapp.SetHttpServer(server);
                }
                catch (TypeLoadException e)
                {
                    throw new WebAppException("Error starting http server", e);
                }
                catch (IOException e)
                {
                    throw new WebAppException("Error starting http server", e);
                }
                Injector injector = Guice.CreateInjector(webapp, new _AbstractModule_280(this));

                Log.Info("Registered webapp guice modules");
                // save a guice filter instance for webapp stop (mostly for unit tests)
                webapp.SetGuiceFilter(injector.GetInstance <GuiceFilter>());
                if (devMode)
                {
                    injector.GetInstance <Dispatcher>().SetDevMode(devMode);
                    Log.Info("in dev mode!");
                }
                return(webapp);
            }