예제 #1
0
        public static Stream GetResourceAsStream(string name)
        {
            System.IO.Stream resourceStream = null;
            ClassLoader      classLoader    = CustomClassLoader;

            if (classLoader != null)
            {
                resourceStream = classLoader.GetResourceAsStream(name);
            }

            if (resourceStream == null)
            {
                // Try the current Thread context classloader
                //classLoader = Thread.CurrentThread.ContextClassLoader;
                resourceStream = classLoader.GetResourceAsStream(name);
            }
            return(resourceStream);
        }
예제 #2
0
        /// <summary>
        /// Convenience method that returns a resource as inputstream from the
        /// classpath.
        /// </summary>
        /// <remarks>
        /// Convenience method that returns a resource as inputstream from the
        /// classpath.
        /// <p>
        /// It first attempts to use the Thread's context classloader and if not
        /// set it uses the <code>ClassUtils</code> classloader.
        /// </remarks>
        /// <param name="name">resource to retrieve.</param>
        /// <returns>
        /// inputstream with the resource, NULL if the resource does not
        /// exist.
        /// </returns>
        internal static InputStream GetResource(string name)
        {
            Check.NotEmpty(name, "name");
            ClassLoader cl = Sharpen.Thread.CurrentThread().GetContextClassLoader();

            if (cl == null)
            {
                cl = typeof(Org.Apache.Hadoop.Lib.Server.Server).GetClassLoader();
            }
            return(cl.GetResourceAsStream(name));
        }
예제 #3
0
        public virtual void TestGetResource()
        {
            Uri         testJar            = MakeTestJar().ToURI().ToURL();
            ClassLoader currentClassLoader = GetType().GetClassLoader();
            ClassLoader appClassloader     = new ApplicationClassLoader(new Uri[] { testJar }, currentClassLoader
                                                                        , null);

            NUnit.Framework.Assert.IsNull("Resource should be null for current classloader",
                                          currentClassLoader.GetResourceAsStream("resource.txt"));
            InputStream @in = appClassloader.GetResourceAsStream("resource.txt");

            NUnit.Framework.Assert.IsNotNull("Resource should not be null for app classloader"
                                             , @in);
            Assert.Equal("hello", IOUtils.ToString(@in));
        }
예제 #4
0
        /// <summary>Loads and inializes the server configuration.</summary>
        /// <exception cref="ServerException">thrown if the configuration could not be loaded/initialized.
        ///     </exception>
        /// <exception cref="Org.Apache.Hadoop.Lib.Server.ServerException"/>
        protected internal virtual void InitConfig()
        {
            VerifyDir(configDir);
            FilePath      file = new FilePath(configDir);
            Configuration defaultConf;
            string        defaultConfig = name + "-default.xml";
            ClassLoader   classLoader   = Sharpen.Thread.CurrentThread().GetContextClassLoader();
            InputStream   inputStream   = classLoader.GetResourceAsStream(defaultConfig);

            if (inputStream == null)
            {
                log.Warn("Default configuration file not available in classpath [{}]", defaultConfig
                         );
                defaultConf = new Configuration(false);
            }
            else
            {
                try
                {
                    defaultConf = new Configuration(false);
                    ConfigurationUtils.Load(defaultConf, inputStream);
                }
                catch (Exception ex)
                {
                    throw new ServerException(ServerException.ERROR.S03, defaultConfig, ex.Message, ex
                                              );
                }
            }
            if (config == null)
            {
                Configuration siteConf;
                FilePath      siteFile = new FilePath(file, name + "-site.xml");
                if (!siteFile.Exists())
                {
                    log.Warn("Site configuration file [{}] not found in config directory", siteFile);
                    siteConf = new Configuration(false);
                }
                else
                {
                    if (!siteFile.IsFile())
                    {
                        throw new ServerException(ServerException.ERROR.S05, siteFile.GetAbsolutePath());
                    }
                    try
                    {
                        log.Debug("Loading site configuration from [{}]", siteFile);
                        inputStream = new FileInputStream(siteFile);
                        siteConf    = new Configuration(false);
                        ConfigurationUtils.Load(siteConf, inputStream);
                    }
                    catch (IOException ex)
                    {
                        throw new ServerException(ServerException.ERROR.S06, siteFile, ex.Message, ex);
                    }
                }
                config = new Configuration(false);
                ConfigurationUtils.Copy(siteConf, config);
            }
            ConfigurationUtils.InjectDefaults(defaultConf, config);
            foreach (string name in Runtime.GetProperties().StringPropertyNames())
            {
                string value = Runtime.GetProperty(name);
                if (name.StartsWith(GetPrefix() + "."))
                {
                    config.Set(name, value);
                    if (name.EndsWith(".password") || name.EndsWith(".secret"))
                    {
                        value = "*MASKED*";
                    }
                    log.Info("System property sets  {}: {}", name, value);
                }
            }
            log.Debug("Loaded Configuration:");
            log.Debug("------------------------------------------------------");
            foreach (KeyValuePair <string, string> entry in config)
            {
                string name_1 = entry.Key;
                string value  = config.Get(entry.Key);
                if (name_1.EndsWith(".password") || name_1.EndsWith(".secret"))
                {
                    value = "*MASKED*";
                }
                log.Debug("  {}: {}", entry.Key, value);
            }
            log.Debug("------------------------------------------------------");
        }
예제 #5
0
        /// <summary>
        /// Instantiate a bean.
        /// <para>
        /// The bean is created based on a name relative to a class-loader.
        /// This name should be a dot-separated name such as "a.b.c".
        /// </para>
        /// <para>
        /// In Beans 1.0 the given name can indicate either a serialized object
        /// or a class.  Other mechanisms may be added in the future.  In
        /// beans 1.0 we first try to treat the beanName as a serialized object
        /// name then as a class name.
        /// </para>
        /// <para>
        /// When using the beanName as a serialized object name we convert the
        /// given beanName to a resource pathname and add a trailing ".ser" suffix.
        /// We then try to load a serialized object from that resource.
        /// </para>
        /// <para>
        /// For example, given a beanName of "x.y", Beans.instantiate would first
        /// try to read a serialized object from the resource "x/y.ser" and if
        /// that failed it would try to load the class "x.y" and create an
        /// instance of that class.
        /// </para>
        /// <para>
        /// If the bean is a subtype of java.applet.Applet, then it is given
        /// some special initialization.  First, it is supplied with a default
        /// AppletStub and AppletContext.  Second, if it was instantiated from
        /// a classname the applet's "init" method is called.  (If the bean was
        /// deserialized this step is skipped.)
        /// </para>
        /// <para>
        /// Note that for beans which are applets, it is the caller's responsiblity
        /// to call "start" on the applet.  For correct behaviour, this should be done
        /// after the applet has been added into a visible AWT container.
        /// </para>
        /// <para>
        /// Note that applets created via beans.instantiate run in a slightly
        /// different environment than applets running inside browsers.  In
        /// particular, bean applets have no access to "parameters", so they may
        /// wish to provide property get/set methods to set parameter values.  We
        /// advise bean-applet developers to test their bean-applets against both
        /// the JDK appletviewer (for a reference browser environment) and the
        /// BDK BeanBox (for a reference bean container).
        ///
        /// </para>
        /// </summary>
        /// <returns> a JavaBean </returns>
        /// <param name="cls">         the class-loader from which we should create
        ///                        the bean.  If this is null, then the system
        ///                        class-loader is used. </param>
        /// <param name="beanName">    the name of the bean within the class-loader.
        ///                        For example "sun.beanbox.foobah" </param>
        /// <param name="beanContext"> The BeanContext in which to nest the new bean </param>
        /// <param name="initializer"> The AppletInitializer for the new bean
        /// </param>
        /// <exception cref="ClassNotFoundException"> if the class of a serialized
        ///              object could not be found. </exception>
        /// <exception cref="IOException"> if an I/O error occurs. </exception>

//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static Object instantiate(ClassLoader cls, String beanName, java.beans.beancontext.BeanContext beanContext, AppletInitializer initializer) throws java.io.IOException, ClassNotFoundException
        public static Object Instantiate(ClassLoader cls, String beanName, BeanContext beanContext, AppletInitializer initializer)
        {
            InputStream       ins;
            ObjectInputStream oins   = null;
            Object            result = null;
            bool        serialized   = false;
            IOException serex        = null;

            // If the given classloader is null, we check if an
            // system classloader is available and (if so)
            // use that instead.
            // Note that calls on the system class loader will
            // look in the bootstrap class loader first.
            if (cls == null)
            {
                try
                {
                    cls = ClassLoader.SystemClassLoader;
                }
                catch (SecurityException)
                {
                    // We're not allowed to access the system class loader.
                    // Drop through.
                }
            }

            // Try to find a serialized object with this name
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String serName = beanName.replace('.','/').concat(".ser");
            String serName = beanName.Replace('.', '/') + ".ser";

            if (cls == null)
            {
                ins = ClassLoader.GetSystemResourceAsStream(serName);
            }
            else
            {
                ins = cls.GetResourceAsStream(serName);
            }
            if (ins != null)
            {
                try
                {
                    if (cls == null)
                    {
                        oins = new ObjectInputStream(ins);
                    }
                    else
                    {
                        oins = new ObjectInputStreamWithLoader(ins, cls);
                    }
                    result     = oins.ReadObject();
                    serialized = true;
                    oins.Close();
                }
                catch (IOException ex)
                {
                    ins.Close();
                    // Drop through and try opening the class.  But remember
                    // the exception in case we can't find the class either.
                    serex = ex;
                }
                catch (ClassNotFoundException ex)
                {
                    ins.Close();
                    throw ex;
                }
            }

            if (result == null)
            {
                // No serialized object, try just instantiating the class
                Class cl;

                try
                {
                    cl = ClassFinder.findClass(beanName, cls);
                }
                catch (ClassNotFoundException ex)
                {
                    // There is no appropriate class.  If we earlier tried to
                    // deserialize an object and got an IO exception, throw that,
                    // otherwise rethrow the ClassNotFoundException.
                    if (serex != null)
                    {
                        throw serex;
                    }
                    throw ex;
                }

                if (!Modifier.isPublic(cl.Modifiers))
                {
                    throw new ClassNotFoundException("" + cl + " : no public access");
                }

                /*
                 * Try to instantiate the class.
                 */

                try
                {
                    result = cl.NewInstance();
                }
                catch (Exception ex)
                {
                    // We have to remap the exception to one in our signature.
                    // But we pass extra information in the detail message.
                    throw new ClassNotFoundException("" + cl + " : " + ex, ex);
                }
            }

            if (result != null)
            {
                // Ok, if the result is an applet initialize it.

                AppletStub stub = null;

                if (result is Applet)
                {
                    Applet applet      = (Applet)result;
                    bool   needDummies = initializer == null;

                    if (needDummies)
                    {
                        // Figure our the codebase and docbase URLs.  We do this
                        // by locating the URL for a known resource, and then
                        // massaging the URL.

                        // First find the "resource name" corresponding to the bean
                        // itself.  So a serialzied bean "a.b.c" would imply a
                        // resource name of "a/b/c.ser" and a classname of "x.y"
                        // would imply a resource name of "x/y.class".

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String resourceName;
                        String resourceName;

                        if (serialized)
                        {
                            // Serialized bean
                            resourceName = beanName.Replace('.', '/') + ".ser";
                        }
                        else
                        {
                            // Regular class
                            resourceName = beanName.Replace('.', '/') + ".class";
                        }

                        URL objectUrl = null;
                        URL codeBase  = null;
                        URL docBase   = null;

                        // Now get the URL correponding to the resource name.
                        if (cls == null)
                        {
                            objectUrl = ClassLoader.GetSystemResource(resourceName);
                        }
                        else
                        {
                            objectUrl = cls.GetResource(resourceName);
                        }

                        // If we found a URL, we try to locate the docbase by taking
                        // of the final path name component, and the code base by taking
                        // of the complete resourceName.
                        // So if we had a resourceName of "a/b/c.class" and we got an
                        // objectURL of "file://bert/classes/a/b/c.class" then we would
                        // want to set the codebase to "file://bert/classes/" and the
                        // docbase to "file://bert/classes/a/b/"

                        if (objectUrl != null)
                        {
                            String s = objectUrl.ToExternalForm();

                            if (s.EndsWith(resourceName))
                            {
                                int ix = s.Length() - resourceName.Length();
                                codeBase = new URL(s.Substring(0, ix));
                                docBase  = codeBase;

                                ix = s.LastIndexOf('/');

                                if (ix >= 0)
                                {
                                    docBase = new URL(s.Substring(0, ix + 1));
                                }
                            }
                        }

                        // Setup a default context and stub.
                        BeansAppletContext context = new BeansAppletContext(applet);

                        stub        = (AppletStub) new BeansAppletStub(applet, context, codeBase, docBase);
                        applet.Stub = stub;
                    }
                    else
                    {
                        initializer.Initialize(applet, beanContext);
                    }

                    // now, if there is a BeanContext, add the bean, if applicable.

                    if (beanContext != null)
                    {
                        UnsafeBeanContextAdd(beanContext, result);
                    }

                    // If it was deserialized then it was already init-ed.
                    // Otherwise we need to initialize it.

                    if (!serialized)
                    {
                        // We need to set a reasonable initial size, as many
                        // applets are unhappy if they are started without
                        // having been explicitly sized.
                        applet.SetSize(100, 100);
                        applet.Init();
                    }

                    if (needDummies)
                    {
                        ((BeansAppletStub)stub).Active_Renamed = true;
                    }
                    else
                    {
                        initializer.Activate(applet);
                    }
                }
                else if (beanContext != null)
                {
                    UnsafeBeanContextAdd(beanContext, result);
                }
            }

            return(result);
        }
예제 #6
0
        /// <exception cref="System.Exception"/>
        private void InitKDCServer()
        {
            string orgName     = conf.GetProperty(OrgName);
            string orgDomain   = conf.GetProperty(OrgDomain);
            string bindAddress = conf.GetProperty(KdcBindAddress);
            IDictionary <string, string> map = new Dictionary <string, string>();

            map["0"] = orgName.ToLower(Extensions.GetEnglishCulture());
            map["1"] = orgDomain.ToLower(Extensions.GetEnglishCulture());
            map["2"] = orgName.ToUpper(Extensions.GetEnglishCulture());
            map["3"] = orgDomain.ToUpper(Extensions.GetEnglishCulture());
            map["4"] = bindAddress;
            ClassLoader   cl            = Thread.CurrentThread().GetContextClassLoader();
            InputStream   is1           = cl.GetResourceAsStream("minikdc.ldiff");
            SchemaManager schemaManager = ds.GetSchemaManager();
            LdifReader    reader        = null;

            try
            {
                string content = StrSubstitutor.Replace(IOUtils.ToString(is1), map);
                reader = new LdifReader(new StringReader(content));
                foreach (LdifEntry ldifEntry in reader)
                {
                    ds.GetAdminSession().Add(new DefaultEntry(schemaManager, ldifEntry.GetEntry()));
                }
            }
            finally
            {
                IOUtils.CloseQuietly(reader);
                IOUtils.CloseQuietly(is1);
            }
            KerberosConfig kerberosConfig = new KerberosConfig();

            kerberosConfig.SetMaximumRenewableLifetime(long.Parse(conf.GetProperty(MaxRenewableLifetime
                                                                                   )));
            kerberosConfig.SetMaximumTicketLifetime(long.Parse(conf.GetProperty(MaxTicketLifetime
                                                                                )));
            kerberosConfig.SetSearchBaseDn(string.Format("dc=%s,dc=%s", orgName, orgDomain));
            kerberosConfig.SetPaEncTimestampRequired(false);
            //kdc = new KdcServer(kerberosConfig);
            kdc = new KdcServer();
            kdc.SetDirectoryService(ds);
            // transport
            string transport = conf.GetProperty(Transport);

            if (transport.Trim().Equals("TCP"))
            {
                kdc.AddTransports(new TcpTransport(bindAddress, port, 3, 50));
            }
            else
            {
                if (transport.Trim().Equals("UDP"))
                {
                    kdc.AddTransports(new UdpTransport(port));
                }
                else
                {
                    throw new ArgumentException("Invalid transport: " + transport);
                }
            }
            kdc.SetServiceName(conf.GetProperty(Instance));
            kdc.Start();
            StringBuilder  sb  = new StringBuilder();
            InputStream    is2 = cl.GetResourceAsStream("minikdc-krb5.conf");
            BufferedReader r   = null;

            try
            {
                r = new BufferedReader(new InputStreamReader(is2, Charsets.Utf8));
                string line = r.ReadLine();
                while (line != null)
                {
                    sb.Append(line).Append("{3}");
                    line = r.ReadLine();
                }
            }
            finally
            {
                IOUtils.CloseQuietly(r);
                IOUtils.CloseQuietly(is2);
            }
            krb5conf = new FilePath(workDir, "krb5.conf").GetAbsoluteFile();
            FileUtils.WriteStringToFile(krb5conf, MessageFormat.Format(sb.ToString(), GetRealm
                                                                           (), GetHost(), Extensions.ToString(GetPort()), Runtime.GetProperty("line.separator"
                                                                                                                                              )));
            Runtime.SetProperty(JavaSecurityKrb5Conf, krb5conf.GetAbsolutePath());
            Runtime.SetProperty(SunSecurityKrb5Debug, conf.GetProperty(Debug, "false"));
            // refresh the config
            Type classRef;

            if (Runtime.GetProperty("java.vendor").Contains("IBM"))
            {
                classRef = Runtime.GetType("com.ibm.security.krb5.internal.Config");
            }
            else
            {
                classRef = Runtime.GetType("sun.security.krb5.Config");
            }
            MethodInfo refreshMethod = classRef.GetMethod("refresh", new Type[0]);

            refreshMethod.Invoke(classRef, new object[0]);
            Log.Info("MiniKdc listening at port: {}", GetPort());
            Log.Info("MiniKdc setting JVM krb5.conf to: {}", krb5conf.GetAbsolutePath());
        }
예제 #7
0
        /// <exception cref="System.Exception"/>
        public virtual void Start()
        {
            ClassLoader cl = Thread.CurrentThread().GetContextClassLoader();

            Runtime.SetProperty(KMSConfiguration.KmsConfigDir, kmsConfDir);
            FilePath aclsFile = new FilePath(kmsConfDir, "kms-acls.xml");

            if (!aclsFile.Exists())
            {
                InputStream  @is = cl.GetResourceAsStream("mini-kms-acls-default.xml");
                OutputStream os  = new FileOutputStream(aclsFile);
                IOUtils.Copy(@is, os);
                @is.Close();
                os.Close();
            }
            FilePath coreFile = new FilePath(kmsConfDir, "core-site.xml");

            if (!coreFile.Exists())
            {
                Configuration core   = new Configuration();
                TextWriter    writer = new FileWriter(coreFile);
                core.WriteXml(writer);
                writer.Close();
            }
            FilePath kmsFile = new FilePath(kmsConfDir, "kms-site.xml");

            if (!kmsFile.Exists())
            {
                Configuration kms = new Configuration(false);
                kms.Set(KMSConfiguration.KeyProviderUri, "jceks://file@" + new Path(kmsConfDir, "kms.keystore"
                                                                                    ).ToUri());
                kms.Set("hadoop.kms.authentication.type", "simple");
                TextWriter writer = new FileWriter(kmsFile);
                kms.WriteXml(writer);
                writer.Close();
            }
            Runtime.SetProperty("log4j.configuration", log4jConfFile);
            jetty = CreateJettyServer(keyStore, keyStorePassword, inPort);
            // we need to do a special handling for MiniKMS to work when in a dir and
            // when in a JAR in the classpath thanks to Jetty way of handling of webapps
            // when they are in the a DIR, WAR or JAR.
            Uri webXmlUrl = cl.GetResource("kms-webapp/WEB-INF/web.xml");

            if (webXmlUrl == null)
            {
                throw new RuntimeException("Could not find kms-webapp/ dir in test classpath");
            }
            bool   webXmlInJar = webXmlUrl.AbsolutePath.Contains(".jar!/");
            string webappPath;

            if (webXmlInJar)
            {
                FilePath webInf = new FilePath("target/" + UUID.RandomUUID().ToString() + "/kms-webapp/WEB-INF"
                                               );
                webInf.Mkdirs();
                new FilePath(webInf, "web.xml").Delete();
                InputStream  @is = cl.GetResourceAsStream("kms-webapp/WEB-INF/web.xml");
                OutputStream os  = new FileOutputStream(new FilePath(webInf, "web.xml"));
                IOUtils.Copy(@is, os);
                @is.Close();
                os.Close();
                webappPath = webInf.GetParentFile().GetAbsolutePath();
            }
            else
            {
                webappPath = cl.GetResource("kms-webapp").AbsolutePath;
            }
            WebAppContext context = new WebAppContext(webappPath, "/kms");

            if (webXmlInJar)
            {
                context.SetClassLoader(cl);
            }
            jetty.AddHandler(context);
            jetty.Start();
            kmsURL = new Uri(GetJettyURL(jetty), "kms");
        }