/// <summary>Create a service classpath</summary> /// <param name="user">username or ""</param> /// <param name="serviceClass">service name</param> /// <returns>a full path</returns> public static string ServiceclassPath(string user, string serviceClass) { string services = RegistryPathUtils.Join(HomePathForUser(user), RegistryConstants .PathUserServices); return(RegistryPathUtils.Join(services, serviceClass)); }
/// <summary> /// List children of a directory and retrieve their /// <see cref="Org.Apache.Hadoop.Registry.Client.Types.RegistryPathStatus"/> /// values. /// <p> /// This is not an atomic operation; A child may be deleted /// during the iteration through the child entries. If this happens, /// the <code>PathNotFoundException</code> is caught and that child /// entry ommitted. /// </summary> /// <param name="path">path</param> /// <returns> /// a possibly empty map of child entries listed by /// their short name. /// </returns> /// <exception cref="Org.Apache.Hadoop.FS.PathNotFoundException">path is not in the registry. /// </exception> /// <exception cref="Org.Apache.Hadoop.Registry.Client.Exceptions.InvalidPathnameException /// ">the path is invalid.</exception> /// <exception cref="System.IO.IOException">Any other IO Exception</exception> public static IDictionary <string, RegistryPathStatus> StatChildren(RegistryOperations registryOperations, string path) { IList <string> childNames = registryOperations.List(path); IDictionary <string, RegistryPathStatus> results = new Dictionary <string, RegistryPathStatus >(); foreach (string childName in childNames) { string child = RegistryPathUtils.Join(path, childName); try { RegistryPathStatus stat = registryOperations.Stat(child); results[childName] = stat; } catch (PathNotFoundException pnfe) { if (Log.IsDebugEnabled()) { Log.Debug("stat failed on {}: moved? {}", child, pnfe, pnfe); } } } // and continue return(results); }
public virtual void TestParentOf() { NUnit.Framework.Assert.AreEqual("/", RegistryPathUtils.ParentOf("/a")); NUnit.Framework.Assert.AreEqual("/", RegistryPathUtils.ParentOf("/a/")); NUnit.Framework.Assert.AreEqual("/a", RegistryPathUtils.ParentOf("/a/b")); NUnit.Framework.Assert.AreEqual("/a/b", RegistryPathUtils.ParentOf("/a/b/c")); }
/// <exception cref="System.IO.IOException"/> private static void AssertCreatedPathEquals(string expected, string @base, string path) { string fullPath = RegistryPathUtils.CreateFullPath(@base, path); NUnit.Framework.Assert.AreEqual("\"" + @base + "\" + \"" + path + "\" =\"" + fullPath + "\"", expected, fullPath); }
public virtual void TestLastPathEntry() { NUnit.Framework.Assert.AreEqual(string.Empty, RegistryPathUtils.LastPathEntry("/" )); NUnit.Framework.Assert.AreEqual(string.Empty, RegistryPathUtils.LastPathEntry("//" )); NUnit.Framework.Assert.AreEqual("c", RegistryPathUtils.LastPathEntry("/a/b/c")); NUnit.Framework.Assert.AreEqual("c", RegistryPathUtils.LastPathEntry("/a/b/c/")); }
/// <exception cref="Org.Apache.Hadoop.Registry.Client.Exceptions.InvalidPathnameException /// "/> private void AssertInvalidPath(string path) { try { RegistryPathUtils.ValidateElementsAsDNS(path); NUnit.Framework.Assert.Fail("path considered valid: " + path); } catch (InvalidPathnameException) { } }
public virtual void TestSplitting() { NUnit.Framework.Assert.AreEqual(1, RegistryPathUtils.Split("/a").Count); NUnit.Framework.Assert.AreEqual(0, RegistryPathUtils.Split("/").Count); NUnit.Framework.Assert.AreEqual(3, RegistryPathUtils.Split("/a/b/c").Count); NUnit.Framework.Assert.AreEqual(3, RegistryPathUtils.Split("/a/b/c/").Count); NUnit.Framework.Assert.AreEqual(3, RegistryPathUtils.Split("a/b/c").Count); NUnit.Framework.Assert.AreEqual(3, RegistryPathUtils.Split("/a/b//c").Count); NUnit.Framework.Assert.AreEqual(3, RegistryPathUtils.Split("//a/b/c/").Count); IList <string> split = RegistryPathUtils.Split("//a/b/c/"); NUnit.Framework.Assert.AreEqual("a", split[0]); NUnit.Framework.Assert.AreEqual("b", split[1]); NUnit.Framework.Assert.AreEqual("c", split[2]); }
/// <summary>Buld the user path -switches to the system path if the user is "".</summary> /// <remarks> /// Buld the user path -switches to the system path if the user is "". /// It also cross-converts the username to ascii via punycode /// </remarks> /// <param name="username">username or ""</param> /// <returns>the path to the user</returns> public static string HomePathForUser(string username) { Preconditions.CheckArgument(username != null, "null user"); // catch recursion if (username.StartsWith(RegistryConstants.PathUsers)) { return(username); } if (username.IsEmpty()) { return(RegistryConstants.PathSystemServices); } // convert username to registry name string convertedName = ConvertUsername(username); return(RegistryPathUtils.Join(RegistryConstants.PathUsers, RegistryPathUtils.EncodeForRegistry (convertedName))); }
/// <summary> /// Extract all service records under a list of stat operations...this /// skips entries that are too short or simply not matching /// </summary> /// <param name="operations">operation support for fetches</param> /// <param name="parentpath">path of the parent of all the entries</param> /// <param name="stats">Collection of stat results</param> /// <returns>a possibly empty map of fullpath:record.</returns> /// <exception cref="System.IO.IOException">for any IO Operation that wasn't ignored. /// </exception> public static IDictionary <string, ServiceRecord> ExtractServiceRecords(RegistryOperations operations, string parentpath, ICollection <RegistryPathStatus> stats) { IDictionary <string, ServiceRecord> results = new Dictionary <string, ServiceRecord >(stats.Count); foreach (RegistryPathStatus stat in stats) { if (stat.size > ServiceRecord.RecordType.Length) { // maybe has data string path = RegistryPathUtils.Join(parentpath, stat.path); try { ServiceRecord serviceRecord = operations.Resolve(path); results[path] = serviceRecord; } catch (EOFException) { if (Log.IsDebugEnabled()) { Log.Debug("data too short for {}", path); } } catch (InvalidRecordException) { if (Log.IsDebugEnabled()) { Log.Debug("Invalid record at {}", path); } } catch (NoRecordException) { if (Log.IsDebugEnabled()) { Log.Debug("No record at {}", path); } } } } return(results); }
public virtual void TestSplittingEmpty() { NUnit.Framework.Assert.AreEqual(0, RegistryPathUtils.Split(string.Empty).Count); NUnit.Framework.Assert.AreEqual(0, RegistryPathUtils.Split("/").Count); NUnit.Framework.Assert.AreEqual(0, RegistryPathUtils.Split("///").Count); }
/// <summary> /// Get the current user path formatted for the registry /// <p> /// In an insecure cluster, the environment variable /// <code>HADOOP_USER_NAME </code> is queried <i>first</i>. /// </summary> /// <remarks> /// Get the current user path formatted for the registry /// <p> /// In an insecure cluster, the environment variable /// <code>HADOOP_USER_NAME </code> is queried <i>first</i>. /// <p> /// This means that in a YARN container where the creator set this /// environment variable to propagate their identity, the defined /// user name is used in preference to the actual user. /// <p> /// In a secure cluster, the kerberos identity of the current user is used. /// </remarks> /// <returns>the encoded shortname of the current user</returns> /// <exception cref="Sharpen.RuntimeException"> /// if the current user identity cannot be determined /// from the OS/kerberos. /// </exception> public static string CurrentUser() { string shortUserName = CurrentUsernameUnencoded(); return(RegistryPathUtils.EncodeForRegistry(shortUserName)); }
/// <summary>Create the path to a service record for a component</summary> /// <param name="user">username or ""</param> /// <param name="serviceClass">service name</param> /// <param name="serviceName">service name unique for that user and service class</param> /// <param name="componentName">unique name/ID of the component</param> /// <returns>a full path</returns> public static string ComponentPath(string user, string serviceClass, string serviceName , string componentName) { return(RegistryPathUtils.Join(ComponentListPath(user, serviceClass, serviceName), componentName)); }
/// <exception cref="System.Exception"/> public virtual void TestParentOfRoot() { RegistryPathUtils.ParentOf("/"); }
/// <summary>Create a path for listing components under a service</summary> /// <param name="user">username or ""</param> /// <param name="serviceClass">service name</param> /// <param name="serviceName">service name unique for that user and service class</param> /// <returns>a full path</returns> public static string ComponentListPath(string user, string serviceClass, string serviceName ) { return(RegistryPathUtils.Join(ServicePath(user, serviceClass, serviceName), RegistryConstants .SubpathComponents)); }
/// <summary>Create a path to a service under a user and service class</summary> /// <param name="user">username or ""</param> /// <param name="serviceClass">service name</param> /// <param name="serviceName">service name unique for that user and service class</param> /// <returns>a full path</returns> public static string ServicePath(string user, string serviceClass, string serviceName ) { return(RegistryPathUtils.Join(ServiceclassPath(user, serviceClass), serviceName)); }
// Is this valid? assertInvalidPath("/50"); /// <exception cref="Org.Apache.Hadoop.Registry.Client.Exceptions.InvalidPathnameException /// "/> private void AssertValidPath(string path) { RegistryPathUtils.ValidateZKPath(path); }
public virtual void TestFormatIdempotent() { AssertConverted("xn--lzg", RegistryPathUtils.EncodeForRegistry(Euro)); }
protected internal virtual void AssertConverted(string expected, string @in) { string @out = RegistryPathUtils.EncodeForRegistry(@in); NUnit.Framework.Assert.AreEqual("Conversion of " + @in, expected, @out); }