public virtual void TestReplQueuesActiveAfterStartupSafemode() { Configuration conf = new Configuration(); FSEditLog fsEditLog = Org.Mockito.Mockito.Mock <FSEditLog>(); FSImage fsImage = Org.Mockito.Mockito.Mock <FSImage>(); Org.Mockito.Mockito.When(fsImage.GetEditLog()).ThenReturn(fsEditLog); FSNamesystem fsNamesystem = new FSNamesystem(conf, fsImage); FSNamesystem fsn = Org.Mockito.Mockito.Spy(fsNamesystem); //Make shouldPopulaeReplQueues return true HAContext haContext = Org.Mockito.Mockito.Mock <HAContext>(); HAState haState = Org.Mockito.Mockito.Mock <HAState>(); Org.Mockito.Mockito.When(haContext.GetState()).ThenReturn(haState); Org.Mockito.Mockito.When(haState.ShouldPopulateReplQueues()).ThenReturn(true); Whitebox.SetInternalState(fsn, "haContext", haContext); //Make NameNode.getNameNodeMetrics() not return null NameNode.InitMetrics(conf, HdfsServerConstants.NamenodeRole.Namenode); fsn.EnterSafeMode(false); NUnit.Framework.Assert.IsTrue("FSNamesystem didn't enter safemode", fsn.IsInSafeMode ()); NUnit.Framework.Assert.IsTrue("Replication queues were being populated during very first " + "safemode", !fsn.IsPopulatingReplQueues()); fsn.LeaveSafeMode(); NUnit.Framework.Assert.IsTrue("FSNamesystem didn't leave safemode", !fsn.IsInSafeMode ()); NUnit.Framework.Assert.IsTrue("Replication queues weren't being populated even after leaving " + "safemode", fsn.IsPopulatingReplQueues()); fsn.EnterSafeMode(false); NUnit.Framework.Assert.IsTrue("FSNamesystem didn't enter safemode", fsn.IsInSafeMode ()); NUnit.Framework.Assert.IsTrue("Replication queues weren't being populated after entering " + "safemode 2nd time", fsn.IsPopulatingReplQueues()); }
/// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException"/> public override void SetState(HAContext context, HAState s) { if (s == NameNode.StandbyState) { SetStateInternal(context, s); return; } base.SetState(context, s); }
/// <summary>Move from the existing state to a new state</summary> /// <param name="context">HA context</param> /// <param name="s">new state</param> /// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException">on failure to transition to new state. /// </exception> public virtual void SetState(HAContext context, Org.Apache.Hadoop.Hdfs.Server.Namenode.HA.HAState s) { if (this == s) { // Aleady in the new state return; } throw new ServiceFailedException("Transtion from state " + this + " to " + s + " is not allowed." ); }
/// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException"/> public override void ExitState(HAContext context) { try { context.StopActiveServices(); } catch (IOException e) { throw new ServiceFailedException("Failed to stop active services", e); } }
/// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException"/> public override void EnterState(HAContext context) { try { context.StartStandbyServices(); } catch (IOException e) { throw new ServiceFailedException("Failed to start standby services", e); } }
/// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException"/> public override void EnterState(HAContext context) { // HAState try { context.StartActiveServices(); } catch (IOException e) { throw new ServiceFailedException("Failed to start backup services", e); } }
/// <exception cref="Org.Apache.Hadoop.Ipc.StandbyException"/> public override void CheckOperation(HAContext context, NameNode.OperationCategory op) { if (op == NameNode.OperationCategory.Unchecked || (op == NameNode.OperationCategory .Read && context.AllowStaleReads())) { return; } string msg = "Operation category " + op + " is not supported in state " + context .GetState(); throw new StandbyException(msg); }
/// <summary>Internal method to transition the state of a given namenode to a new state. /// </summary> /// <param name="nn">Namenode</param> /// <param name="s">new state</param> /// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException">on failure to transition to new state. /// </exception> protected internal void SetStateInternal(HAContext context, Org.Apache.Hadoop.Hdfs.Server.Namenode.HA.HAState s) { PrepareToExitState(context); s.PrepareToEnterState(context); context.WriteLock(); try { ExitState(context); context.SetState(s); s.EnterState(context); s.UpdateLastHATransitionTime(); } finally { context.WriteUnlock(); } }
/// <summary> /// Method to be overridden by subclasses to perform steps necessary for /// entering a state. /// </summary> /// <param name="context">HA context</param> /// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException">on failure to enter the state. /// </exception> public abstract void EnterState(HAContext context);
/// <summary>Method to be overridden by subclasses to prepare to enter a state.</summary> /// <remarks> /// Method to be overridden by subclasses to prepare to enter a state. /// This method is called <em>without</em> the context being locked, /// and after /// <see cref="PrepareToExitState(HAContext)"/> /// has been called /// for the previous state, but before /// <see cref="ExitState(HAContext)"/> /// has been called for the previous state. /// </remarks> /// <param name="context">HA context</param> /// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException">on precondition failure /// </exception> public virtual void PrepareToEnterState(HAContext context) { }
/// <summary>Check if an operation is supported in a given state.</summary> /// <param name="context">HA context</param> /// <param name="op">Type of the operation.</param> /// <exception cref="Org.Apache.Hadoop.Ipc.StandbyException"> /// if a given type of operation is not /// supported in standby state /// </exception> public abstract void CheckOperation(HAContext context, NameNode.OperationCategory op);
/// <summary> /// Method to be overridden by subclasses to perform steps necessary for /// exiting a state. /// </summary> /// <param name="context">HA context</param> /// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException">on failure to enter the state. /// </exception> public abstract void ExitState(HAContext context);
public override void CheckOperation(HAContext context, NameNode.OperationCategory op) { return; }
/// <exception cref="Org.Apache.Hadoop.HA.ServiceFailedException"/> public override void PrepareToExitState(HAContext context) { context.PrepareToStopStandbyServices(); }
/// <exception cref="Org.Apache.Hadoop.Ipc.StandbyException"/> public override void CheckOperation(HAContext context, NameNode.OperationCategory op) { // HAState context.CheckOperation(op); }