/// <summary>Creates the namenode proxy with the passed protocol.</summary> /// <remarks> /// Creates the namenode proxy with the passed protocol. This will handle /// creation of either HA- or non-HA-enabled proxy objects, depending upon /// if the provided URI is a configured logical URI. /// </remarks> /// <param name="conf"> /// the configuration containing the required IPC /// properties, client failover configurations, etc. /// </param> /// <param name="nameNodeUri"> /// the URI pointing either to a specific NameNode /// or to a logical nameservice. /// </param> /// <param name="xface">the IPC interface which should be created</param> /// <param name="fallbackToSimpleAuth"> /// set to true or false during calls to indicate if /// a secure client falls back to simple auth /// </param> /// <returns> /// an object containing both the proxy and the associated /// delegation token service it corresponds to /// </returns> /// <exception cref="System.IO.IOException">if there is an error creating the proxy</exception> public static NameNodeProxies.ProxyAndInfo <T> CreateProxy <T>(Configuration conf, URI nameNodeUri, AtomicBoolean fallbackToSimpleAuth) { System.Type xface = typeof(T); AbstractNNFailoverProxyProvider <T> failoverProxyProvider = CreateFailoverProxyProvider (conf, nameNodeUri, xface, true, fallbackToSimpleAuth); if (failoverProxyProvider == null) { // Non-HA case return(CreateNonHAProxy(conf, NameNode.GetAddress(nameNodeUri), xface, UserGroupInformation .GetCurrentUser(), true, fallbackToSimpleAuth)); } else { // HA case DFSClient.Conf config = new DFSClient.Conf(conf); T proxy = (T)RetryProxy.Create(xface, failoverProxyProvider, RetryPolicies.FailoverOnNetworkException (RetryPolicies.TryOnceThenFail, config.maxFailoverAttempts, config.maxRetryAttempts , config.failoverSleepBaseMillis, config.failoverSleepMaxMillis)); Text dtService; if (failoverProxyProvider.UseLogicalURI()) { dtService = HAUtil.BuildTokenServiceForLogicalUri(nameNodeUri, HdfsConstants.HdfsUriScheme ); } else { dtService = SecurityUtil.BuildTokenService(NameNode.GetAddress(nameNodeUri)); } return(new NameNodeProxies.ProxyAndInfo <T>(proxy, dtService, NameNode.GetAddress( nameNodeUri))); } }
public virtual void SetupCluster() { conf = new Configuration(); conf.SetInt(DFSConfigKeys.DfsHaTaileditsPeriodKey, 1); HAUtil.SetAllowStandbyReads(conf, true); fsHelper = new FileSystemTestHelper(); string testRoot = fsHelper.GetTestRootDir(); testRootDir = new FilePath(testRoot).GetAbsoluteFile(); conf.Set(DFSConfigKeys.DfsEncryptionKeyProviderUri, JavaKeyStoreProvider.SchemeName + "://file" + new Path(testRootDir.ToString(), "test.jks").ToUri()); cluster = new MiniDFSCluster.Builder(conf).NnTopology(MiniDFSNNTopology.SimpleHATopology ()).NumDataNodes(1).Build(); cluster.WaitActive(); cluster.TransitionToActive(0); fs = (DistributedFileSystem)HATestUtil.ConfigureFailoverFs(cluster, conf); DFSTestUtil.CreateKey(TestKey, cluster, 0, conf); DFSTestUtil.CreateKey(TestKey, cluster, 1, conf); nn0 = cluster.GetNameNode(0); nn1 = cluster.GetNameNode(1); dfsAdmin0 = new HdfsAdmin(cluster.GetURI(0), conf); dfsAdmin1 = new HdfsAdmin(cluster.GetURI(1), conf); KeyProviderCryptoExtension nn0Provider = cluster.GetNameNode(0).GetNamesystem().GetProvider (); fs.GetClient().SetKeyProvider(nn0Provider); }
public virtual void TestIPFailoverProxyProviderLogicalUri() { // setup the config with the IP failover proxy provider class Configuration config = new HdfsConfiguration(conf); URI nnUri = cluster.GetURI(0); config.Set(DFSConfigKeys.DfsClientFailoverProxyProviderKeyPrefix + "." + nnUri.GetHost (), typeof(IPFailoverProxyProvider).FullName); NUnit.Framework.Assert.IsFalse("IPFailoverProxyProvider should not use logical URI." , HAUtil.UseLogicalUri(config, nnUri)); }
public virtual void TestHANameNodesWithFederation() { HdfsConfiguration conf = new HdfsConfiguration(); string Ns1Nn1Host = "ns1-nn1.example.com:8020"; string Ns1Nn2Host = "ns1-nn2.example.com:8020"; string Ns2Nn1Host = "ns2-nn1.example.com:8020"; string Ns2Nn2Host = "ns2-nn2.example.com:8020"; conf.Set(CommonConfigurationKeys.FsDefaultNameKey, "hdfs://ns1"); // Two nameservices, each with two NNs. conf.Set(DFSConfigKeys.DfsNameservices, "ns1,ns2"); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsHaNamenodesKeyPrefix, "ns1"), "ns1-nn1,ns1-nn2" ); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsHaNamenodesKeyPrefix, "ns2"), "ns2-nn1,ns2-nn2" ); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsNamenodeRpcAddressKey, "ns1", "ns1-nn1" ), Ns1Nn1Host); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsNamenodeRpcAddressKey, "ns1", "ns1-nn2" ), Ns1Nn2Host); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsNamenodeRpcAddressKey, "ns2", "ns2-nn1" ), Ns2Nn1Host); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsNamenodeRpcAddressKey, "ns2", "ns2-nn2" ), Ns2Nn2Host); IDictionary <string, IDictionary <string, IPEndPoint> > map = DFSUtil.GetHaNnRpcAddresses (conf); NUnit.Framework.Assert.IsTrue(HAUtil.IsHAEnabled(conf, "ns1")); NUnit.Framework.Assert.IsTrue(HAUtil.IsHAEnabled(conf, "ns2")); NUnit.Framework.Assert.IsFalse(HAUtil.IsHAEnabled(conf, "ns3")); NUnit.Framework.Assert.AreEqual(Ns1Nn1Host, map["ns1"]["ns1-nn1"].ToString()); NUnit.Framework.Assert.AreEqual(Ns1Nn2Host, map["ns1"]["ns1-nn2"].ToString()); NUnit.Framework.Assert.AreEqual(Ns2Nn1Host, map["ns2"]["ns2-nn1"].ToString()); NUnit.Framework.Assert.AreEqual(Ns2Nn2Host, map["ns2"]["ns2-nn2"].ToString()); NUnit.Framework.Assert.AreEqual(Ns1Nn1Host, DFSUtil.GetNamenodeServiceAddr(conf, "ns1", "ns1-nn1")); NUnit.Framework.Assert.AreEqual(Ns1Nn2Host, DFSUtil.GetNamenodeServiceAddr(conf, "ns1", "ns1-nn2")); NUnit.Framework.Assert.AreEqual(Ns2Nn1Host, DFSUtil.GetNamenodeServiceAddr(conf, "ns2", "ns2-nn1")); // No nameservice was given and we can't determine which service addr // to use as two nameservices could share a namenode ID. NUnit.Framework.Assert.AreEqual(null, DFSUtil.GetNamenodeServiceAddr(conf, null, "ns1-nn1")); // Ditto for nameservice IDs, if multiple are defined NUnit.Framework.Assert.AreEqual(null, DFSUtil.GetNamenodeNameServiceId(conf)); NUnit.Framework.Assert.AreEqual(null, DFSUtil.GetSecondaryNameServiceId(conf)); ICollection <URI> uris = DFSUtil.GetNameServiceUris(conf, DFSConfigKeys.DfsNamenodeRpcAddressKey ); NUnit.Framework.Assert.AreEqual(2, uris.Count); NUnit.Framework.Assert.IsTrue(uris.Contains(new URI("hdfs://ns1"))); NUnit.Framework.Assert.IsTrue(uris.Contains(new URI("hdfs://ns2"))); }
/// <summary> /// Generate a dummy namenode proxy instance that utilizes our hacked /// <see cref="Org.Apache.Hadoop.IO.Retry.LossyRetryInvocationHandler{T}"/> /// . Proxy instance generated using this /// method will proactively drop RPC responses. Currently this method only /// support HA setup. null will be returned if the given configuration is not /// for HA. /// </summary> /// <param name="config"> /// the configuration containing the required IPC /// properties, client failover configurations, etc. /// </param> /// <param name="nameNodeUri"> /// the URI pointing either to a specific NameNode /// or to a logical nameservice. /// </param> /// <param name="xface">the IPC interface which should be created</param> /// <param name="numResponseToDrop">The number of responses to drop for each RPC call /// </param> /// <param name="fallbackToSimpleAuth"> /// set to true or false during calls to indicate if /// a secure client falls back to simple auth /// </param> /// <returns> /// an object containing both the proxy and the associated /// delegation token service it corresponds to. Will return null of the /// given configuration does not support HA. /// </returns> /// <exception cref="System.IO.IOException">if there is an error creating the proxy</exception> public static NameNodeProxies.ProxyAndInfo <T> CreateProxyWithLossyRetryHandler <T> (Configuration config, URI nameNodeUri, int numResponseToDrop, AtomicBoolean fallbackToSimpleAuth ) { System.Type xface = typeof(T); Preconditions.CheckArgument(numResponseToDrop > 0); AbstractNNFailoverProxyProvider <T> failoverProxyProvider = CreateFailoverProxyProvider (config, nameNodeUri, xface, true, fallbackToSimpleAuth); if (failoverProxyProvider != null) { // HA case int delay = config.GetInt(DFSConfigKeys.DfsClientFailoverSleeptimeBaseKey, DFSConfigKeys .DfsClientFailoverSleeptimeBaseDefault); int maxCap = config.GetInt(DFSConfigKeys.DfsClientFailoverSleeptimeMaxKey, DFSConfigKeys .DfsClientFailoverSleeptimeMaxDefault); int maxFailoverAttempts = config.GetInt(DFSConfigKeys.DfsClientFailoverMaxAttemptsKey , DFSConfigKeys.DfsClientFailoverMaxAttemptsDefault); int maxRetryAttempts = config.GetInt(DFSConfigKeys.DfsClientRetryMaxAttemptsKey, DFSConfigKeys.DfsClientRetryMaxAttemptsDefault); InvocationHandler dummyHandler = new LossyRetryInvocationHandler <T>(numResponseToDrop , failoverProxyProvider, RetryPolicies.FailoverOnNetworkException(RetryPolicies. TryOnceThenFail, maxFailoverAttempts, Math.Max(numResponseToDrop + 1, maxRetryAttempts ), delay, maxCap)); T proxy = (T)Proxy.NewProxyInstance(failoverProxyProvider.GetInterface().GetClassLoader (), new Type[] { xface }, dummyHandler); Text dtService; if (failoverProxyProvider.UseLogicalURI()) { dtService = HAUtil.BuildTokenServiceForLogicalUri(nameNodeUri, HdfsConstants.HdfsUriScheme ); } else { dtService = SecurityUtil.BuildTokenService(NameNode.GetAddress(nameNodeUri)); } return(new NameNodeProxies.ProxyAndInfo <T>(proxy, dtService, NameNode.GetAddress( nameNodeUri))); } else { Log.Warn("Currently creating proxy using " + "LossyRetryInvocationHandler requires NN HA setup" ); return(null); } }
public virtual void TestMultipleNamenodes() { HdfsConfiguration conf = new HdfsConfiguration(); conf.Set(DFSConfigKeys.DfsNameservices, "nn1,nn2"); // Test - configured list of namenodes are returned string Nn1Address = "localhost:9000"; string Nn2Address = "localhost:9001"; string Nn3Address = "localhost:9002"; conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsNamenodeRpcAddressKey, "nn1"), Nn1Address ); conf.Set(DFSUtil.AddKeySuffixes(DFSConfigKeys.DfsNamenodeRpcAddressKey, "nn2"), Nn2Address ); IDictionary <string, IDictionary <string, IPEndPoint> > nnMap = DFSUtil.GetNNServiceRpcAddresses (conf); NUnit.Framework.Assert.AreEqual(2, nnMap.Count); IDictionary <string, IPEndPoint> nn1Map = nnMap["nn1"]; NUnit.Framework.Assert.AreEqual(1, nn1Map.Count); IPEndPoint addr = nn1Map[null]; NUnit.Framework.Assert.AreEqual("localhost", addr.GetHostName()); NUnit.Framework.Assert.AreEqual(9000, addr.Port); IDictionary <string, IPEndPoint> nn2Map = nnMap["nn2"]; NUnit.Framework.Assert.AreEqual(1, nn2Map.Count); addr = nn2Map[null]; NUnit.Framework.Assert.AreEqual("localhost", addr.GetHostName()); NUnit.Framework.Assert.AreEqual(9001, addr.Port); // Test - can look up nameservice ID from service address CheckNameServiceId(conf, Nn1Address, "nn1"); CheckNameServiceId(conf, Nn2Address, "nn2"); CheckNameServiceId(conf, Nn3Address, null); // HA is not enabled in a purely federated config NUnit.Framework.Assert.IsFalse(HAUtil.IsHAEnabled(conf, "nn1")); NUnit.Framework.Assert.IsFalse(HAUtil.IsHAEnabled(conf, "nn2")); }
public virtual void TestWrappedFailoverProxyProvider() { // setup the config with the dummy provider class Configuration config = new HdfsConfiguration(conf); string logicalName = HATestUtil.GetLogicalHostname(cluster); HATestUtil.SetFailoverConfigurations(cluster, config, logicalName); config.Set(DFSConfigKeys.DfsClientFailoverProxyProviderKeyPrefix + "." + logicalName , typeof(TestDFSClientFailover.DummyLegacyFailoverProxyProvider).FullName); Path p = new Path("hdfs://" + logicalName + "/"); // not to use IP address for token service SecurityUtil.SetTokenServiceUseIp(false); // Logical URI should be used. NUnit.Framework.Assert.IsTrue("Legacy proxy providers should use logical URI.", HAUtil .UseLogicalUri(config, p.ToUri())); }