मुझे आपके बारे में पता नहीं है, लेकिन आमतौर पर जब मुझे कुछ लिखने की जरूरत होती है, तो बुखार और विचारों की पूरी वेश्यावृत्ति खरोंच से शुरू होती है। विभिन्न अमूर्त मॉडल पहले से ही मेरे सिर में उड़ते हैं, क्या और कहां से आते हैं। लेकिन उनमें से किसी एक को पकड़ना असंभव है, क्योंकि आपके पास एक खाली चादर है और आपके दिमाग में एक विचार आंसू बहा रहा है, इसे लागू करने के लिए कुछ भी नहीं है, और आप पूरे कंकाल को बाहर नहीं निकाल सकते, क्योंकि आप पहले से ही समस्या को हल करने के बारे में सोच रहे हैं, लेकिन आपको बस जरूरत है एप्लिकेशन की रीढ़ लिखें।

नीचे "NULL प्रोजेक्ट" है, बहुत ही रीढ़ है जिसके साथ यह आमतौर पर शुरू होता है। मेरे साथ।

यह पोस्ट उन लोगों के लिए सबसे दिलचस्प होने की संभावना नहीं है जो पहले से ही अनुभवी हैं और जो सीधे सी ++ विकास से संबंधित नहीं हैं, क्योंकि नीचे प्रस्तुत सामग्री का एक ही उद्देश्य है - एक शुरुआत के लिए तैयार नींव देना।

आवश्यकताओं

शुरुआत के लिए, मैं इस फ्रेमवर्क को लागू करने के लिए कई आवश्यकताओं को उजागर करने की कोशिश करूंगा।

प्रोजेक्ट फ़ोल्डर
सीमेक सॉल्यूशिनोव उत्पन्न करने के लिए स्क्रिप्ट और स्क्रिप्ट का निर्माण करते हैं
स्क्रिप्ट शुरू और बंद करो
आवेदन शुरू होना चाहिए, काम करना चाहिए और सही ढंग से समाप्त होना चाहिए, पूरी प्रक्रिया को लॉग इन किया जाना चाहिए
आप कंसोल में लॉग इन कर सकते हैं, वैसे भी, प्रत्येक प्रोजेक्ट का अपना लॉगर होता है, मुख्य बात यह है कि इसे बदलना आसान होगा।
एप्लिकेशन को कमांड लाइन को पार्स करना चाहिए
एप्लिकेशन को फॉर्म की कुंजी = मान की कॉन्फ़िगरेशन फ़ाइल पार्स करने में सक्षम होना चाहिए
बढ़ावा के बिना परियोजना? नहीं, सुना नहीं। इसलिए तुरंत बढ़ावा दें
त्रुटि से निपटने। चूंकि यह केवल रीढ़ है और यहां, वास्तव में, कोई प्रदर्शन नहीं है, हम इसे अपवादों के साथ करते हैं।
~~दुनिया पर कब्जा समारोह बनाते हैं~~

प्रोजेक्ट फ़ोल्डर

. ├── CMakeLists.txt ├── gen_eclipse.sh ├── include │  ├── logger.h │  ├── mediator.h │  ├── pid.h │  ├── program_options.h │  ├── thread.h │  └── version.h ├── package.sh ├── src │  ├── logger.cpp │  ├── main.cpp │  ├── mediator.cpp │  ├── pid.cpp │  ├── program_options.cpp │  └── version.cpp ├── start.sh ├── stop.sh └── version.sh

सोल्युशिन जनरेटर

Gen_eclipse.sh स्क्रिप्ट का उद्देश्य डिबग उत्पन्न करने और समाधान जारी करने के लिए फ़ोल्डर संरचना तैयार करना और cmake को लागू करना है। और प्रोजेक्ट का वर्तमान संस्करण भी सेट करें। ऐसा हुआ कि लिनक्स सिस्टम पर विकास आमतौर पर एक्लिप्स वातावरण में किया जाता है, इसलिए इसका नाम gen_eclipse है। लेकिन दोस्तों Cmake और ग्रहण को पूरी तरह से बनाने में मैं सफल नहीं रहा। एक्लिप्स में उत्पन्न प्रोजेक्ट को खोलने के लिए, आपको मौजूदा मेक प्रोजेक्ट को आयात करने की आवश्यकता है, या तो रिलीज़ या डिबग करें, और संदर्भ मेनू के माध्यम से शामिल और src निर्देशिकाओं के लिंक जोड़ें।

gen_eclipse.sh

 #!/bin/bash ROOT_DIR=$PWD BUILD_DIR=$PWD/"build" BUILD_DIR_R=$BUILD_DIR/release BUILD_DIR_D=$BUILD_DIR/debug mkdir -p $BUILD_DIR mkdir -p $BUILD_DIR_R mkdir -p $BUILD_DIR_D if [ -d $BUILD_DIR_R ]; then if [ -f $BUILD_DIR_R/CMakeCache.txt ]; then rm $BUILD_DIR_R/CMakeCache.txt fi fi if [ -d $BUILD_DIR_D ]; then if [ -f $BUILD_DIR_D/CMakeCache.txt ]; then rm $BUILD_DIR_D/CMakeCache.txt fi fi echo "[[ Generate Release solution]]" cd $BUILD_DIR_R cmake -G "Eclipse CDT4 - Unix Makefiles" -DCMAKE_BUILD_TYPE:STRING="Release" --build $BUILD_DIR_R ../../ echo echo "[[ Generate Debug solution]]" cd $BUILD_DIR_D cmake -G "Eclipse CDT4 - Unix Makefiles" -DCMAKE_BUILD_TYPE:STRING="Debug" --build $BUILD_DIR_D ../../ cd $ROOT_DIR ./version.sh

संस्करण

ध्यान देने योग्य पहली बात यह है कि मैं तोड़फोड़ का उपयोग करता हूं और संस्करणों के रूप में संशोधन संख्याओं पर भरोसा करता हूं। मैं आमतौर पर निम्नलिखित संस्करण प्रारूप का पालन करता हूं: MAJOR.MINOR.REVISION। पहले दो मान हैंडल द्वारा निर्धारित किए गए हैं, तीसरा svn संशोधन है। जहां तक मुझे पता है, तोड़फोड़ करने वाला ग्राहक सिर्फ रिवीजन नंबर नहीं दे पा रहा है, इसलिए मैं निम्नलिखित तंत्र का उपयोग करता हूं

 REVISION=`LANG=C svn info | grep "Last Changed Rev:" | sed s/"Last Changed Rev":\ //` if [[ "$REVISION" == "" ]]; then echo "Cannot recognize number of revision" exit 1 fi ... VER_CPP=src/version.cpp echo "#include \"version.h\"" > $VER_CPP echo "const char* VERSION = \"$VERSION\";" >> $VER_CPP

लिपियाँ शुरू होती हैं, टूटती हैं

एक नियम के रूप में, सभी सॉफ़्टवेयर जिन्हें लिनक्स के तहत लिखा जाना था, ये सर्वर, बड़े और छोटे थे। उनकी ख़ासियत यह है कि वे पृष्ठभूमि में काम करते हैं, ये सेवाएं हैं। मुझे पता है कि ऐसी चीजों के लिए init.d निर्देशिका में स्क्रिप्ट्स को शुरू करना और बंद करना प्रथा है। लेकिन! मेरे पास कभी भी एक ऐसा मामला नहीं था जहां किसी सेवा का केवल एक ही संस्करण एकल सर्वर पर लॉन्च किया गया हो। इसलिए, मैं पीआईडी फ़ाइल पर नियंत्रण के साथ स्टार्ट स्टॉप स्क्रिप्ट के अभ्यास का पालन करता हूं।

start.sh

 #!/bin/bash source init.conf MAIN_LOG="$APP_LOG_DIR"/start.log echo "Start application '$APP_NAME'" if [ -f $APP_PID ]; then PID=`cat $APP_PID` if [ -z $PID ]; then echo "File '$APP_PID' exist but it's empty, delete it" rm $APP_PID elif ! ps h -p $PID > /dev/null; then echo "File '$APP_PID' exist but process with pid '$PID' doesn't exist, delete it" rm $APP_PID else echo "$APP_NAME already started (file $APP_PID exist)" exit fi fi mkdir -p $APP_LOG_DIR if [ $APP_EXPORT_LIB_DIR ]; then export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$APP_EXPORT_LIB_DIR; fi echo =========================================== >> $MAIN_LOG date >> $MAIN_LOG if [ -f $APP_BIN ]; then ./$APP_BIN -l $APP_LOG_DIR -c $APP_CONF -p $APP_PID >> $MAIN_LOG & else echo "Error: binary file '$APP_BIN' doesn't exist" exit 1 fi if [[ $? != 0 ]]; then echo "Not started" else echo "Started" fi

शटडाउन स्क्रिप्ट में स्लो सर्वर शटडाउन के लिए अधिक परिष्कृत तर्क है।

stop.sh

 #!/bin/bash source init.conf if [ ! -f $APP_PID ]; then echo "'$APP_NAME' not started (file $APP_PID doesn't exist)" exit fi PID=`cat $APP_PID` if ! ps h -p $PID > /dev/null then echo "'$APP_NAME' not started, removing old $APP_PID file" rm $APP_PID exit fi if ! kill -s SIGTERM $PID then echo "Cannot stop process" exit fi for i in {1..10} do if ps h -p $PID > /dev/null then echo -n . sleep 1 else echo "Stopped" exit fi done echo echo "Can't correctly stop application, finish him" kill -9 $PID rm $APP_PID

पुनश्च। स्टॉप.श स्क्रिप्ट के अधिक उपयोगी संस्करण की पेशकश करने के लिए मेरे सहयोगी आंद्रेई को धन्यवाद

Package.sh

प्रत्येक प्रोजेक्ट में, मेरे पास एक पैकेज.श स्क्रिप्ट है जिसका उद्देश्य पर्याप्त इंस्टॉलेशन पैकेज बनाना है। आमतौर पर, यह एक संग्रहीत एप्लिकेशन फ़ोल्डर है जिसमें एप्लिकेशन काम करने के लिए पर्याप्त फ़ाइलों का एक सेट है। न्यूनतम सेट ब्रेक स्टार्ट स्क्रिप्ट, एक कॉन्फ़िगरेशन फ़ाइल, एप्लिकेशन स्वयं और लॉग के लिए एक फ़ोल्डर है।

package.sh

 #!/bin/bash APP_NAME=projectnull VERSION=`./version.sh show` PACKAGE=$APP_NAME.$VERSION.tar.bz2 echo "Create instalation package of '$APP_NAME' ($PACKAGE)" TEMP_FOLDER=$APP_NAME FILES=( "build/release/projectnull" "start.sh" "stop.sh" "init.conf" "*.conf" ) LOG_DIR=logs if [ -d $TEMP_FOLDER ]; then rm -rf $TEMP_FOLDER fi mkdir $TEMP_FOLDER for i in "${FILES[@]}" do echo "copy '$i'" cp $i $TEMP_FOLDER done echo creat $LOG_DIR mkdir $TEMP_FOLDER/$LOG_DIR tar -cjf $PACKAGE $TEMP_FOLDER rm -rf $TEMP_FOLDER echo Finished

कार्यात्मक

और इसलिए, प्रोग्रामिंग में सीधे आगे बढ़ने के लिए मुझे आमतौर पर क्या चाहिए:

पहली प्राथमिकता कमांड लाइन विकल्प
कॉन्फ़िगरेशन फ़ाइल
लकड़हारे से बातचीत करने का सरल तरीका
एप्लिकेशन को सही ढंग से रोकने की क्षमता

चलिए शुरू करते हैं:

पहली प्राथमिकता कमांड लाइन विकल्प

मैंने अपने लिए ऐसे तीन मापदंडों की पहचान की है। अब मैं समझाने की कोशिश करूंगा कि वे क्यों हैं।
लॉगिंग के लिए निर्देशिका। कॉन्फ़िगरेशन फ़ाइल में इस पैरामीटर को संग्रहीत नहीं करने का कारण यह है कि त्रुटियों को मैं लॉग करना चाहता हूं कॉन्फ़िगरेशन फ़ाइल के पार्सिंग के दौरान पहले से ही हो सकता है। एक निर्देशिका क्यों? मैं इस तथ्य के लिए उपयोग किया जाता हूं कि प्रत्येक लॉन्च एक अलग लॉग फ़ाइल है, इसलिए पुराने लॉग को हटाना आसान है।
कॉन्फ़िगरेशन फ़ाइल यदि कमांड लाइन के माध्यम से नहीं है, तो कैसे? खासकर यदि आपके पास कई कॉन्फ़िगरेशन हैं जिन्हें आप जल्दी से स्विच करना चाहते हैं।
PID फ़ाइल। कॉन्फ़िगरेशन फ़ाइल में इसे संग्रहीत नहीं करने का एकमात्र कारण यह है कि इस पैरामीटर का उपयोग तुरंत 2 स्थानों पर किया जाता है। स्क्रिप्ट शुरू और बंद करो। और इसे एक अलग इनिट फ़ाइल में रखना बहुत आसान है, जो स्टॉप स्क्रिप्ट्स को शुरू करने के लिए जोड़ता है, और इसे दो से एक बार संपादित करता है (मैं एक conf फाइल के बारे में बात कर रहा हूं)।

कमांड लाइन और कॉन्फ़िगरेशन फ़ाइल को बढ़ावा देने के द्वारा पार्सिंग :: program_options

program_options.cpp

 void ProgramOptions::load(int argc, char* argv[]) { options_description desc("Allowed options"); desc.add_options() ("help,h", "produce help message") ("config,c", value<std::string>(&conf_file)->default_value(std::string(CONF_FILE)), "set configuration file") ("logdir,l", value<std::string>(&log_dir)->default_value(std::string(LOG_DIR)), "set log directory") ("pidfile,p", value<std::string>(&pid_file)->default_value(std::string(PID_FILE)), "set pid file") ; variables_map vm; store(parse_command_line(argc, argv, desc), vm); notify(vm); if (vm.count("help")) { std::cout << desc << "\n"; exit(0); } std::cout << "Will be used the next options:" << std::endl << "CONF_FILE = " << conf_file << std::endl << "LOG_DIR = " << log_dir << std::endl << "PID_DIR = " << pid_file << std::endl ; }

प्रत्येक पैरामीटर का एक डिफ़ॉल्ट मान होता है।

./projectnull -h
अनुमत विकल्प:
-h [--help] मदद संदेश का उत्पादन
-c [--config] arg (= project.conf) सेट कॉन्फ़िगरेशन फ़ाइल
-l [--logdir] arg (= log) सेट लॉग डायरेक्टरी है
-p [--pidfile] arg (= project.pid) pid फ़ाइल सेट करता है

लॉगिंग

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

logger.h

 #define ENTRY __PRETTY_FUNCTION__ #define LOG_0(s) ; #define LOG_1(s) Log::note(ENTRY, s) #define LOG_2(s, p1) Log::note(ENTRY, s, p1) #define LOG_3(s, p1, p2) Log::note(ENTRY, s, p1, p2) #define LOG_4(s, p1, p2, p3) Log::note(ENTRY, s, p1, p2, p3) #define LOG_5(s, p1, p2, p3, p4) Log::note(ENTRY, s, p1, p2, p3, p4) #define LOG_X(x,s,p1,p2,p3,p4,FUNC, ...) FUNC #define LOG(...) LOG_X(,##__VA_ARGS__,\ LOG_5(__VA_ARGS__),\ LOG_4(__VA_ARGS__),\ LOG_3(__VA_ARGS__),\ LOG_2(__VA_ARGS__),\ LOG_1(__VA_ARGS__),\ LOG_0(__VA_ARGS__)\ )

 LOG("Appication started, version: %s (%s)", VERSION, BUILD_TYPE);

आउटपुट:

[एन] [इंट मुख्य (इंट, चार **)] मूल्यांकन शुरू किया, संस्करण: १.०.३ (RELEASE)

बंद

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

 void Mediator::wait_exit() { LOG("Set up waiting exit"); sigset_t set; int sig; sigemptyset(&set); sigaddset(&set, SIGINT); sigaddset(&set, SIGQUIT); sigaddset(&set, SIGTERM); sigaddset(&set, SIGTSTP); sigprocmask(SIG_BLOCK, &set, NULL); sigwait(&set, &sig); switch (sig) { case SIGINT: case SIGQUIT: case SIGTERM: case SIGTSTP: LOG("Catched signal to stopping application"); stop(); break; } }

केवल एक चीज जो आवश्यक है, वह मुख्य थ्रेड में प्रतीक्षा_एक्सिट () फ़ंक्शन को कॉल करना है, सभी सक्रिय कार्यों के पूरा होने के बाद।

  LOG("Appication started, version: %s (%s)", VERSION, BUILD_TYPE); { Mediator mediator; mediator.start(); mediator.wait_exit(); } LOG("Applicatiom stopped");

इन जरूरतों के लिए सिग्नल हैंडलर के गलत उपयोग की ओर इशारा करने के लिए मजीदी का धन्यवाद। मुझे आशा है कि मैंने आपके प्रस्ताव को सही ढंग से व्याख्यायित (कार्यान्वित) किया है।

अनुप्रयोग संरचना

तो हम अंतिम भाग के लिए मिला। जैसा कि यह पहले से ही कई के लिए स्पष्ट हो गया है, मैं "मध्यस्थ" पैटर्न का उपयोग करता हूं। बेशक, इसके सभी महिमा में नहीं, क्योंकि अभी तक कोई व्यावसायिक तर्क नहीं है।

 class Mediator: public Thread { public: Mediator(); virtual ~Mediator(); void wait_exit(); private: virtual void run(); void load_app_configuration(); void create_pid(); private: Pid pid_; };

यदि किसी कार्य को अलग थ्रेड में किया जाना चाहिए, तो ऐसे कार्य के लिए विशेष वर्ग थ्रेड से अलग वर्ग होना चाहिए।

 class Thread { public: void start() {th_ = boost::thread(boost::bind(&Thread::run, this));} void stop() {th_.interrupt(); th_.join();} virtual ~Thread(){} private: virtual void run() = 0; private: boost::thread th_; };

जिसका उद्देश्य सिंगल फॉर्मेट में स्टार्ट और स्टॉप प्रोसेस को सपोर्ट करना है।

कोष

परियोजना Google कोड में उपलब्ध है, लेकिन केवल पढ़ने के लिए। ऐसा इसलिए नहीं है क्योंकि मैं लालची हूं, मुझे नहीं पता कि सभी के लिए पहुंच कैसे खोलें। यदि आप परिवर्तन करना चाहते हैं, तो अपना जी-ईमेल लिखें, मैं आपको परियोजना में जोड़ दूंगा।

 svn checkout http://project-null.googlecode.com/svn/trunk/ project-null-read-only

कुछ शब्द ...

इस अनुभव को एक ठोस टेम्पलेट में बनाने का विचार लगभग दो महीने पहले आया था, अगली परियोजना की प्रक्रिया में, जिसे जल्दी से और खरोंच से साफ करने की आवश्यकता थी। परियोजना के लेखन के दौरान, मैं इस नतीजे पर पहुंचा कि यह पहली बार नहीं है कि मुझे इस तरह की वास्तुकला मिली है, और यह कि हर बार सभी नुकसानों को याद करने का कोई मतलब नहीं है और उसी समाधान पर आते हैं जो मैंने पहले इस्तेमाल किया था, आपको इसे एक टेम्पलेट के रूप में डिजाइन करने की आवश्यकता है। इस लेख को लिखने की सलाह से लंबे समय तक मुझे पीड़ा हुई, लेकिन शिक्षक और एक गिलास पानी के बारे में दृष्टांत को याद करते हुए, मैंने फैसला किया कि मेरे लिए यह कहना बेहतर होगा कि लेख एक पैसे के लायक नहीं है, क्योंकि मैं इसकी सलाह के बारे में सोचना जारी रखूंगा।

आपका ध्यान देने के लिए धन्यवाद।

पुनश्च। स्टार्टअप पर पीआईडी फ़ाइल के विभिन्न चेक जोड़े। मामलों को एक पीआईडी फ़ाइल के साथ संसाधित किया जाता है - कोई प्रक्रिया नहीं है, पीआईडी फ़ाइल खाली है।

पूरा प्रोजेक्ट