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);
}
/// <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));
}
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));
}
/// <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("------------------------------------------------------");
}
/// <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);
}
/// <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());
}
/// <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");
}
