int getQueueInfo(LibYarnClient_t *client, char *queue, bool includeApps,
bool includeChildQueues, bool recursive, LibYarnQueueInfo_t **queueInfo) {
string queueStr(queue);
QueueInfo queueInfoCpp;
int result = client->getQueueInfo(queueStr, includeApps, includeChildQueues,recursive, queueInfoCpp);
if (result == FUNCTION_SUCCEEDED) {
*queueInfo = (LibYarnQueueInfo_t *) malloc(sizeof(LibYarnQueueInfo_t));
(*queueInfo)->queueName = strdup(queueInfoCpp.getQueueName().c_str());
(*queueInfo)->capacity = queueInfoCpp.getCapacity();
(*queueInfo)->maximumCapacity = queueInfoCpp.getMaximumCapacity();
(*queueInfo)->currentCapacity = queueInfoCpp.getCurrentCapacity();
(*queueInfo)->state = queueInfoCpp.getQueueState();
list<QueueInfo> childQueueInfos = queueInfoCpp.getChildQueues();
(*queueInfo)->childQueueNameArraySize = childQueueInfos.size();
(*queueInfo)->childQueueNameArray = (char**) malloc(sizeof(char *) * childQueueInfos.size());
int i = 0;
for (list<QueueInfo>::iterator it = childQueueInfos.begin();
it != childQueueInfos.end(); it++) {
(*queueInfo)->childQueueNameArray[i] = strdup(it->getQueueName().c_str());
i++;
}
return FUNCTION_SUCCEEDED;
} else {
setErrorMessage(client->getErrorMessage());
return FUNCTION_FAILED;
}
}
void queryQueues(MidiClient* c)
{
cout << endl << "ALSA Queues" << endl;
cout << "id Queue_Name__________ Timer_Name__________ owner status "
<< " state PPQ Tempo BPM Ticks Time" << endl;
QList<int> queues = c->getAvailableQueues();
foreach( int q, queues ) {
MidiQueue* queue = new MidiQueue(c, q);
if (queue != NULL) {
QueueInfo qinfo = queue->getInfo();
QueueStatus qsts = queue->getStatus();
QueueTempo qtmp = queue->getTempo();
QueueTimer qtmr = queue->getTimer();
TimerId tid(qtmr.getId());
QString tname;
try {
Timer* timer = new Timer(tid, SND_TIMER_OPEN_NONBLOCK);
TimerInfo tinfo = timer->getTimerInfo();
tname = tinfo.getName();
delete timer;
} catch (...) {
tname = "inaccessible";
}
cout << qSetFieldWidth(3) << left << qinfo.getId()
<< qSetFieldWidth(20) << qinfo.getName().left(20)
<< qSetFieldWidth(0) << " "
<< qSetFieldWidth(20) << tname.left(20)
<< qSetFieldWidth(6) << right << qinfo.getOwner()
<< qSetFieldWidth(7) << (qinfo.isLocked() ? "locked" : "free")
<< qSetFieldWidth(8) << (qsts.isRunning() ? "running" : "stopped")
<< qSetFieldWidth(4) << qtmp.getPPQ()
<< qSetFieldWidth(7) << qtmp.getRealBPM()
<< qSetFieldWidth(4) << qtmp.getNominalBPM()
<< qSetFieldWidth(8) << qsts.getTickTime()
<< qSetFieldWidth(0) << " " << qsts.getClockTime()
<< endl;
delete queue;
}
}
TEST_F(TestApplicationClient,TestGetQueueInfo){
string queue = "";
QueueInfo queueInfo = client->getQueueInfo(queue,true,true,true);
EXPECT_EQ(queueInfo.getQueueName(), "default");
EXPECT_FLOAT_EQ(queueInfo.getCapacity(), 0.67);
EXPECT_FLOAT_EQ(queueInfo.getMaximumCapacity(), 0.95);
EXPECT_FLOAT_EQ(queueInfo.getCurrentCapacity(), 0.5);
EXPECT_EQ(queueInfo.getQueueState(), QueueState::Q_RUNNING);
list<QueueInfo> child = queueInfo.getChildQueues();
EXPECT_EQ(child.size(), 1);
list<QueueInfo>::iterator it = child.begin();
EXPECT_EQ(it->getQueueName(), "hawq-queue");
EXPECT_FLOAT_EQ(it->getCapacity(), 0.33);
EXPECT_FLOAT_EQ(it->getMaximumCapacity(), 0.5);
EXPECT_FLOAT_EQ(it->getCurrentCapacity(), 0.25);
list<ApplicationReport> appReportList = queueInfo.getApplicationReports();
list<ApplicationReport>::iterator itAppReport = appReportList.begin();
EXPECT_EQ(itAppReport->getApplicationId().getId(), 100);
EXPECT_EQ(itAppReport->getUser(), "postgres");
}
int main(void)
{
string rmHost("localhost");
string rmPort("8032");
string schedHost("localhost");
string schedPort("8030");
string amHost("localhost");
int32_t amPort = 0;
//cluster node1
/*
string rmHost("10.37.7.101");
string rmPort("8032");
string schedHost("10.37.7.101");
string schedPort("8030");
string amHost("10.34.0.134");
int32_t amPort = 0;
*/
string am_tracking_url("url");
LibYarnClient client(rmHost, rmPort, schedHost, schedPort, amHost, amPort, am_tracking_url);
//1. createJob
string jobName("libyarn");
string queue("default");
string jobId = client.createJob(jobName, queue);
cout<<"jobId:"<<jobId<<endl;
//2. allocate
ResourceRequest resRequest;
string host("*");
resRequest.setResourceName(host);
Resource capability;
capability.setVirtualCores(1);
capability.setMemory(1024);
resRequest.setCapability(capability);
resRequest.setNumContainers(3);
resRequest.setRelaxLocality(true);
Priority priority;
priority.setPriority(1);
resRequest.setPriority(priority);
string resGroupId("group_1");
list<string> blackListAdditions;
list<string> blackListRemovals;
list<Container> allocatedResources = client.allocateResources(jobId,
resGroupId, resRequest, blackListAdditions, blackListRemovals);
for (list<Container>::iterator it = allocatedResources.begin();
it != allocatedResources.end(); it++) {
cout << "allocate: host:" << (*it).getNodeId().getHost() << ", port:"
<< (*it).getNodeId().getPort() << ", cid:" << (*it).getId().getId()
<< ", vcores:" << (*it).getResource().getVirtualCores() << ", mem:"
<< (*it).getResource().getMemory() << endl;
}
//3. active
client.activeResources(jobId, resGroupId);
sleep(1);
//4. release
client.releaseResources(jobId, resGroupId);
sleep(2);
//5. getQueueInfo
QueueInfo queueInfo = client.getQueueInfo(queue, true, true, true);
cout << "queueName:" << queueInfo.getQueueName() << ", capacity:"
<< queueInfo.getCapacity() << ", maximumCapacity:"
<< queueInfo.getMaximumCapacity() << ", currentCapacity:"
<< queueInfo.getCurrentCapacity() << ", state:"
<< queueInfo.getQueueState() << endl;
//6. getCluster
list<NodeState> nodeStates;
nodeStates.push_back(NodeState::NS_RUNNING);
list<NodeReport> nodeReports = client.getClusterNodes(nodeStates);
for (list<NodeReport>::iterator it = nodeReports.begin(); it != nodeReports.end(); it++) {
cout << "host:" << it->getNodeId().getHost() << ", port:"
<< it->getNodeId().getPort() << ", httpAddress:" << it->getHttpAddress()
<< ", rackName:" << it->getRackName() << ", used:[vcore:"
<< it->getUsedResource().getVirtualCores() << ", mem:"
<< it->getUsedResource().getMemory() << "], capability:[vcore:"
<< it->getResourceCapability().getVirtualCores() << ", mem:"
<< it->getResourceCapability().getMemory() << "], numContainers:"
<< it->getNumContainers() << ", node_state:" << it->getNodeState()
<< ", health_report:" << it->getHealthReport()
<< ", last_health_report_time:" << it->getLastHealthReportTime()
<< endl;
}
//7. finish
cout << "to finish: jobId:" << jobId << endl;
client.finishJob(jobId, FinalApplicationStatus::APP_SUCCEEDED);
sleep(1);
return 0;
}
TestApplicationClient(){
string user("postgres");
string rmHost("localhost");
string rmPort("8032");
string tokenService = "";
Yarn::Config config;
Yarn::Internal::SessionConfig sessionConfig(config);
MockApplicationClientProtocol *protocol = new MockApplicationClientProtocol(user,rmHost,rmPort,tokenService, sessionConfig);
ApplicationId appId;
appId.setId(100);
appId.setClusterTimestamp(1454307175682);
GetNewApplicationResponse getNewApplicationResponse;
getNewApplicationResponse.setApplicationId(appId);
EXPECT_CALL((*protocol),getNewApplication(_)).Times(AnyNumber()).WillOnce(Return(getNewApplicationResponse));
EXPECT_CALL((*protocol),submitApplication(_)).Times(AnyNumber()).WillOnce(Return());
ApplicationReport appReport;
appReport.setApplicationId(appId);
appReport.setUser(user);
string queue("default");
string appName("hawq");
string hostname("master");
appReport.setQueue(queue);
appReport.setName(appName);
appReport.setHost(hostname);
appReport.setRpcPort(8090);
appReport.setProgress(0.5);
GetApplicationReportResponse appReportResponse;
appReportResponse.setApplicationReport(appReport);
EXPECT_CALL((*protocol),getApplicationReport(_)).Times(AnyNumber()).WillOnce(Return(appReportResponse));
ContainerId containerId;
containerId.setId(501);
containerId.setApplicationId(appId);
Resource resource;
resource.setMemory(1024);
resource.setVirtualCores(1);
Priority priority;
priority.setPriority(1);
ContainerReport report;
report.setId(containerId);
report.setResource(resource);
report.setPriority(priority);
list<ContainerReport> reportList;
reportList.push_back(report);
GetContainersResponse getContainersResponse;
getContainersResponse.setContainersReportList(reportList);
EXPECT_CALL((*protocol),getContainers(_)).Times(AnyNumber()).WillOnce(Return(getContainersResponse));
NodeId nodeId;
string nodeHost("node1");
nodeId.setHost(nodeHost);
nodeId.setPort(9983);
NodeReport nodeReport;
nodeReport.setNodeId(nodeId);
string rackName("default-rack");
nodeReport.setRackName(rackName);
nodeReport.setNumContainers(8);
Resource nodeResource;
nodeResource.setMemory(2048*8);
nodeResource.setVirtualCores(8);
nodeReport.setResourceCapablity(nodeResource);
nodeReport.setNodeState(NodeState::NS_RUNNING);
list<NodeReport> nodeReportList;
nodeReportList.push_back(nodeReport);
GetClusterNodesResponse getClusterNodesResponse;
getClusterNodesResponse.setNodeReports(nodeReportList);
EXPECT_CALL((*protocol),getClusterNodes(_)).Times(AnyNumber()).WillOnce(Return(getClusterNodesResponse));
QueueInfo queueInfo;
queueInfo.setQueueName(queue);
queueInfo.setCapacity(0.67);
queueInfo.setMaximumCapacity(0.95);
queueInfo.setCurrentCapacity(0.5);
queueInfo.setQueueState(QueueState::Q_RUNNING);
QueueInfo childQueue;
string childQueueName("hawq-queue");
childQueue.setQueueName(childQueueName);
childQueue.setCapacity(0.33);
childQueue.setMaximumCapacity(0.5);
childQueue.setCurrentCapacity(0.25);
list<QueueInfo> childQueueList;
childQueueList.push_back(childQueue);
queueInfo.setChildQueues(childQueueList);
list<ApplicationReport> appReportList;
appReportList.push_back(appReport);
queueInfo.setApplicationReports(appReportList);
GetQueueInfoResponse getQueueInfoResponse;
getQueueInfoResponse.setQueueInfo(queueInfo);
EXPECT_CALL((*protocol),getQueueInfo(_)).Times(AnyNumber()).WillOnce(Return(getQueueInfoResponse));
KillApplicationResponseProto killApplicationResponseProto;
EXPECT_CALL((*protocol),forceKillApplication(_)).Times(AnyNumber()).WillOnce(Return(KillApplicationResponse(killApplicationResponseProto)));
YarnClusterMetrics metrics;
metrics.setNumNodeManagers(10);
GetClusterMetricsResponse clusterMetricsResponse;
clusterMetricsResponse.setClusterMetrics(metrics);
EXPECT_CALL((*protocol),getClusterMetrics(_)).Times(AnyNumber()).WillOnce(Return(clusterMetricsResponse));
GetApplicationsResponse applicationsResponse;
applicationsResponse.setApplicationList(appReportList);
EXPECT_CALL((*protocol),getApplications(_)).Times(AnyNumber()).WillOnce(Return(applicationsResponse));
QueueUserACLInfo aclInfo;
aclInfo.setQueueName(queue);
list<QueueACL> queueACLList;
QueueACL acl1 = QueueACL::QACL_ADMINISTER_QUEUE;
QueueACL acl2 = QueueACL::QACL_SUBMIT_APPLICATIONS;
queueACLList.push_back(acl1);
queueACLList.push_back(acl2);
aclInfo.setUserAcls(queueACLList);
list<QueueUserACLInfo> aclInfoList;
aclInfoList.push_back(aclInfo);
GetQueueUserAclsInfoResponse queueUserAclsInfoResponse;
queueUserAclsInfoResponse.setUserAclsInfoList(aclInfoList);
EXPECT_CALL((*protocol),getQueueAclsInfo(_)).Times(AnyNumber()).WillOnce(Return(queueUserAclsInfoResponse));
client = new ApplicationClient(protocol);
}
QWidget* XletQueuesConfigure::buildConfigureQueueList(QWidget *parent)
{
QWidget *root = new QWidget(parent);
QGridLayout *layout = new QGridLayout(root);
root->setLayout(layout);
layout->addWidget(new QLabel(tr("Queue"), root), 0, 0, Qt::AlignLeft);
QLabel *label_qos = new QLabel(tr("Qos - X (s)"), root);
label_qos->setToolTip(tr(
"This is the threshold in seconds to consider that the answer to a "
"call was too late to be accounted as an answer of quality."));
layout->addWidget(label_qos, 0, 1, Qt::AlignLeft);
QLabel *label_window = new QLabel(tr("Window (s)"), root);
label_window->setToolTip(tr(
"The window is the period of time used to compute the statistics"));
layout->addWidget(label_window, 0, 2, Qt::AlignLeft);
QCheckBox *displayQueue;
QSpinBox *spinBox;
int row;
int column;
QVariantMap statConfig = b_engine->getConfig("guioptions.queuespanel").toMap();
QString xqueueid;
row = 1;
QHashIterator<QString, XInfo *> i = \
QHashIterator<QString, XInfo *>(b_engine->iterover("queues"));
while (i.hasNext()) {
column = 0;
i.next();
QueueInfo * queueinfo = (QueueInfo *) i.value();
xqueueid = queueinfo->xid();
displayQueue = new QCheckBox(queueinfo->queueName(), root);
displayQueue->setProperty("xqueueid", xqueueid);
displayQueue->setProperty("param", "visible");
displayQueue->setChecked(statConfig.value("visible" + xqueueid, true).toBool());
layout->addWidget(displayQueue, row, column++);
connect(displayQueue, SIGNAL(stateChanged(int)),
this, SLOT(changeQueueStatParam(int)));
spinBox = new QSpinBox(root);
spinBox->setAlignment(Qt::AlignCenter);
spinBox->setMaximum(240);
spinBox->setProperty("xqueueid", xqueueid);
spinBox->setProperty("param", "xqos");
spinBox->setValue(statConfig.value("xqos" + xqueueid, 60).toInt());
layout->addWidget(spinBox, row, column++);
connect(spinBox, SIGNAL(valueChanged(int)),
this, SLOT(changeQueueStatParam(int)));
spinBox = new QSpinBox(root);
spinBox->setAlignment(Qt::AlignCenter);
spinBox->setMaximum(3600*3);
spinBox->setProperty("xqueueid", xqueueid);
spinBox->setProperty("param", "window");
spinBox->setValue(statConfig.value("window" + xqueueid, 3600).toInt());
layout->addWidget(spinBox, row, column++);
connect(spinBox, SIGNAL(valueChanged(int)),
this, SLOT(changeQueueStatParam(int)));
row++;
}
return root;
}
