😃 👨🏿‍💻 🐺 आपका सिस्टम मॉनिटर (लिनक्स) लिखना 👭 👈🏻 👨🏽‍🎨

इस लेख में, मैं आपके स्वयं के सिस्टम मॉनिटर बनाने की प्रक्रिया का वर्णन करूँगा। यह सिस्टम मॉनिटर दिखाता है:

होस्ट का नाम
उपयोगकर्ता नाम
अपटाइम
प्रोसेसर मॉडल का नाम
सीपीयू आवृत्ति
सीपीयू लोड
रैम राशि
कैश्ड डेटा के बिना उपयोग की गई RAM की मात्रा
प्रक्रिया चल रही है

यदि कोई पेनल्‍ट पॉइंट में समझ में नहीं आता है कि कैश्ड डेटा के बिना इसका क्‍या अर्थ है, तो इसे पढ़ें, यह बताता है कि इसका अर्थ क्‍या है। इसके अलावा इस प्रणाली की निगरानी में प्रक्रियाओं को पूरा करने की क्षमता को लागू किया जाता है।
नतीजतन, हमें ऐसी प्रणाली की निगरानी करनी चाहिए:

अब इसकी मुख्य विशेषताओं को परिभाषित किया गया है, और मैं कोड का वर्णन करना शुरू कर सकता हूं, मैं आपको तुरंत चेतावनी देता हूं कि कोड केवल लिनक्स में काम करेगा, क्योंकि इसकी लगभग सभी विशेषताएं / खरीद फोल्डर को पार्स करने पर आधारित हैं। मैंने अपने सिस्टम मॉनिटर को तीन वर्गों में विभाजित किया है, प्रथम श्रेणी में सामान्य सिस्टम जानकारी लागू की जाती है, दूसरी कक्षा में एक प्रक्रिया तालिका, अच्छी तरह से, और तीसरी कक्षा इसे एक पूरे में संयोजित करेगी। यहाँ प्रथम श्रेणी की रूपरेखा है, मैंने इसे जानकारी कहा:

#ifndef INFO_H #define INFO_H #include <QtGui> #include <iostream> #include <fstream> #include <pwd.h> #include <unistd.h> #include <sys/sysinfo.h> #include <vector> using namespace std; class Info : public QWidget { Q_OBJECT public: explicit Info(QWidget *parent = 0); private: QLabel * hostname; QLabel * user; QLabel * uptime; QLabel * proc; QLabel * freq; QLabel * cpuload; QLabel * mem; QLabel * memload; QProgressBar * cpubar; QProgressBar * membar; QVBoxLayout * layout; QHBoxLayout * hlayout; vector<float> readCpuStats(); int getCpuLoad(double dt); public slots: void update(); }; #endif // INFO_H

हेडर फ़ाइलों pwd.h और unistd.h का उपयोग उपयोगकर्ता नाम प्राप्त करने के लिए किया जाता है, और हेडर फ़ाइल sys / sysinfo.h अपटाइम के लिए। अब मैं जानकारी वर्ग के कार्यान्वयन का वर्णन करूंगा, यह info.cpp फ़ाइल में स्थित है। Info.cpp फ़ाइल की शुरुआत में, हमें info.h (जानकारी वर्ग की रूपरेखा) को शामिल करना होगा। जानकारी वर्ग के लिए निर्माता इस प्रकार है:

 Info::Info(QWidget *parent) : QWidget(parent) { hostname = new QLabel("Hostname: "); user = new QLabel(": "); uptime = new QLabel("Uptime: "); proc = new QLabel(": "); freq = new QLabel(":"); cpuload = new QLabel(" : "); mem = new QLabel(" : "); memload = new QLabel("  : "); cpubar = new QProgressBar; membar = new QProgressBar; layout = new QVBoxLayout; hlayout = new QHBoxLayout; cpubar->setMaximumHeight(21); membar->setMaximumHeight(21); hlayout->addWidget(cpuload); hlayout->addWidget(cpubar); layout->addWidget(hostname); layout->addWidget(user); layout->addWidget(uptime); layout->addWidget(proc); layout->addWidget(freq); layout->addLayout(hlayout); layout->addWidget(mem); layout->addWidget(memload); layout->addWidget(membar); setLayout(layout); update(); QTimer *timer = new QTimer; connect(timer, SIGNAL(timeout()), this, SLOT(update())); timer->start(2000); }

बहुत शुरुआत में हम सभी ग्राफिक तत्वों को इनिशियलाइज़ करते हैं। अगला चरण लेआउट में ग्राफिक तत्वों की व्यवस्था कर रहा है। हम अपडेट स्लॉट को कॉल करने के बाद, ताकि सभी लेबल और प्रगति बार मानों से भर जाएं। नियमित रूप से अपडेट की जाने वाली जानकारी के लिए, हम क्यूटीमर क्लास का एक ऑब्जेक्ट बनाते हैं, और इसके टाइमआउट सिग्नल को उस अपडेट स्लॉट से जोड़ते हैं जिसे हम पहले से जानते हैं।
मुझे लगता है कि अद्यतन स्लॉट का वर्णन करना तर्कसंगत होगा, यहाँ इसका कोड है:

 void Info::update() { ifstream stream("/proc/sys/kernel/hostname"); string str; getline(stream,str); hostname->setText("Hostname: " + QString::fromStdString(str)); uid_t uid = geteuid(); passwd *pw = getpwuid(uid); user->setText(": " + QString::fromAscii(pw->pw_name)); struct sysinfo o; sysinfo(&o); long up = o.uptime; int hour = up/60/60; int min = (up - hour*60*60) / 60; int sec = ((up - hour*60*60) - min*60); QString e = QString::number(hour) + QString(" h. ") + QString::number(min) + QString(" m. ") + QString::number(sec) + QString(" s."); uptime->setText("Uptime: " + e); stream.close(); stream.open("/proc/cpuinfo"); for(int i = 0; i < 16;i++) stream >> str; getline(stream,str); proc->setText(": " + QString::fromStdString(str)); for(int i = 0; i< 7; i++) stream >> str; freq->setText(": " + QString::fromStdString(str) + " MHz"); cpubar->setValue(getCpuLoad(0.3)); stream.close(); stream.open("/proc/meminfo"); stream >> str; stream >> str; int num = atoi(str.c_str()); int percent = num / 100; int gb = (num / 1024) / 1024; int mb = (num-gb*1024*1024) /1024; int kb = (num - (gb*1024*1024+mb*1024)); if (gb > 0) e = QString::number(gb) + QString(" Gb "); else e = QString(""); if (mb > 0) e += QString::number(mb) + QString(" Mb "); if (kb > 0) e += QString::number(kb) + QString(" Kb "); mem->setText(" : " + e); int free = 0; for (int i = 0 ; i < 3 ; i++) { stream >> str; stream >> str; stream >> str; free += atoi(str.c_str()); } num -= free; gb = num / 1024 / 1024; mb = (num - gb*1024*1024) / 1024; kb = (num - ((mb*1024) + (gb * 1024 * 1024))); if (gb > 0) e = QString::number(gb) + QString(" Gb "); else e = QString(""); if (mb > 0) e += QString::number(mb) + QString(" Mb "); if (kb > 0) e += QString::number(kb) + QString(" Kb "); memload->setText("  : " + e); percent = num / percent; membar->setValue(percent); }

सबसे पहले, हम पढ़ने के लिए खोलते हैं (यही कारण है कि प्रोग्राम को सुपरयूसर अधिकारों की आवश्यकता नहीं है) फ़ाइल / proc / sys / कर्नेल / होस्टनाम और मशीन का नाम प्राप्त करें, जिसके बाद हम hostname लेबल में भरते हैं। जिसके बाद हम passwd और uid_t संरचनाओं का एक उदाहरण बनाते हैं, जिनकी मदद से हमें उपयोगकर्ता लेबल में भरने के लिए उपयोगकर्ता नाम मिलता है। उपयोगकर्ता नाम कैसे पता करें, इस बारे में जानकारी whoami कार्यक्रम के स्रोत कोड से ली गई थी। फिर हम सिसिनोफो संरचना के एक उदाहरण के साथ मूल्यों को बनाते हैं और भरते हैं, जिससे हम सिस्टम अपटाइम के बारे में जानकारी लेते हैं। उसके बाद, हम फ़ाइल / proc / cpuinfo के साथ पहले से ही बनाई गई स्ट्रीम स्ट्रीम को लिंक करते हैं, जिसमें हम प्रोसेसर मॉडल के नाम और इसकी आवृत्ति के बारे में जानकारी पाते हैं। हमें getCpuLoad विधि का उपयोग करके प्रोसेसर लोड मिलता है, जिसका मैं नीचे वर्णन करूंगा। अब हम फाइल / proc / meminfo के साथ स्ट्रीम स्ट्रीम को जोड़ते हैं, जिसमें से हम RAM की मात्रा लेते हैं, और इसे एक पठनीय रूप में लाते हैं। फिर उसी फ़ाइल से हमें मुफ्त रैम की मात्रा, साथ ही कैश्ड डेटा की मात्रा मिलती है। कब्जे वाली रैम की मात्रा प्राप्त करने के लिए, हम सभी रैम से फ्री रैम और कैश्ड डेटा की मात्रा को घटाते हैं, फिर हम इसे एक पठनीय रूप में लाते हैं। अब, जैसा कि मैंने ऊपर वादा किया था, getCpuLoad फ़ंक्शन विवरण। मैंने यह फ़ंक्शन खुद नहीं लिखा था (मैंने इसे यहां से लिया है ), इसलिए मैं इसका बहुत विस्तृत विवरण नहीं दे सकता, मैं इसे सामान्य शब्दों में वर्णित करूंगा। यहाँ यह है:

 int Info::getCpuLoad(double dt) { vector<float> stats1 = readCpuStats(); QProcess::execute("sleep",QStringList() << QString::number(dt)); vector<float> stats2 = readCpuStats(); int size1 = stats1.size(); int size2 = stats2.size(); if (!size1 || !size2 || size1 != size2) return 2; for (int i = 0; i < size1; ++i) stats2[i] -= stats1[i]; int sum = 1; for (int i = 0; i < size1; ++i) sum += stats2[i]; int load = 100 - (stats2[size2 - 1] * 100 / sum); return load; }

दो बार हमें readCpuStats फ़ंक्शन का उपयोग करके तीन मान मिलते हैं (मैं इसे नीचे भी वर्णित करूंगा), लेकिन हम एक निश्चित समय अंतराल के साथ इस फ़ंक्शन को कहते हैं। प्रोसेसर लोड की गणना इन मूल्यों के आधार पर की जाती है। और अब readCpuStats फ़ंक्शन का वर्णन:

 vector<float> Info::readCpuStats() { vector<float> ret; ifstream stat_file("/proc/stat"); if (!stat_file.is_open()) { cout << "Unable to open /proc/stat" << std::endl; return ret; } int val; string tmp; stat_file >> tmp; for (int i = 0; i < 4; ++i) { stat_file >> val; ret.push_back(val); } stat_file.close(); return ret; }

यह फ़ंक्शन उसी साइट से लिया गया था जैसे getCpuLoad फ़ंक्शन। इस फ़ंक्शन में, हम फ़ाइल / proc / स्टेट से मानों को पढ़ते हैं, और उन्हें एक वेक्टर में दर्ज करते हैं, जिसे हम फिर रिटर्न स्टेटमेंट के साथ वापस करते हैं।
अब इन्फो क्लास लिखा गया है, और आप प्रोसेसटेबल क्लास लिखने के लिए आगे बढ़ सकते हैं। यहाँ इस वर्ग की रूपरेखा है:

 #ifndef PROCESSTABLE_H #define PROCESSTABLE_H #include <QtGui> #include <iostream> #include <fstream> using namespace std; class ProcessTable : public QWidget { Q_OBJECT public: explicit ProcessTable(QWidget *parent = 0); private: QTableWidget * table; QHBoxLayout* hlayout; QPushButton* button; QVBoxLayout* layout; public slots: void update(); void kill(); }; #endif // PROCESSTABLE_H

अपडेट स्लॉट का उपयोग टेबल को पॉप्युलेट करने के लिए किया जाता है, और प्रक्रियाओं को समाप्त करने के लिए किल स्लॉट को। इस वर्ग की कार्यान्वयन फ़ाइल में, हमें पहले फ़ाइल को उसके कंकाल के साथ शामिल करना चाहिए। अब मैं इस वर्ग के कंस्ट्रक्टर के विवरण की ओर मुड़ता हूं, यहां कंस्ट्रक्टर कोड दिया गया है:

 ProcessTable::ProcessTable(QWidget *parent) : QWidget(parent) { hlayout = new QHBoxLayout; button = new QPushButton(""); button->setToolTip("       PID     \"\""); connect(button,SIGNAL(clicked()),this,SLOT(kill())); hlayout->addStretch(); hlayout->addWidget(button); layout = new QVBoxLayout; table = new QTableWidget; update(); layout->addWidget(table); layout->addLayout(hlayout); this->setLayout(layout); QTimer *timer = new QTimer; connect(timer, SIGNAL(timeout()), this, SLOT(update())); timer->start(4000); }

सबसे पहले, हम ग्राफिक तत्वों को इनिशियलाइज़ करते हैं, और उन्हें कंपोज़ करते हैं, साथ ही "फिनिश" बटन से क्लिक किए गए सिग्नल को हमारी क्लास - किल के स्लॉट से जोड़ते हैं। हम टेबल को आबाद करने के लिए अपडेट स्लॉट भी कहते हैं, और टाइमर का उपयोग करके टेबल के अपडेट को लागू करते हैं। अब अद्यतन स्लॉट का विवरण, यहाँ इसका कोड है:

 void ProcessTable::update() { table->setColumnCount(2); table->setRowCount(0); QStringList list; list << "Name" << "PID"; table->setHorizontalHeaderLabels(list); QDir * dir = new QDir("/proc"); list = dir->entryList(QStringList("*"),QDir::AllDirs); foreach(QString str, list) { if(str.toInt()) { ifstream stream; stream.open("/proc/" + str.toAscii() + "/comm"); string s; getline(stream,s); int lastRow = table->rowCount(); QString icon = "/usr/share/icons/hicolor/32x32/apps/" + QString::fromStdString(s) + ".png"; QFile file(icon); table->insertRow(lastRow); table->setColumnWidth(0,150); if(!file.exists()) { icon = ":/binary.png"; } table->setItem(lastRow,0,new QTableWidgetItem(QPixmap(icon),QString::fromStdString(s))); table->setItem(lastRow,1,new QTableWidgetItem(str)); } else { continue; } } }

सबसे पहले, हम तालिका के साथ स्तंभों और पंक्तियों की संख्या, साथ ही स्तंभों के नाम भी निर्धारित करते हैं। तब हमें / proc फ़ोल्डर में निर्देशिकाओं की एक सूची मिलती है। तालिका को भरने के लिए, हम पूरी सूची के माध्यम से लूप करते हैं, निर्देशिकाओं को छोड़ देते हैं जो प्रक्रियाओं से संबंधित नहीं हैं। हमें फ़ाइल / proc / pid / comm से प्रक्रिया का नाम मिलता है। हम आइकन को फोल्डर / usr / share / icons / hicolor / 32x32 / apps से लेते हैं, और यदि आइकन नहीं है, तो बाइनरी में बाइनरी.पिंग चित्र सिलना का उपयोग किया जाता है। ये रही तस्वीर:

स्रोत में इसे सीवे करने के लिए, मैंने आरसीसी का उपयोग किया, आप मैक्स शेली की पुस्तक "क्यूटी - प्रोफेशनल सी ++ प्रोग्रामिंग" में आरसीसी का उपयोग करने के बारे में पढ़ सकते हैं, या आप इसे गूगल कर सकते हैं, मुझे लगता है कि आरसीसी का उपयोग करके इंटरनेट पर बहुत सारे मैना हैं।
अब किल स्लॉट के विवरण पर जाएं, यहां इसका कोड है:

 void ProcessTable::kill() { QList<QTableWidgetItem*> list = table->selectedItems(); QTableWidgetItem* item = list.value(0); QString str = item->text(); QProcess::execute("kill", QStringList() << str); update(); }

प्रक्रिया को पूरा करने के लिए, मैं उस प्रोग्राम का उपयोग करता हूं जो सभी लिनक्स में है (यदि आपके लिनक्स में यह नहीं है, तो मैं यह भी कल्पना नहीं कर सकता कि यह किस तरह का लिनक्स है), मैं इस कार्यक्रम को लॉन्च करने के लिए QProcess वर्ग के निष्पादन विधि का उपयोग करता हूं, इस फ़ंक्शन का दूसरा तर्क मापदंडों की एक सूची है एक प्रोग्राम के लिए, मैं पूरी की जाने वाली प्रक्रिया का केवल PID पास करता हूं, इस प्रोग्राम को कॉल करने के बाद मैं टेबल को अपडेट करता हूं ताकि पूरी की गई प्रक्रिया इससे गायब हो जाए। अब मैं SystemMonitor वर्ग के विवरण की ओर मुड़ता हूं, जिसमें मैं दो वर्गों को जोड़ता हूं। इस वर्ग का ढांचा काफी सरल है:

 #ifndef SYSTEMMONITOR_H #define SYSTEMMONITOR_H #include <QtGui> #include "info.h" #include "processtable.h" class SystemMonitor : public QWidget { Q_OBJECT public: explicit SystemMonitor(QWidget *parent = 0); }; #endif // SYSTEMMONITOR_H

खैर, इस वर्ग में केवल एक ही विधि है, इसलिए मैं अब इसका वर्णन करूंगा। यहाँ इस निर्माण विधि के लिए कोड है (कार्यान्वयन फ़ाइल के शीर्ष पर एक वायरफ्रेम फ़ाइल कनेक्शन जोड़ें):

 SystemMonitor::SystemMonitor(QWidget *parent) : QWidget(parent) { QTabWidget * tab = new QTabWidget; Info* info = new Info; ProcessTable* pt = new ProcessTable; tab->addTab(info,"  "); tab->addTab(pt,""); QVBoxLayout * layout = new QVBoxLayout; layout->addWidget(tab); this->setLayout(layout); this->show(); }

कंस्ट्रक्टर में, हम बस एक टैब विजेट बनाते हैं, और जानकारी के साथ हमारे विजेट को जोड़ते हैं, और टेबल के साथ विजेट, क्योंकि ऐडटैब विधि विजेट को एक तर्क के रूप में स्वीकार करती है, इसके लिए हमें QWidget से जानकारी और प्रोसेसटेबल कक्षाएं विरासत में मिली हैं। और अब अंतिम स्पर्श, प्रोग्राम का शुरुआती बिंदु, जो कि मुख्य है। फाइल। यहाँ उसका कोड है:

 #include "systemmonitor.h" int main(int argc,char** argv) { QTextCodec::setCodecForLocale(QTextCodec::codecForName("UTF-8")); QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8")); QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); QApplication app(argc,argv); QStyle * style = QStyleFactory::create("Cleanlooks"); app.setStyle(style); SystemMonitor sys; return app.exec(); }

पहले तीन पंक्तियों को सही ढंग से प्रदर्शित कार्यक्रम में रूसी पत्र बनाते हैं। लाइनें 8 और 9 सुनिश्चित करती हैं कि हमारा आवेदन किसी भी सिस्टम पर समान होगा।
खैर, यह तो है, सिस्टम मॉनिटर अभी के लिए तैयार है!

आपका सिस्टम मॉनिटर (लिनक्स) लिखना

More articles: