Esempio n. 1
0
 /// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/>
 public override GetQueueInfoResponse GetQueueInfo(GetQueueInfoRequest request)
 {
     this._enclosing.ResetStartFailoverFlag(true);
     // make sure failover has been triggered
     NUnit.Framework.Assert.IsTrue(this._enclosing.WaittingForFailOver());
     // return fake QueueInfo
     return(GetQueueInfoResponse.NewInstance(this._enclosing.CreateFakeQueueInfo()));
 }
        /// <exception cref="Com.Google.Protobuf.ServiceException"/>
        public virtual YarnServiceProtos.GetQueueInfoResponseProto GetQueueInfo(RpcController
                                                                                controller, YarnServiceProtos.GetQueueInfoRequestProto proto)
        {
            GetQueueInfoRequestPBImpl request = new GetQueueInfoRequestPBImpl(proto);

            try
            {
                GetQueueInfoResponse response = real.GetQueueInfo(request);
                return(((GetQueueInfoResponsePBImpl)response).GetProto());
            }
            catch (YarnException e)
            {
                throw new ServiceException(e);
            }
            catch (IOException e)
            {
                throw new ServiceException(e);
            }
        }
Esempio n. 3
0
        public virtual void TestGetRootQueues()
        {
            ApplicationClientProtocol applicationsManager = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
                                                                                      >();
            GetQueueInfoResponse response  = Org.Mockito.Mockito.Mock <GetQueueInfoResponse>();
            QueueInfo            queueInfo = Org.Mockito.Mockito.Mock <QueueInfo>();

            Org.Mockito.Mockito.When(response.GetQueueInfo()).ThenReturn(queueInfo);
            try
            {
                Org.Mockito.Mockito.When(applicationsManager.GetQueueInfo(Org.Mockito.Mockito.Any
                                                                          <GetQueueInfoRequest>())).ThenReturn(response);
            }
            catch (YarnException e)
            {
                throw new IOException(e);
            }
            ResourceMgrDelegate delegate_ = new _ResourceMgrDelegate_69(applicationsManager,
                                                                        new YarnConfiguration());

            delegate_.GetRootQueues();
            ArgumentCaptor <GetQueueInfoRequest> argument = ArgumentCaptor.ForClass <GetQueueInfoRequest
                                                                                     >();

            try
            {
                Org.Mockito.Mockito.Verify(applicationsManager).GetQueueInfo(argument.Capture());
            }
            catch (YarnException e)
            {
                throw new IOException(e);
            }
            NUnit.Framework.Assert.IsTrue("Children of root queue not requested", argument.GetValue
                                              ().GetIncludeChildQueues());
            NUnit.Framework.Assert.IsTrue("Request wasn't to recurse through children", argument
                                          .GetValue().GetRecursive());
        }
Esempio n. 4
0
        /// <exception cref="System.Exception"/>
        public virtual void TestResourceMgrDelegate()
        {
            /* we not want a mock of resource mgr delegate */
            ApplicationClientProtocol clientRMProtocol = Org.Mockito.Mockito.Mock <ApplicationClientProtocol
                                                                                   >();
            ResourceMgrDelegate delegate_ = new _ResourceMgrDelegate_256(clientRMProtocol, conf
                                                                         );

            /* make sure kill calls finish application master */
            Org.Mockito.Mockito.When(clientRMProtocol.ForceKillApplication(Matchers.Any <KillApplicationRequest
                                                                                         >())).ThenReturn(KillApplicationResponse.NewInstance(true));
            delegate_.KillApplication(appId);
            Org.Mockito.Mockito.Verify(clientRMProtocol).ForceKillApplication(Matchers.Any <KillApplicationRequest
                                                                                            >());
            /* make sure getalljobs calls get all applications */
            Org.Mockito.Mockito.When(clientRMProtocol.GetApplications(Matchers.Any <GetApplicationsRequest
                                                                                    >())).ThenReturn(recordFactory.NewRecordInstance <GetApplicationsResponse>());
            delegate_.GetAllJobs();
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetApplications(Matchers.Any <GetApplicationsRequest
                                                                                       >());
            /* make sure getapplication report is called */
            Org.Mockito.Mockito.When(clientRMProtocol.GetApplicationReport(Matchers.Any <GetApplicationReportRequest
                                                                                         >())).ThenReturn(recordFactory.NewRecordInstance <GetApplicationReportResponse>()
                                                                                                          );
            delegate_.GetApplicationReport(appId);
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetApplicationReport(Matchers.Any <GetApplicationReportRequest
                                                                                            >());
            /* make sure metrics is called */
            GetClusterMetricsResponse clusterMetricsResponse = recordFactory.NewRecordInstance
                                                               <GetClusterMetricsResponse>();

            clusterMetricsResponse.SetClusterMetrics(recordFactory.NewRecordInstance <YarnClusterMetrics
                                                                                      >());
            Org.Mockito.Mockito.When(clientRMProtocol.GetClusterMetrics(Matchers.Any <GetClusterMetricsRequest
                                                                                      >())).ThenReturn(clusterMetricsResponse);
            delegate_.GetClusterMetrics();
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetClusterMetrics(Matchers.Any <GetClusterMetricsRequest
                                                                                         >());
            Org.Mockito.Mockito.When(clientRMProtocol.GetClusterNodes(Matchers.Any <GetClusterNodesRequest
                                                                                    >())).ThenReturn(recordFactory.NewRecordInstance <GetClusterNodesResponse>());
            delegate_.GetActiveTrackers();
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetClusterNodes(Matchers.Any <GetClusterNodesRequest
                                                                                       >());
            GetNewApplicationResponse newAppResponse = recordFactory.NewRecordInstance <GetNewApplicationResponse
                                                                                        >();

            newAppResponse.SetApplicationId(appId);
            Org.Mockito.Mockito.When(clientRMProtocol.GetNewApplication(Matchers.Any <GetNewApplicationRequest
                                                                                      >())).ThenReturn(newAppResponse);
            delegate_.GetNewJobID();
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetNewApplication(Matchers.Any <GetNewApplicationRequest
                                                                                         >());
            GetQueueInfoResponse queueInfoResponse = recordFactory.NewRecordInstance <GetQueueInfoResponse
                                                                                      >();

            queueInfoResponse.SetQueueInfo(recordFactory.NewRecordInstance <QueueInfo>());
            Org.Mockito.Mockito.When(clientRMProtocol.GetQueueInfo(Matchers.Any <GetQueueInfoRequest
                                                                                 >())).ThenReturn(queueInfoResponse);
            delegate_.GetQueues();
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetQueueInfo(Matchers.Any <GetQueueInfoRequest
                                                                                    >());
            GetQueueUserAclsInfoResponse aclResponse = recordFactory.NewRecordInstance <GetQueueUserAclsInfoResponse
                                                                                        >();

            Org.Mockito.Mockito.When(clientRMProtocol.GetQueueUserAcls(Matchers.Any <GetQueueUserAclsInfoRequest
                                                                                     >())).ThenReturn(aclResponse);
            delegate_.GetQueueAclsForCurrentUser();
            Org.Mockito.Mockito.Verify(clientRMProtocol).GetQueueUserAcls(Matchers.Any <GetQueueUserAclsInfoRequest
                                                                                        >());
        }