(ಚಿತ್ರದಿಂದ ರಿಂದ
ಹಾಯ್!
ನನ್ನ ಹೆಸರು ಎವ್ಗೆನಿ ಚೆರ್ಕಿನ್, ನಾನು ಗಣಿಗಾರಿಕೆ ಕಂಪನಿಯಲ್ಲಿ ಅಭಿವೃದ್ಧಿ ತಂಡದಲ್ಲಿ ಪ್ರೋಗ್ರಾಮರ್ ಆಗಿದ್ದೇನೆ ಪಾಲಿಮೆಟಲ್.
ಯಾವುದೇ ದೊಡ್ಡ ಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ, ನೀವು ಯೋಚಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ: "ಅದನ್ನು ನಿರ್ವಹಿಸಲು ಯಾವ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮ?" ಮುಂದಿನ ಆವೃತ್ತಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವ ಮೊದಲು ಐಟಿ ಯೋಜನೆಯು ಹಲವಾರು ಹಂತಗಳ ಮೂಲಕ ಹೋಗುತ್ತದೆ. ಈ ಹಂತಗಳ ಸರಪಳಿಯು ಸ್ವಯಂಚಾಲಿತವಾಗಿದ್ದಾಗ ಅದು ಒಳ್ಳೆಯದು. ಐಟಿ ಯೋಜನೆಯ ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವ ಸ್ವಯಂಚಾಲಿತ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ನಿರಂತರ ಇಂಟಿಗ್ರೇಷನ್. ಬಿಲ್ಡ್‌ಬಾಟ್ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಲ್ಲಿ ನಮಗೆ ಉತ್ತಮ ಸಹಾಯಕರಾಗಿ ಹೊರಹೊಮ್ಮಿದರು.
ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಸಾಧ್ಯತೆಗಳ ಅವಲೋಕನವನ್ನು ನೀಡಲು ನಿರ್ಧರಿಸಿದೆ ಬಿಲ್ಡ್‌ಬಾಟ್. ಈ ಸಾಫ್ಟ್ವೇರ್ ಏನು ಸಾಮರ್ಥ್ಯ ಹೊಂದಿದೆ? ಅವನನ್ನು ಹೇಗೆ ಸಂಪರ್ಕಿಸುವುದು ಮತ್ತು ಅವನೊಂದಿಗೆ ಸಾಮಾನ್ಯ ಪರಿಣಾಮಕಾರಿ ಕೆಲಸದ ಸಂಬಂಧವನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು? ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಕೆಲಸದ ಸೇವೆಯನ್ನು ರಚಿಸುವ ಮೂಲಕ ನಮ್ಮ ಅನುಭವವನ್ನು ನೀವೇ ಅನ್ವಯಿಸಬಹುದು.
ಪರಿವಿಡಿ
ಪರಿವಿಡಿ
1. ಬಿಲ್ಡ್‌ಬಾಟ್ ಏಕೆ?
ಹಿಂದೆ habr-e ನಲ್ಲಿ ನಾನು ಅನುಷ್ಠಾನದ ಬಗ್ಗೆ ಲೇಖನಗಳನ್ನು ನೋಡಿದೆ ನಿರಂತರ ಇಂಟಿಗ್ರೇಷನ್ ಬಳಸಲಾಗುತ್ತಿದೆ ಬಿಲ್ಡ್‌ಬಾಟ್. ಉದಾ, ನಾನು ಅದನ್ನು ಅತ್ಯಂತ ಮಾಹಿತಿಯುಕ್ತವಾಗಿ ಕಂಡುಕೊಂಡೆ. ಇನ್ನೊಂದು ಉದಾಹರಣೆ ಇದೆ - . ಈ ಲೇಖನಗಳನ್ನು ಮಸಾಲೆ ಮಾಡಬಹುದು ಮತ್ತು ಅದರ ನಂತರ, ಇಂಗ್ಲಿಷ್ನಲ್ಲಿ. ಕೂಪ್ ಉತ್ತಮ ಆರಂಭಿಕ ಹಂತವನ್ನು ಮಾಡುತ್ತದೆ. ಈ ಲೇಖನಗಳನ್ನು ಓದಿದ ನಂತರ, ನೀವು ಬಹುಶಃ ತಕ್ಷಣವೇ ಏನನ್ನಾದರೂ ಬಯಸುತ್ತೀರಿ ಬಿಲ್ಡ್‌ಬಾಟ್ ಮಾಡಬೇಕಾದದ್ದು.
ನಿಲ್ಲಿಸು! ಯಾರಾದರೂ ಅದನ್ನು ತಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ ಬಳಸಿದ್ದಾರೆಯೇ? ಇದು ಹೌದು ಎಂದು ತಿರುಗುತ್ತದೆ ಅದನ್ನು ತಮ್ಮ ಕಾರ್ಯಗಳಲ್ಲಿ ಅನ್ವಯಿಸಿದ್ದಾರೆ. ಕಾಣಬಹುದು ಬಳಕೆ ಬಿಲ್ಡ್‌ಬಾಟ್ ಮತ್ತು Google ಕೋಡ್ ಆರ್ಕೈವ್‌ಗಳಲ್ಲಿ.
ಹಾಗಾದರೆ ಜನರು ಬಳಸುವ ತರ್ಕವೇನು ಬಿಲ್ಡ್‌ಬಾಟ್? ಎಲ್ಲಾ ನಂತರ, ಇತರ ಸಾಧನಗಳಿವೆ: ಹಡಗು ನಿಯಂತ್ರಣ и ಜೆಂಕಿನ್ಸ್. ನಾನು ಈ ರೀತಿ ಉತ್ತರಿಸುತ್ತೇನೆ. ಹೆಚ್ಚಿನ ಕಾರ್ಯಗಳಿಗಾಗಿ ಜೆಂಕಿನ್ಸ್ ಮತ್ತು ಸತ್ಯವು ಸಾಕಷ್ಟು ಇರುತ್ತದೆ. ಅದರ ತಿರುವಿನಲ್ಲಿ, ಬಿಲ್ಡ್‌ಬಾಟ್ - ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಸಮಸ್ಯೆಗಳನ್ನು ಅಲ್ಲಿ ಸರಳವಾಗಿ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ ಜೆಂಕಿನ್ಸ್. ಆಯ್ಕೆ ನಿಮ್ಮದು. ಆದರೆ ಅಭಿವೃದ್ಧಿಶೀಲ ಗುರಿ ಯೋಜನೆಗಾಗಿ ನಾವು ಸಾಧನವನ್ನು ಹುಡುಕುತ್ತಿರುವುದರಿಂದ, ಸರಳ ಹಂತಗಳಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಸಂವಾದಾತ್ಮಕತೆ ಮತ್ತು ಅನನ್ಯ ಇಂಟರ್ಫೇಸ್ ಹೊಂದಿರುವ ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಪಡೆಯಲು ಅನುಮತಿಸುವ ಒಂದನ್ನು ಏಕೆ ಆರಿಸಬಾರದು.
ಗುರಿ ಯೋಜನೆಯು ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲ್ಪಟ್ಟವರಿಗೆ, ಪ್ರಶ್ನೆಯು ಉದ್ಭವಿಸುತ್ತದೆ: "ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಬಳಸಿದ ಭಾಷೆಯ ವಿಷಯದಲ್ಲಿ ಸ್ಪಷ್ಟವಾದ ಇಂಟರ್ಫೇಸ್ ಹೊಂದಿರುವ ಏಕೀಕರಣ ವ್ಯವಸ್ಥೆಯನ್ನು ಏಕೆ ಆಯ್ಕೆ ಮಾಡಬಾರದು?" ಮತ್ತು ಈಗ ಪ್ರಯೋಜನಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುವ ಸಮಯ ಬಿಲ್ಡ್‌ಬಾಟ್.
ಆದ್ದರಿಂದ, ನಮ್ಮ "ವಾದ್ಯ ಕ್ವಾರ್ಟೆಟ್". ನನಗಾಗಿ, ನಾನು ನಾಲ್ಕು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಗುರುತಿಸಿದ್ದೇನೆ ಬಿಲ್ಡ್‌ಬಾಟ್:
- ಇದು ಜಿಪಿಎಲ್ ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ತೆರೆದ ಮೂಲ ಚೌಕಟ್ಟಾಗಿದೆ
- ಇದು ಪೈಥಾನ್ ಅನ್ನು ಸಂರಚನಾ ಸಾಧನವಾಗಿ ಬಳಸುವುದು ಮತ್ತು ಅಗತ್ಯವಿರುವ ಕ್ರಿಯೆಗಳ ವಿವರಣೆಯಾಗಿದೆ
- ಅಸೆಂಬ್ಲಿ ನಡೆಯುವ ಯಂತ್ರದಿಂದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ಇದು ಒಂದು ಅವಕಾಶವಾಗಿದೆ
- ಇವುಗಳು, ಅಂತಿಮವಾಗಿ, ಹೋಸ್ಟ್‌ಗೆ ಕನಿಷ್ಠ ಅವಶ್ಯಕತೆಗಳಾಗಿವೆ. ನಿಯೋಜನೆಗೆ ಪೈಥಾನ್ ಮತ್ತು ತಿರುಚಿದ ಅಗತ್ಯವಿದೆ, ಮತ್ತು ವರ್ಚುವಲ್ ಯಂತ್ರ ಮತ್ತು ಜಾವಾ ಯಂತ್ರದ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.
2. ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ನೇತೃತ್ವದ ಪರಿಕಲ್ಪನೆ
ಕಾರ್ಯ ವಿತರಣಾ ವಾಸ್ತುಶಿಲ್ಪಕ್ಕೆ ಕೇಂದ್ರವಾಗಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್. ಇದು ಒಂದು ಸೇವೆಯಾಗಿದೆ:
- ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ ಯೋಜನೆಯ ಮೂಲ ಮರದಲ್ಲಿನ ಬದಲಾವಣೆಗಳು
- ಕಳುಹಿಸುತ್ತದೆ ಯೋಜನೆಯನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು ವರ್ಕರ್ ಸೇವೆಯಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಆಜ್ಞೆಗಳು
- ತಿಳಿಸುತ್ತದೆ ತೆಗೆದುಕೊಂಡ ಕ್ರಮಗಳ ಫಲಿತಾಂಶಗಳ ಬಗ್ಗೆ ಬಳಕೆದಾರರು
ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ಫೈಲ್ ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ master.cfg. ಈ ಫೈಲ್ ರೂಟ್‌ನಲ್ಲಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್. ಈ ಮೂಲವನ್ನು ಹೇಗೆ ರಚಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಾನು ನಂತರ ತೋರಿಸುತ್ತೇನೆ. ಫೈಲ್ ಸ್ವತಃ master.cfg ಕರೆಗಳನ್ನು ಬಳಸುವ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ ಬಿಲ್ಡ್‌ಬಾಟ್.
ಮುಂದಿನ ಪ್ರಮುಖ ವಸ್ತು ಬಿಲ್ಡ್‌ಬಾಟ್ ಒಂದು ಹೆಸರನ್ನು ಹೊಂದಿದೆ ವರ್ಕರ್. ಈ ಸೇವೆಯನ್ನು ಮತ್ತೊಂದು ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಬೇರೆ OS ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು, ಅಥವಾ ಬಹುಶಃ ಅಲ್ಲಿ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್. ಇದು ತನ್ನದೇ ಆದ ಪ್ಯಾಕೇಜುಗಳು ಮತ್ತು ವೇರಿಯೇಬಲ್‌ಗಳೊಂದಿಗೆ ವಿಶೇಷವಾಗಿ ಸಿದ್ಧಪಡಿಸಲಾದ ವರ್ಚುವಲ್ ಪರಿಸರದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರಬಹುದು. ಪೈಥಾನ್ ಉಪಯುಕ್ತತೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಈ ವರ್ಚುವಲ್ ಪರಿಸರಗಳನ್ನು ತಯಾರಿಸಬಹುದು ವರ್ಚುಲೆನ್ವಿ, ವೆನ್ವಿ.
ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ಎಲ್ಲರಿಗೂ ಆಜ್ಞೆಗಳನ್ನು ಪ್ರಸಾರ ಮಾಡುತ್ತದೆ ವರ್ಕರ್-y, ಮತ್ತು ಅವನು, ಪ್ರತಿಯಾಗಿ, ಅವುಗಳನ್ನು ಪೂರೈಸುತ್ತಾನೆ. ಅಂದರೆ, ಯೋಜನೆಯನ್ನು ನಿರ್ಮಿಸುವ ಮತ್ತು ಪರೀಕ್ಷಿಸುವ ಪ್ರಕ್ರಿಯೆಯು ಮುಂದುವರಿಯಬಹುದು ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ ವರ್ಕರ್-e ವಿಂಡೋಸ್ ಚಾಲನೆಯಲ್ಲಿದೆ ಮತ್ತು ಲಿನಕ್ಸ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಮತ್ತೊಂದು ವರ್ಕರ್‌ನಲ್ಲಿ.
ಚೆಕ್ಔಟ್ ಯೋಜನೆಯ ಮೂಲ ಕೋಡ್‌ಗಳು ಪ್ರತಿಯೊಂದರಲ್ಲೂ ಸಂಭವಿಸುತ್ತವೆ ವರ್ಕರ್-ಇ.
3. ಅನುಸ್ಥಾಪನೆ
ಆದ್ದರಿಂದ, ಹೋಗೋಣ. ನಾನು ಉಬುಂಟು 18.04 ಅನ್ನು ಹೋಸ್ಟ್ ಆಗಿ ಬಳಸುತ್ತಿದ್ದೇನೆ. ನಾನು ಅದರ ಮೇಲೆ ಒಂದನ್ನು ಇಡುತ್ತೇನೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ ಮತ್ತು ಒಂದು ವರ್ಕರ್-ಎ. ಆದರೆ ಮೊದಲು ನೀವು python3.7 ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ:
sudo apt-get update
sudo apt-get install python3.7
3.7.2 ಬದಲಿಗೆ python3.7.1 ಅಗತ್ಯವಿರುವವರಿಗೆ, ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡಬಹುದು:
sudo apt-get update
sudo apt-get software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt-get install python3.7
sudo ln -fs /usr/bin/python3.7 /usr/bin/python3
pip3 install --upgrade pip
ಮುಂದಿನ ಹಂತವು ಸ್ಥಾಪಿಸುವುದು ಎಂದು ಟ್ವೀಟ್ ಮಾಡಿದ್ದಾರೆ и ಬಿಲ್ಡ್‌ಬಾಟ್, ಹಾಗೆಯೇ ಹೆಚ್ಚುವರಿ ಕಾರ್ಯವನ್ನು ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಪ್ಯಾಕೇಜುಗಳು ಬಿಲ್ಡ್‌ಬಾಟ್-ದಿ.
/*Все что под sudo будет установленно для всех пользователей в директорию /usr/local/lib/python3.7/dist-packages*/
#На хосте который производит мониторинг Worker-ов
sudo pip install twisted #Библиотека twisted
sudo pip install buildbot #BuildMaster
#Дополнительный функционал
pip install pysqlite3 #Устанавливаем базу sqllite в учебных целях
pip install jinja2 #framework наподобие django, для web и для почтовых рассыллок
pip install autobahn #Web cокеты для связи BuildMaster->Worker
pip install sqlalchemy sqlalchemy-migrate #Для отображения схемы базы данных
#Для Web отображения BuildBot-a
pip install buildbot-www buildbot-grid-view buildbot-console-view buildbot-waterfall-view
pip install python-dateutil #Отображение дат в web
#На стороне хоста который непосредственно осуществляет сборку и тестирование
pip install buildbot-worker #Worker
#Дополнительный функционал
sudo pip install virtualenv #Виртуальная среда
4. ಮೊದಲ ಹಂತಗಳು
ರಚಿಸಲು ಸಮಯ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್. ಅದು ನಮ್ಮ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಇರುತ್ತದೆ /ಮನೆ/ಹಬ್ರ್/ಮಾಸ್ಟರ್.
mkdir master
buildbot create-master master # Собственно сдесь и создаемಮುಂದಿನ ನಡೆ. ರಚಿಸೋಣ ವರ್ಕರ್. ಅದು ನಮ್ಮ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಇರುತ್ತದೆ /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ.
mkdir worker
buildbot-worker create-worker --umask=0o22 --keepalive=60 worker localhost:4000 yourWorkerName password
ನೀವು ಓಡಿದಾಗ ವರ್ಕರ್, ನಂತರ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅದು ರಚಿಸುತ್ತದೆ /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ ಯೋಜನೆಯ ಹೆಸರಿನೊಂದಿಗೆ ಫೋಲ್ಡರ್, ಇದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ master.cfg. ಮತ್ತು ಯೋಜನೆಯ ಹೆಸರಿನ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಅದು ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತದೆ ನಿರ್ಮಿಸಲು, ಮತ್ತು ಅದನ್ನು ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ ಚೆಕ್ಔಟ್. ಗಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೈರೆಕ್ಟರಿ ವರ್ಕರ್-ಮತ್ತು ಇದು ಡೈರೆಕ್ಟರಿ ಆಗುತ್ತದೆ /home/habr/yourProject/build.
"ಗೋಲ್ಡನ್ ಕೀ
ಮತ್ತು ಈಗ ನಾನು ಹಿಂದಿನ ಪ್ಯಾರಾಗ್ರಾಫ್ ಅನ್ನು ಏನು ಬರೆದಿದ್ದೇನೆ: ಒಂದು ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಸ್ಟರ್ ನಿಂದ ಬೇಡಿಕೆ ಇಡುತ್ತಾರೆ ವರ್ಕರ್-ಮತ್ತು ಈ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ರಿಮೋಟ್ ಆಗಿ ಮಾಡಿದರೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಸ್ಕ್ರಿಪ್ಟ್ ಚಲಾಯಿಸಲು ಹಕ್ಕುಗಳನ್ನು ಹೊಂದಿಲ್ಲ. ಪರಿಸ್ಥಿತಿಯನ್ನು ಸರಿಪಡಿಸಲು, ನಿಮಗೆ ಒಂದು ಕೀ ಬೇಕಾಗುತ್ತದೆ --umask=0o22, ಇದು ಈ ಡೈರೆಕ್ಟರಿಗೆ ಬರೆಯುವುದನ್ನು ನಿಷೇಧಿಸುತ್ತದೆ, ಆದರೆ ಉಡಾವಣಾ ಹಕ್ಕುಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಮತ್ತು ನಮಗೆ ಬೇಕಾಗಿರುವುದು ಅಷ್ಟೆ.
ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ и ವರ್ಕರ್ ಪರಸ್ಪರ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಿ. ಅದು ಒಡೆಯುತ್ತದೆ ಮತ್ತು ಸಂಭವಿಸುತ್ತದೆ ವರ್ಕರ್ ನಿಂದ ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿ ಸ್ವಲ್ಪ ಸಮಯ ಕಾಯುತ್ತಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ. ಯಾವುದೇ ಪ್ರತಿಕ್ರಿಯೆ ಇಲ್ಲದಿದ್ದರೆ, ಸಂಪರ್ಕವನ್ನು ಮರುಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. ಕೀ --keepalive=60 ಅದರ ನಂತರದ ಸಮಯವನ್ನು ಸೂಚಿಸುವ ಅಗತ್ಯವಿದೆ ಸಂಪರ್ಕ ರೀಬೂಟ್‌ಗಳು.
5. ಸಂರಚನೆ. ಹಂತ ಹಂತದ ಪಾಕವಿಧಾನ
ಸಂರಚನೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ನಾವು ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಯಂತ್ರದ ಬದಿಯಲ್ಲಿ ನಡೆಸಲಾಗುತ್ತದೆ ರಚಿಸಿ-ಮಾಸ್ಟರ್. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಡೈರೆಕ್ಟರಿಯಾಗಿದೆ /ಮನೆ/ಹಬ್ರ್/ಮಾಸ್ಟರ್. ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ master.cfg ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ, ಆದರೆ ಆಜ್ಞೆಯು ಈಗಾಗಲೇ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿದೆ master.cmg.ಮಾದರಿ. ನೀವು ಅದನ್ನು ಮರುಹೆಸರಿಸುವ ಅಗತ್ಯವಿದೆ master.cfg.samp в master.cfg
mv master.cfg.sample master.cfgಇದನ್ನು ತೆರೆಯೋಣ master.cfg. ಮತ್ತು ಅದು ಏನು ಒಳಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ. ಮತ್ತು ಅದರ ನಂತರ, ನಮ್ಮದೇ ಆದ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸೋಣ.
master.cfg
c['change_source'] = []
c['change_source'].append(changes.GitPoller(
'git://github.com/buildbot/hello-world.git',
workdir='gitpoller-workdir', branch='master',
pollInterval=300))
c['schedulers'] = []
c['schedulers'].append(schedulers.SingleBranchScheduler(
name="all",
change_filter=util.ChangeFilter(branch='master'),
treeStableTimer=None,
builderNames=["runtests"]))
c['schedulers'].append(schedulers.ForceScheduler(
name="force",
builderNames=["runtests"]))
factory = util.BuildFactory()
factory.addStep(steps.Git(repourl='git://github.com/buildbot/hello-world.git', mode='incremental'))
factory.addStep(steps.ShellCommand(command=["trial", "hello"],
env={"PYTHONPATH": "."}))
c['builders'] = []
c['builders'].append(
util.BuilderConfig(name="runtests",
workernames=["example-worker"],
factory=factory))
c['services'] = []
c['title'] = "Hello World CI"
c['titleURL'] = "https://buildbot.github.io/hello-world/"
c['buildbotURL'] = "http://localhost:8010/"
c['www'] = dict(port=8010,
plugins=dict(waterfall_view={}, console_view={}, grid_view={}))
c['db'] = {
'db_url' : "sqlite:///state.sqlite",
}
5.1 ಬಿಲ್ಡ್ಮಾಸ್ಟರ್ ಕಾನ್ಫಿಗ್
c = BuildmasterConfig = {} ಬಿಲ್ಡ್ಮಾಸ್ಟರ್ ಕಾನ್ಫಿಗ್ - ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನ ಮೂಲ ನಿಘಂಟು. ಇದನ್ನು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನಲ್ಲಿ ಸೇರಿಸಬೇಕು. ಬಳಕೆಯ ಸುಲಭತೆಗಾಗಿ, ಸಂರಚನಾ ಕೋಡ್‌ನಲ್ಲಿ ಅಲಿಯಾಸ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಗಿದೆ "ಸಿ". ಶೀರ್ಷಿಕೆಗಳು в c["keyFromDist"] ಪರಸ್ಪರ ಕ್ರಿಯೆಗೆ ಸ್ಥಿರ ಅಂಶಗಳಾಗಿವೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್. ಪ್ರತಿ ಕೀಲಿಗಾಗಿ, ಅನುಗುಣವಾದ ವಸ್ತುವನ್ನು ಮೌಲ್ಯವಾಗಿ ಬದಲಿಸಲಾಗುತ್ತದೆ.
5.2 ಕಾರ್ಮಿಕರು
c['workers'] = [worker.Worker("example-worker", "pass")]ಈ ಬಾರಿ ನಾವು ಸೂಚಿಸುತ್ತೇವೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-y ಪಟ್ಟಿ ವರ್ಕರ್-ರು. ನಾನೇ ವರ್ಕರ್ ನಾವು ರಚಿಸಿದ್ದೇವೆ , ಸೂಚಿಸುತ್ತದೆ ನೀವು-ಕೆಲಸಗಾರ-ಹೆಸರು и ಪಾಸ್ವರ್ಡ್. ಈಗ ಅವರು ಬದಲಿಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿದೆ ಉದಾಹರಣೆಗೆ ಕೆಲಸಗಾರ и ಉತ್ತೀರ್ಣ .
5.3 change_source
c['change_source'] = []
c['change_source'].append(changes.GitPoller(
'git://github.com/buildbot/hello-world.git',
workdir='gitpoller-workdir', branch='master',
pollInterval=300))
ಕೀಲಿಯಿಂದ ಬದಲಾವಣೆ_ಮೂಲ ನಿಘಂಟು c ಪ್ರಾಜೆಕ್ಟ್‌ನ ಮೂಲ ಕೋಡ್‌ನೊಂದಿಗೆ ರೆಪೊಸಿಟರಿಯನ್ನು ಪೋಲ್ ಮಾಡುವ ವಸ್ತುವನ್ನು ಇರಿಸಲು ನಾವು ಬಯಸುವ ಪಟ್ಟಿಗೆ ನಾವು ಪ್ರವೇಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಉದಾಹರಣೆಯು Git ರೆಪೊಸಿಟರಿಯನ್ನು ಬಳಸುತ್ತದೆ, ಅದು ಕೆಲವು ಮಧ್ಯಂತರಗಳಲ್ಲಿ ಪೋಲ್ ಮಾಡಲ್ಪಡುತ್ತದೆ.
ಮೊದಲ ವಾದವು ನಿಮ್ಮ ರೆಪೊಸಿಟರಿಯ ಮಾರ್ಗವಾಗಿದೆ.
ಕೆಲಸಗಾರ ಬದಿಯಲ್ಲಿರುವ ಫೋಲ್ಡರ್‌ಗೆ ಮಾರ್ಗವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ವರ್ಕರ್- ಮಾರ್ಗಕ್ಕೆ ಸಂಬಂಧಿ /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ/ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್/ಬಿಲ್ಡ್ git ರೆಪೊಸಿಟರಿಯ ಸ್ಥಳೀಯ ಆವೃತ್ತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.
ಶಾಖೆ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಶಾಖೆಯನ್ನು ಹೊಂದಿದೆ ಅದನ್ನು ಅನುಸರಿಸಬೇಕು.
ಮತದಾನ ಮಧ್ಯಂತರ ಅದರ ನಂತರದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ಬದಲಾವಣೆಗಳಿಗಾಗಿ ರೆಪೊಸಿಟರಿಯನ್ನು ಪೋಲ್ ಮಾಡುತ್ತದೆ.
ಪ್ರಾಜೆಕ್ಟ್‌ನ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಹಲವಾರು ವಿಧಾನಗಳಿವೆ.
ಸರಳವಾದ ವಿಧಾನವೆಂದರೆ ಮತದಾನ, ಇದು ಸೂಚಿಸುತ್ತದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ನಿಯತಕಾಲಿಕವಾಗಿ ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಸರ್ವರ್ ಅನ್ನು ಸಮೀಕ್ಷೆ ಮಾಡುತ್ತದೆ. ಒಂದು ವೇಳೆ ಬದ್ಧತೆ ರೆಪೊಸಿಟರಿಯಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ಸ್ವಲ್ಪ ವಿಳಂಬದೊಂದಿಗೆ ಆಂತರಿಕ ವಸ್ತುವನ್ನು ರಚಿಸುತ್ತದೆ ಬದಲಾವಣೆ ಮತ್ತು ಅದನ್ನು ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ಕಳುಹಿಸಿ ವೇಳಾಪಟ್ಟಿ, ಇದು ಯೋಜನೆಯನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಹಂತಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ವರ್ಕರ್-ಇ. ಈ ಹಂತಗಳಲ್ಲಿ ಸೂಚಿಸಲಾಗುವುದು ಅಪ್ಡೇಟ್ ಭಂಡಾರ. ನಿಖರವಾಗಿ ಆನ್ ವರ್ಕರ್ಇದು ರೆಪೊಸಿಟರಿಯ ಸ್ಥಳೀಯ ನಕಲನ್ನು ರಚಿಸುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯ ವಿವರಗಳನ್ನು ಮುಂದಿನ ಎರಡು ವಿಭಾಗಗಳಲ್ಲಿ ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ( и ).
ರೆಪೊಸಿಟರಿಯ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಇನ್ನೂ ಹೆಚ್ಚು ಸೊಗಸಾದ ವಿಧಾನವೆಂದರೆ ಅದನ್ನು ಹೋಸ್ಟ್ ಮಾಡುವ ಸರ್ವರ್‌ನಿಂದ ನೇರವಾಗಿ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುವುದು ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್- ಯೋಜನೆಯ ಮೂಲ ಕೋಡ್‌ಗಳನ್ನು ಬದಲಾಯಿಸುವ ಬಗ್ಗೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಡೆವಲಪರ್ ಮಾಡಿದ ತಕ್ಷಣ ಬದ್ಧತೆ, ಪ್ರಾಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿಯನ್ನು ಹೊಂದಿರುವ ಸರ್ವರ್ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ವೈ. ಮತ್ತು ಅವನು ಪ್ರತಿಯಾಗಿ, ವಸ್ತುವನ್ನು ರಚಿಸುವ ಮೂಲಕ ಅದನ್ನು ಪ್ರತಿಬಂಧಿಸುತ್ತಾನೆ PBCchangeSource. ಮುಂದೆ, ಈ ವಸ್ತುವನ್ನು ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ ವೇಳಾಪಟ್ಟಿ, ಇದು ಯೋಜನೆಯನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು ಹಂತಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಈ ವಿಧಾನದ ಒಂದು ಪ್ರಮುಖ ಭಾಗವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಕೊಕ್ಕೆ- ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸರ್ವರ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು. ಲಿಪಿಯಲ್ಲಿ ಕೊಕ್ಕೆ-a, ಯಾವಾಗ ಪ್ರಕ್ರಿಯೆಯ ಕ್ರಿಯೆಗಳಿಗೆ ಜವಾಬ್ದಾರರು ಬದ್ಧತೆ-ಇ, ನೀವು ಉಪಯುಕ್ತತೆಯನ್ನು ಕರೆಯಬೇಕಾಗಿದೆ ಕಳುಹಿಸಿ ಬದಲಾವಣೆ ಮತ್ತು ನೆಟ್ವರ್ಕ್ ವಿಳಾಸವನ್ನು ಸೂಚಿಸಿ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ. ನೀವು ಕೇಳುವ ನೆಟ್ವರ್ಕ್ ಪೋರ್ಟ್ ಅನ್ನು ಸಹ ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು PBCchangeSource. PBCchangeSource, ಮೂಲಕ, ಭಾಗವಾಗಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ. ಈ ವಿಧಾನಕ್ಕೆ ಅನುಮತಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ ನಿರ್ವಹಣೆಪ್ರಾಜೆಕ್ಟ್ ರೆಪೊಸಿಟರಿ ಇರುವ ಸರ್ವರ್‌ನಲ್ಲಿ -a. ನೀವು ಮೊದಲು ರೆಪೊಸಿಟರಿಯ ಬ್ಯಾಕಪ್ ಮಾಡಬೇಕಾಗಿದೆ.
5.4 ಶೆಡ್ಯೂಲರ್‌ಗಳು
c['schedulers'] = []
c['schedulers'].append(schedulers.SingleBranchScheduler(
name="all",
change_filter=util.ChangeFilter(branch='master'),
treeStableTimer=None,
builderNames=["runtests"]))
c['schedulers'].append(schedulers.ForceScheduler(
name="force",
builderNames=["runtests"]))
ಶೆಡ್ಯೂಲರ್‌ಗಳು - ಇದು ಯೋಜನೆಯ ಸಂಪೂರ್ಣ ಜೋಡಣೆ ಮತ್ತು ಪರೀಕ್ಷೆಯ ಸರಪಳಿಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಪ್ರಚೋದಕವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಒಂದು ಅಂಶವಾಗಿದೆ.
ಆ ಬದಲಾವಣೆಗಳನ್ನು ದಾಖಲಿಸಲಾಗಿದೆ ಬದಲಾವಣೆ_ಮೂಲ, ಕೆಲಸದ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ರೂಪಾಂತರಗೊಳ್ಳುತ್ತದೆ ಬಿಲ್ಡ್‌ಬಾಟ್-ಆಬ್ಜೆಕ್ಟ್ ಮಾಡಲು ಬದಲಾವಣೆ ಮತ್ತು ಈಗ ಪ್ರತಿ ಶೆಡ್ಯೂಲರ್ ಅವುಗಳ ಆಧಾರದ ಮೇಲೆ, ಇದು ಯೋಜನೆಯ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ವಿನಂತಿಗಳನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ವಿನಂತಿಗಳನ್ನು ಸರದಿಯಲ್ಲಿ ಮತ್ತಷ್ಟು ವರ್ಗಾಯಿಸಿದಾಗ ಅದು ನಿರ್ಧರಿಸುತ್ತದೆ. ಒಂದು ವಸ್ತು ಬಿಲ್ಡರ್ ವಿನಂತಿಗಳ ಸರದಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಜೋಡಣೆಯ ಸ್ಥಿತಿಯನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ ವರ್ಕರ್-ಇ. ಬಿಲ್ಡರ್ ಮೇಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಇ ಮತ್ತು ಮೇಲೆ ವರ್ಕರ್-ಇ. ಜೊತೆಗೆ ಕಳುಹಿಸುತ್ತಾನೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಒಂದು ವರ್ಕರ್- ಮತ್ತು ಈಗಾಗಲೇ ನಿರ್ದಿಷ್ಟ ನಿರ್ಮಿಸಲು - ಅನುಸರಿಸಬೇಕಾದ ಹಂತಗಳ ಸರಣಿ.
ಪ್ರಸ್ತುತ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ನೋಡುತ್ತೇವೆ ಶೆಡ್ಯೂಲರ್‌ಗಳು 2 ತುಣುಕುಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ. ಇದಲ್ಲದೆ, ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿದೆ.
SingleBranchScheduler - ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ತರಗತಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಇದು ಒಂದು ಶಾಖೆಯನ್ನು ವೀಕ್ಷಿಸುತ್ತದೆ ಮತ್ತು ಅದರಲ್ಲಿ ದಾಖಲಾದ ಬದಲಾವಣೆಯಿಂದ ಪ್ರಚೋದಿಸಲ್ಪಡುತ್ತದೆ. ಅವನು ಬದಲಾವಣೆಗಳನ್ನು ನೋಡಿದಾಗ, ಅವನು ಬಿಲ್ಡ್ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುವುದನ್ನು ವಿಳಂಬಗೊಳಿಸಬಹುದು (ವಿಶೇಷ ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅವಧಿಗೆ ಮುಂದೂಡಿ ಟ್ರೀ ಸ್ಟೇಬಲ್ ಟೈಮರ್) IN ಹೆಸರು ಪ್ರದರ್ಶಿಸಲಾಗುವ ವೇಳಾಪಟ್ಟಿಯ ಹೆಸರನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಬಿಲ್ಡ್‌ಬಾಟ್- ವೆಬ್ ಇಂಟರ್ಫೇಸ್. IN ಚೇಂಜ್ ಫಿಲ್ಟರ್ ಫಿಲ್ಟರ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ, ಅದನ್ನು ಹಾದುಹೋದ ನಂತರ ಶಾಖೆಯಲ್ಲಿ ಬದಲಾವಣೆಗಳು ನಿರ್ಮಾಣಕ್ಕಾಗಿ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲು ವೇಳಾಪಟ್ಟಿಯನ್ನು ಕೇಳುತ್ತವೆ. IN ಬಿಲ್ಡರ್ ಹೆಸರುಗಳು ಹೆಸರನ್ನು ಸೂಚಿಸಲಾಗಿದೆ ಬಿಲ್ಡರ್-a, ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಹೊಂದಿಸುತ್ತೇವೆ. ನಮ್ಮ ಪ್ರಕರಣದಲ್ಲಿನ ಹೆಸರು ಯೋಜನೆಯ ಹೆಸರಿನಂತೆಯೇ ಇರುತ್ತದೆ: ನಿಮ್ಮ ಯೋಜನೆ.
ಫೋರ್ಸ್ ಶೆಡ್ಯೂಲರ್ ಬಹಳ ಸರಳವಾದ ವಿಷಯ. ಈ ರೀತಿಯ ವೇಳಾಪಟ್ಟಿಯನ್ನು ಮೌಸ್ ಕ್ಲಿಕ್ ಮೂಲಕ ಪ್ರಚೋದಿಸಲಾಗುತ್ತದೆ ಬಿಲ್ಡ್‌ಬಾಟ್- ವೆಬ್ ಇಂಟರ್ಫೇಸ್. ನಿಯತಾಂಕಗಳು ನಲ್ಲಿನಂತೆಯೇ ಅದೇ ಸಾರವನ್ನು ಹೊಂದಿವೆ SingleBranchScheduler.
PS ಸಂಖ್ಯೆ 3. ಬಹುಶಃ ಇದು ಸೂಕ್ತವಾಗಿ ಬರುತ್ತದೆ
ಆವರ್ತಕ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯ-ನಿಶ್ಚಿತ ಆವರ್ತನದಲ್ಲಿ ನಡೆಯುವ ವೇಳಾಪಟ್ಟಿಯಾಗಿದೆ. ಕರೆ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ
from buildbot.plugins import schedulers
nightly = schedulers.Periodic(name="daily",
builderNames=["full-solaris"],
periodicBuildTimer=24*60*60)
c['schedulers'] = [nightly]
5.5 ಬಿಲ್ಡ್ ಫ್ಯಾಕ್ಟರಿ
factory = util.BuildFactory()
factory.addStep(steps.Git(repourl='git://github.com/buildbot/hello-world.git', mode='incremental'))
factory.addStep(steps.ShellCommand(command=["trial", "hello"],
env={"PYTHONPATH": "."}))
ಆವರ್ತಕ ಬಿಲ್ಡ್ಟೈಮರ್ ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಈ ಆವರ್ತಕತೆಯ ಸಮಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
ಬಿಲ್ಡ್ ಫ್ಯಾಕ್ಟರಿ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ ನಿರ್ಮಿಸಲು, ಅದು ನಂತರ ಬಿಲ್ಡರ್ ಗೆ ಕಳುಹಿಸುತ್ತದೆ ವರ್ಕರ್. ದಿ ಬಿಲ್ಡ್ ಫ್ಯಾಕ್ಟರಿ ಅನುಸರಿಸಬೇಕಾದ ಕ್ರಮಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ವರ್ಕರ್-ವೈ. ವಿಧಾನವನ್ನು ಕರೆಯುವ ಮೂಲಕ ಹಂತಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ addStep
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಮೊದಲ ಸೇರಿಸಲಾಗಿದೆ ಹಂತ git ಕ್ಲೀನ್ -d -f -f -x, ನಂತರ git ಚೆಕ್ out ಟ್. ಈ ಕ್ರಿಯೆಗಳನ್ನು ಪ್ಯಾರಾಮೀಟರ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ ವಿಧಾನ, ಇದು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಲಾಗಿಲ್ಲ ಆದರೆ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ ತಾಜಾ. ಪ್ಯಾರಾಮೀಟರ್ ಮೋಡ್='ಹೆಚ್ಚುವರಿ' ಫೈಲ್‌ಗಳು ಡೈರೆಕ್ಟರಿಯಿಂದ ಬಂದಿವೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಚೆಚೌಟ್, ರೆಪೊಸಿಟರಿಯಿಂದ ಕಾಣೆಯಾಗಿರುವಾಗ, ಅಸ್ಪೃಶ್ಯವಾಗಿ ಉಳಿಯಿರಿ.
ಎರಡನೇ ಸೇರಿಸಿದ ಹಂತವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕರೆಯುತ್ತಿದೆ ಪ್ರಯೋಗ ನಿಯತಾಂಕದೊಂದಿಗೆ ಹಲೋ ಬದಿಯಲ್ಲಿ ವರ್ಕರ್ಡೈರೆಕ್ಟರಿಯಿಂದ -a /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ/ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್/ಬಿಲ್ಡ್ ಪರಿಸರ ವೇರಿಯೇಬಲ್ PATHONPATH =... ಹೀಗೆ, ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಬದಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ವರ್ಕರ್- ಪ್ರತಿ ಹೆಜ್ಜೆ util.ShellCommand. ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ನೇರವಾಗಿ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇರಿಸಬಹುದು. ನಂತರ ನಲ್ಲಿ ಚೆಚೌಟ್-ಇ ಅವರು ಬೀಳುತ್ತಾರೆ /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ/ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್/ಬಿಲ್ಡ್. ಆದಾಗ್ಯೂ, ನಂತರ ಎರಡು "ಆದರೆ" ಇವೆ:
- ವರ್ಕರ್ ಕೀಲಿಯೊಂದಿಗೆ ರಚಿಸಬೇಕು ಆದ್ದರಿಂದ ಅದು ನಂತರ ಮರಣದಂಡನೆ ಹಕ್ಕುಗಳನ್ನು ನಿರ್ಬಂಧಿಸುವುದಿಲ್ಲ ಚೆಕ್ಔಟ್-ದಿ.
- ನಲ್ಲಿ ಜಿಟ್ ಪುಶ್ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ -e ನೀವು ಆಸ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿದೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದಆದ್ದರಿಂದ ನಂತರ ಚೆಚೌಟ್-e Git ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಹಕ್ಕನ್ನು ಕಳೆದುಕೊಂಡಿಲ್ಲ.
5.6 ಬಿಲ್ಡರ್‌ಗಳು
c['builders'] = []
c['builders'].append(util.BuilderConfig(name="runtests",
workernames=["example-worker"],
factory=factory))
ಏನು ಎಂಬುದರ ಬಗ್ಗೆ ಬಿಲ್ಡರ್ ತಿಳಿಸಲಾಯಿತು . ಅದನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಈಗ ನಾನು ನಿಮಗೆ ಹೆಚ್ಚು ವಿವರವಾಗಿ ಹೇಳುತ್ತೇನೆ. ಬಿಲ್ಡರ್ ಕಾನ್ಫಿಗ್ ನಿರ್ಮಾಣಕಾರರಾಗಿದ್ದಾರೆ ಬಿಲ್ಡರ್. ಅಂತಹ ವಿನ್ಯಾಸಕರು ಸಿ['ಬಿಲ್ಡರ್ಸ್'] ಇದು ವಸ್ತುಗಳ ಹಾಳೆಯಾಗಿರುವುದರಿಂದ ನೀವು ಹಲವಾರು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಬಿಲ್ಡರ್ ಮಾದರಿ. ಈಗ ನಾವು ಉದಾಹರಣೆಯನ್ನು ಪುನಃ ಬರೆಯೋಣ ಬಿಲ್ಡ್‌ಬಾಟ್, ಅದನ್ನು ನಮ್ಮ ಕಾರ್ಯಕ್ಕೆ ಹತ್ತಿರ ತರುವುದು.
c['builders'] = []
c['builders'].append(util.BuilderConfig(name="yourProject",
workernames=["yourWorkerName"],
factory=factory))
ಈಗ ನಾನು ನಿಯತಾಂಕಗಳ ಬಗ್ಗೆ ಹೇಳುತ್ತೇನೆ ಬಿಲ್ಡರ್ ಕಾನ್ಫಿಗ್.
ಹೆಸರು ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ ಬಿಲ್ಡರ್-ಎ. ಇಲ್ಲಿ ನಾವು ಹೆಸರಿಸಿದೆವು ನಿಮ್ಮ ಯೋಜನೆ... ಇದರರ್ಥ ಆನ್ ಆಗಿದೆ ವರ್ಕರ್- ಈ ಮಾರ್ಗವನ್ನು ರಚಿಸಲಾಗುವುದು /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ/ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್/ಬಿಲ್ಡ್. ಶೆಡ್ಯೂಲರ್ ಹುಡುಕುವುದು ಬಿಲ್ಡರ್ ಕೇವಲ ಈ ಹೆಸರಿನಿಂದ.
ಕಾರ್ಮಿಕರ ಹೆಸರುಗಳು ಹಾಳೆಯನ್ನು ಒಳಗೊಂಡಿದೆ ವರ್ಕರ್-ರು. ಪ್ರತಿಯೊಂದನ್ನು ಸೇರಿಸಬೇಕು ಸಿ['ಕೆಲಸಗಾರರು'].
ಕಾರ್ಖಾನೆಯ - ನಿರ್ದಿಷ್ಟ ನಿರ್ಮಿಸಲು, ಇದು ಸಂಬಂಧಿಸಿದೆ ಬಿಲ್ಡರ್. ಅವನು ವಸ್ತುವನ್ನು ಕಳುಹಿಸುತ್ತಾನೆ ನಿರ್ಮಿಸಲು ಮೇಲೆ ವರ್ಕರ್ ಇದರಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ನಿರ್ಮಿಸಲು-ದಿ.
6. ನಿಮ್ಮ ಸ್ವಂತ ಸಂರಚನೆಯ ಉದಾಹರಣೆ
ಮೂಲಕ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾನು ಪ್ರಸ್ತಾಪಿಸುವ ಪ್ರಾಜೆಕ್ಟ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ ಬಿಲ್ಡ್‌ಬಾಟ್
.
ನಾವು ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಯಾಗಿ ಬಳಸುತ್ತೇವೆ svn. ರೆಪೊಸಿಟರಿಯು ಕೆಲವು ರೀತಿಯ ಮೋಡದಲ್ಲಿ ನೆಲೆಗೊಂಡಿದೆ. ಈ ಮೋಡದ ವಿಳಾಸ ಇಲ್ಲಿದೆ . ಕೆಳಗಿನ ಮೋಡದಲ್ಲಿ svn ಖಾತೆಯ ಬಳಕೆದಾರಹೆಸರು ಇದೆ: ಬಳಕೆದಾರ, ಪಾಸ್ವರ್ಡ್: ಪಾಸ್ವರ್ಡ್. ಹಂತಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ನಿರ್ಮಿಸಲು-a ಸಹ ಶಾಖೆಯಲ್ಲಿ ಇರುತ್ತದೆ svn, ಪ್ರತ್ಯೇಕ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಬಿಲ್ಡ್‌ಬಾಟ್/ವರ್ಕರ್_ಲಿನಕ್ಸ್. ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಉಳಿಸಿದ ಆಸ್ತಿಯೊಂದಿಗೆ ರೆಪೊಸಿಟರಿಯಲ್ಲಿವೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ.
ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ и ವರ್ಕರ್ ಅದೇ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಿ project.host .ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್ ಅದರ ಫೈಲ್‌ಗಳನ್ನು ಫೋಲ್ಡರ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ /ಮನೆ/ಹಬ್ರ್/ಮಾಸ್ಟರ್. ವರ್ಕರ್ ಇದನ್ನು ಕೆಳಗಿನ ಮಾರ್ಗದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ /ಮನೆ/ಹಬ್ರ್/ಕೆಲಸಗಾರ. ಪ್ರಕ್ರಿಯೆ ಸಂವಹನ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ ಮತ್ತು ವರ್ಕರ್-a ಪ್ರೋಟೋಕಾಲ್ ಪ್ರಕಾರ ಪೋರ್ಟ್ 4000 ಮೂಲಕ ನಡೆಸಲಾಗುತ್ತದೆ ಬಿಲ್ಡ್‌ಬಾಟ್-ಎ, ಅಂದರೆ 'pb' ಶಿಷ್ಟಾಚಾರ.
ಗುರಿ ಯೋಜನೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪೈಥಾನ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಕಾರ್ಯವು ಅದರ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಅನ್ನು ರಚಿಸುವುದು, ದಸ್ತಾವೇಜನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸುವುದು. ವೈಫಲ್ಯದ ಸಂದರ್ಭದಲ್ಲಿ, ಎಲ್ಲಾ ಡೆವಲಪರ್‌ಗಳು ವಿಫಲವಾದ ಕ್ರಮವಿದೆ ಎಂದು ಇಮೇಲ್ ಮೂಲಕ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ.
ವೆಬ್ ಪ್ರದರ್ಶನ ಬಿಲ್ಡ್‌ಬಾಟ್ ನಾವು ಪೋರ್ಟ್ 80 ಗೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ project.host. Apatch ಅನ್ನು ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಗ್ರಂಥಾಲಯದ ಭಾಗವಾಗಿ ತಿರುಚಿದ ಈಗಾಗಲೇ ವೆಬ್ ಸರ್ವರ್ ಇದೆ, ಬಿಲ್ಡ್‌ಬಾಟ್ ಅದನ್ನು ಬಳಸುತ್ತದೆ.
ಆಂತರಿಕ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಿಲ್ಡ್‌ಬಾಟ್ использовать ಸ್ಕ್ಲೈಟ್.
ಮೇಲಿಂಗ್‌ಗೆ ಹೋಸ್ಟ್ ಅಗತ್ಯವಿದೆ smtp.your.domain - ಇದು ಮೇಲ್ನಿಂದ ಪತ್ರಗಳನ್ನು ಕಳುಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ [ಇಮೇಲ್ ರಕ್ಷಿಸಲಾಗಿದೆ] ದೃಢೀಕರಣವಿಲ್ಲದೆ. ಹೋಸ್ಟ್‌ನಲ್ಲಿಯೂ ಸಹSMTP ಪೋಸ್ಟ್ 1025 ರಲ್ಲಿ ನಿಮಿಷಗಳನ್ನು ಕೇಳಲಾಗುತ್ತಿದೆ.
ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ತೊಡಗಿರುವ ಇಬ್ಬರು ಜನರಿದ್ದಾರೆ: ನಿರ್ವಹಣೆ и ಬಳಕೆದಾರ. ನಿರ್ವಾಹಕರು ನಿರ್ವಾಹಕರು ಬಿಲ್ಡ್‌ಬಾಟ್. ಬಳಕೆದಾರನು ಮಾಡುವ ವ್ಯಕ್ತಿ ಬದ್ಧತೆ-ರು.
ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಫೈಲ್ ಅನ್ನು ಇದರ ಮೂಲಕ ರಚಿಸಲಾಗಿದೆ ಪೈನ್‌ಸ್ಟಾಲರ್. ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ಮೂಲಕ ರಚಿಸಲಾಗಿದೆ ಡಾಕ್ಸಿಜನ್.
ಈ ವಾಸ್ತುಶಿಲ್ಪಕ್ಕಾಗಿ ನಾನು ಇದನ್ನು ಬರೆದಿದ್ದೇನೆ: master.cfg:
master.cfg
import os, re
from buildbot.plugins import steps, util, schedulers, worker, changes, reporters
c= BuildmasterConfig ={}
c['workers'] = [ worker.Worker('yourWorkerName', 'password') ]
c['protocols'] = {'pb': {'port': 4000}}
svn_poller = changes.SVNPoller(repourl="https://svn.host/svn/yourProject/trunk",
svnuser="user",
svnpasswd="password",
pollinterval=60,
split_file=util.svn.split_file_alwaystrunk
)
c['change_source'] = svn_poller
hourlyscheduler = schedulers.SingleBranchScheduler(
name="your-project-schedulers",
change_filter=util.ChangeFilter(branch=None),
builderNames=["yourProject"],
properties = {'owner': 'admin'}
)
c['schedulers'] = [hourlyscheduler]
checkout = steps.SVN(repourl='https://svn.host/svn/yourProject/trunk',
mode='full',
method='fresh',
username="user",
password="password",
haltOnFailure=True)
projectHost_build = util.BuildFactory()
cleanProject = steps.ShellCommand(name="Clean",
command=["buildbot/worker_linux/pyinstaller_project", "clean"]
)
buildProject = steps.ShellCommand(name="Build",
command=["buildbot/worker_linux/pyinstaller_project", "build"]
)
doxyProject = steps.ShellCommand(name="Update Docs",
command=["buildbot/worker_linux/gendoc", []]
)
testProject = steps.ShellCommand(name="Tests",
command=["python","tests/utest.py"],
env={'PYTHONPATH': '.'}
)
projectHost_build.addStep(checkout)
projectHost_build.addStep(cleanProject)
projectHost_build.addStep(buildProject)
projectHost_build.addStep(doxyProject)
projectHost_build.addStep(testProject)
c['builders'] = [
util.BuilderConfig(name="yourProject", workername='yourWorkerName', factory=projectHost_build)
]
template_html=u'''
<h4>Статус построенного релиза: {{ summary }}</h4>
<p>Используемый сервис для постраения: {{ workername }}</p>
<p>Проект: {{ projects }}</p>
<p>Для того что бы посмотреть интерфейс управления пройдите по ссылке: {{ buildbot_url }}</p>
<p>Для того что бы посмотреть результат сборки пройдите по ссылке: {{ build_url }}</p>
<p>Используя WinSCP можно подключиться к серверу c ip:xxx.xx.xxx.xx. Войдя под habr/password, забрать собранный executable файл с директории ~/worker/yourProject/build/dist.</p>
<p><b>Построение было произведено через Buildbot</b></p>
'''
sendMessageToAll = reporters.MailNotifier(fromaddr="[email protected]",
sendToInterestedUsers=True,
lookup="your.domain",
relayhost="smtp.your.domain",
smtpPort=1025,
mode="warnings",
extraRecipients=['[email protected]'],
messageFormatter=reporters.MessageFormatter(
template=template_html,
template_type='html',
wantProperties=True,
wantSteps=True)
)
c['services'] = [sendMessageToAll]
c['title'] = "The process of bulding"
c['titleURL'] = "http://project.host:80/"
c['buildbotURL'] = "http://project.host"
c['www'] = dict(port=80,
plugins=dict(waterfall_view={}, console_view={}, grid_view={}))
c['db'] = {
'db_url' : "sqlite:///state.sqlite"
}
ಮೊದಲು ನಿಮಗೆ ಬೇಕು ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ ಮತ್ತು ವರ್ಕರ್-ಎ. ನಂತರ ಈ ಫೈಲ್ ಅನ್ನು ಅಂಟಿಸಿ master.cfg в /ಮನೆ/ಹಬ್ರ್/ಮಾಸ್ಟರ್.
ಸೇವೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್aa
sudo buildbot start /home/habr/master
ನಂತರ ಸೇವೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿ ವರ್ಕರ್-a
buildbot-worker start /home/habr/worker
ಸಿದ್ಧವಾಗಿದೆ! ಈಗ ಬಿಲ್ಡ್‌ಬಾಟ್ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರಚೋದಿಸುತ್ತದೆ ಬದ್ಧತೆ-ವೈ ಇನ್ svn, ಮೇಲಿನ ವಾಸ್ತುಶೈಲಿಯೊಂದಿಗೆ ಯೋಜನೆಯನ್ನು ನಿರ್ಮಿಸುವ ಮತ್ತು ಪರೀಕ್ಷಿಸುವ ಹಂತಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು.
ಮೇಲಿನ ಕೆಲವು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನಾನು ಕೆಳಗೆ ವಿವರಿಸುತ್ತೇನೆ master.cfg.
6.1 ನಿಮ್ಮ master.cfg ಗೆ ಹೋಗುವ ದಾರಿಯಲ್ಲಿ
ಬರೆಯುವಾಗ ನನ್ನ master.cfg ಅನೇಕ ದೋಷಗಳನ್ನು ಮಾಡಲಾಗುವುದು, ಆದ್ದರಿಂದ ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಓದುವುದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಎಂದು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಇಸಿ ಸಂಪೂರ್ಣ ಮಾರ್ಗ /home/habr/master/twistd.log, ಮತ್ತು ಬದಿಯಲ್ಲಿ ವರ್ಕರ್-a ಸಂಪೂರ್ಣ ಮಾರ್ಗದೊಂದಿಗೆ /home/habr/worker/twistd.log. ನೀವು ದೋಷವನ್ನು ಓದಿದಾಗ ಮತ್ತು ಅದನ್ನು ಸರಿಪಡಿಸಿದಾಗ, ನೀವು ಸೇವೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ ಬಿಲ್ಡ್ ಮಾಸ್ಟರ್-ಎ. ಇದನ್ನು ಹೇಗೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
sudo buildbot stop /home/habr/master
sudo buildbot upgrade-master /home/habr/master
sudo buildbot start /home/habr/master
6.2 svn ಜೊತೆ ಕೆಲಸ
svn_poller = changes.SVNPoller(repourl="https://svn.host/svn/yourProject/trunk",
svnuser="user",
svnpasswd="password",
pollinterval=60,
split_file=util.svn.split_file_alwaystrunk
)
c['change_source'] = svn_poller
hourlyscheduler = schedulers.SingleBranchScheduler(
name="your-project-schedulers",
change_filter=util.ChangeFilter(branch=None),
builderNames=["yourProject"],
properties = {'owner': 'admin'}
)
c['schedulers'] = [hourlyscheduler]
checkout = steps.SVN(repourl='https://svn.host/svn/yourProject/trunk',
mode='full',
method='fresh',
username="user",
password="password",
haltOnFailure=True)
ಮೊದಲಿಗೆ, ನಾವು ನೋಡೋಣ svn_poller. ಇದು ಇನ್ನೂ ಅದೇ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ, ನಿಯಮಿತವಾಗಿ ರೆಪೊಸಿಟರಿಯನ್ನು ನಿಮಿಷಕ್ಕೊಮ್ಮೆ ಪೋಲಿಂಗ್ ಮಾಡುತ್ತದೆ. ಈ ವಿಷಯದಲ್ಲಿ svn_poller ಶಾಖೆಯನ್ನು ಮಾತ್ರ ಪ್ರವೇಶಿಸುತ್ತದೆ ಕಾಂಡ. ನಿಗೂಢ ನಿಯತಾಂಕ split_file=util.svn.split_file_alwaystrunk ನಿಯಮಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ: ಫೋಲ್ಡರ್ ರಚನೆಯನ್ನು ಹೇಗೆ ಒಡೆಯುವುದು svn ಶಾಖೆಗಳ ಮೇಲೆ. ಅವರು ಅವರಿಗೆ ಸಂಬಂಧಿತ ಮಾರ್ಗಗಳನ್ನು ಸಹ ನೀಡುತ್ತಾರೆ. ಅದರ ತಿರುವಿನಲ್ಲಿ ಸ್ಪ್ಲಿಟ್_ಫೈಲ್_ಯಾವಾಗಲೂ ಸ್ಟ್ರಂಕ್ ರೆಪೊಸಿಟರಿಯು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ ಎಂದು ಹೇಳುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಕಾಂಡ.
В ವೇಳಾಪಟ್ಟಿಗಳು ಸೂಚಿಸಲಾಗಿದೆ ಚೇಂಜ್ ಫಿಲ್ಟರ್ಯಾರು ನೋಡುತ್ತಾರೆ ಯಾವುದೂ ಮತ್ತು ಅದರೊಂದಿಗೆ ಶಾಖೆಯನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ ಕಾಂಡ ಮೂಲಕ ನೀಡಿದ ಸಂಘದ ಪ್ರಕಾರ ಸ್ಪ್ಲಿಟ್_ಫೈಲ್_ಯಾವಾಗಲೂ ಸ್ಟ್ರಂಕ್. ಬದಲಾವಣೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವುದು ಕಾಂಡ, ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಬಿಲ್ಡರ್ ಹೆಸರಿನೊಂದಿಗೆ ನಿಮ್ಮ ಯೋಜನೆ.
ಗುಣಗಳು ಇಲ್ಲಿ ಇದು ಅಗತ್ಯವಿದೆ ಆದ್ದರಿಂದ ನಿರ್ವಾಹಕರು ಪ್ರಕ್ರಿಯೆಯ ಮಾಲೀಕರಂತೆ ನಿರ್ಮಾಣ ಮತ್ತು ಪರೀಕ್ಷಾ ಫಲಿತಾಂಶಗಳ ಮೇಲಿಂಗ್ ಪಟ್ಟಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾರೆ.
ಹಂತ ನಿರ್ಮಿಸಲು-a ಚೆಕ್ಔಟ್ ರೆಪೊಸಿಟರಿಯ ಸ್ಥಳೀಯ ಆವೃತ್ತಿಯಲ್ಲಿರುವ ಯಾವುದೇ ಫೈಲ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅಳಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ ವರ್ಕರ್-ಎ. ತದನಂತರ ಪೂರ್ಣ ಮಾಡಿ svn ನವೀಕರಣ. ಮೋಡ್ ಅನ್ನು ನಿಯತಾಂಕದ ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ ಮೋಡ್=ಪೂರ್ಣ, ವಿಧಾನ = ತಾಜಾ. ಪ್ಯಾರಾಮೀಟರ್ haltOnTailure ವೇಳೆ ಎಂದು ಹೇಳುತ್ತಾರೆ svn ನವೀಕರಣ ದೋಷದೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಕಟ್ಟಡ ಮತ್ತು ಪರೀಕ್ಷೆಯ ಸಂಪೂರ್ಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅಮಾನತುಗೊಳಿಸಬೇಕು, ಏಕೆಂದರೆ ಮುಂದಿನ ಕ್ರಮಗಳು ಅರ್ಥವಿಲ್ಲ.
6.3 ನಿಮಗೆ ಪತ್ರ: ವರದಿಗಾರರು ಘೋಷಿಸಲು ಅಧಿಕಾರ ಹೊಂದಿದ್ದಾರೆ
ವರದಿಗಾರರು ಇಮೇಲ್ ಮೂಲಕ ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುವ ಸೇವೆಯಾಗಿದೆ.
template_html=u'''
<h4>Статус построенного релиза: {{ summary }}</h4>
<p>Используемый сервис для постраения: {{ workername }}</p>
<p>Проект: {{ projects }}</p>
<p>Для того что бы посмотреть интерфейс управления пройдите по ссылке: {{ buildbot_url }}</p>
<p>Для того что бы посмотреть результат сборки пройдите по ссылке: {{ build_url }}</p>
<p>Используя WinSCP можно подключиться к серверу c ip:xxx.xx.xxx.xx. Войдя под habr/password, забрать собранный executable файл с директории ~/worker/yourProject/build/dist.</p>
<p><b>Построение было произведено через Buildbot</b></p>
'''
sendMessageToAll = reporters.MailNotifier(fromaddr="[email protected]",
sendToInterestedUsers=True,
lookup="your.domain",
relayhost="smtp.your.domain",
smtpPort=1025,
mode="warnings",
extraRecipients=['[email protected]'],
messageFormatter=reporters.MessageFormatter(
template=template_html,
template_type='html',
wantProperties=True,
wantSteps=True)
)
c['services'] = [sendMessageToAll]
ಅವನು ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಬಹುದು .
ಮೇಲ್ನೋಟಿಫೈಯರ್ ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸಲು ಇಮೇಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
ಟೆಂಪ್ಲೇಟ್_html ಸುದ್ದಿಪತ್ರಕ್ಕಾಗಿ ಪಠ್ಯ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಮಾರ್ಕ್ಅಪ್ ರಚಿಸಲು HTML ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಎಂಜಿನ್ನಿಂದ ಮಾರ್ಪಡಿಸಲ್ಪಟ್ಟಿದೆ (ಇದರೊಂದಿಗೆ ಹೋಲಿಸಬಹುದು ಜಾಂಗೊ). ಬಿಲ್ಡ್‌ಬಾಟ್ ಸಂದೇಶ ಪಠ್ಯವನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಟೆಂಪ್ಲೇಟ್‌ನಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಿಸುವ ವೇರಿಯಬಲ್‌ಗಳ ಗುಂಪನ್ನು ಹೊಂದಿದೆ. ಈ ಅಸ್ಥಿರಗಳನ್ನು {{ ಡಬಲ್ ಕರ್ಲಿ ಬ್ರೇಸ್‌ಗಳು }} ನಲ್ಲಿ ಸುತ್ತುವರಿಯಲಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಸಾರಾಂಶ ಪೂರ್ಣಗೊಂಡ ಕಾರ್ಯಾಚರಣೆಗಳ ಸ್ಥಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಅಂದರೆ, ಯಶಸ್ಸು ಅಥವಾ ವೈಫಲ್ಯ. ಎ ಯೋಜನೆಗಳು ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ ನಿಮ್ಮ ಯೋಜನೆ. ಆದ್ದರಿಂದ, ನಿಯಂತ್ರಣ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿ ಜಿಂಜಾ2, ಅಸ್ಥಿರ ಬಿಲ್ಡ್‌ಬಾಟ್-a ಮತ್ತು ಪೈಥಾನ್ ಸ್ಟ್ರಿಂಗ್ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಪರಿಕರಗಳು, ನೀವು ಸಾಕಷ್ಟು ತಿಳಿವಳಿಕೆ ಸಂದೇಶವನ್ನು ರಚಿಸಬಹುದು.
ಮೇಲ್ನೋಟಿಫೈಯರ್ ಕೆಳಗಿನ ವಾದಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ಇಂದ - ಪ್ರತಿಯೊಬ್ಬರೂ ಸುದ್ದಿಪತ್ರವನ್ನು ಸ್ವೀಕರಿಸುವ ವಿಳಾಸ.
ಆಸಕ್ತಿ ಹೊಂದಿರುವ ಬಳಕೆದಾರರಿಗೆ ಕಳುಹಿಸಿ=True ಮಾಡಿದ ಮಾಲೀಕರು ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಬದ್ಧತೆ.
ಮೇಲೆ ನೋಡು - ಸುದ್ದಿಪತ್ರವನ್ನು ಸ್ವೀಕರಿಸುವ ಬಳಕೆದಾರರ ಹೆಸರುಗಳಿಗೆ ಸೇರಿಸಬೇಕಾದ ಪ್ರತ್ಯಯ. ಆದ್ದರಿಂದ ನಿರ್ವಹಣೆ ಬಳಕೆದಾರರು ವಿಳಾಸದಲ್ಲಿ ಸುದ್ದಿಪತ್ರವನ್ನು ಹೇಗೆ ಸ್ವೀಕರಿಸುತ್ತಾರೆ [ಇಮೇಲ್ ರಕ್ಷಿಸಲಾಗಿದೆ].
ರಿಲೇಹೋಸ್ಟ್ ಸರ್ವರ್ ತೆರೆಯಲಾದ ಹೋಸ್ಟ್ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ SMTPಒಂದು smptPort ಆಲಿಸುವ ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ SMTP ಸರ್ವರ್
ಮೋಡ್="ಎಚ್ಚರಿಕೆ" ಕನಿಷ್ಠ ಒಂದು ಹೆಜ್ಜೆ ಇದ್ದರೆ ಮಾತ್ರ ಮೇಲಿಂಗ್ ಮಾಡಬೇಕು ಎಂದು ಹೇಳುತ್ತಾರೆ ನಿರ್ಮಿಸಲು-a, ಇದು ಸ್ಥಿತಿ ವೈಫಲ್ಯ ಅಥವಾ ಎಚ್ಚರಿಕೆಯೊಂದಿಗೆ ಕೊನೆಗೊಂಡಿತು. ಯಶಸ್ಸಿನ ಸಂದರ್ಭದಲ್ಲಿ, ಸುದ್ದಿಪತ್ರವನ್ನು ಕಳುಹಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
ಹೆಚ್ಚುವರಿ ಸ್ವೀಕರಿಸುವವರು ಮಾಲೀಕರು ಮತ್ತು ನಿರ್ವಹಿಸಿದ ವ್ಯಕ್ತಿಗೆ ಹೆಚ್ಚುವರಿಯಾಗಿ ಮೇಲಿಂಗ್ ಕಳುಹಿಸಬೇಕಾದ ವ್ಯಕ್ತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಒಳಗೊಂಡಿದೆ ಬದ್ಧತೆ.
ಸಂದೇಶ ಫಾರ್ಮ್ಯಾಟರ್ ಸಂದೇಶದ ಸ್ವರೂಪ, ಅದರ ಟೆಂಪ್ಲೇಟ್ ಮತ್ತು ಲಭ್ಯವಿರುವ ಅಸ್ಥಿರಗಳ ಗುಂಪನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ವಸ್ತುವಾಗಿದೆ ಜಿಂಜಾ2. ಮುಂತಾದ ಆಯ್ಕೆಗಳು ಬಯಸುವ ಪ್ರಾಪರ್ಟೀಸ್ = ನಿಜ и ಬಯಸುವ ಹಂತಗಳು=ನಿಜ ಲಭ್ಯವಿರುವ ಅಸ್ಥಿರಗಳ ಈ ಸೆಟ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ.
ಜೊತೆಗೆ['ಸೇವೆಗಳು']=[sendMessageToAll] ಸೇವೆಗಳ ಪಟ್ಟಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅದರಲ್ಲಿ ನಮ್ಮದು ವರದಿಗಾರ.
ನಾವು ಮಾಡಿದೆವು! ಅಭಿನಂದನೆಗಳು
ನಾವು ನಮ್ಮದೇ ಆದ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದು ಸಮರ್ಥವಾಗಿರುವ ಕಾರ್ಯವನ್ನು ನೋಡಿದೆವು. ಬಿಲ್ಡ್‌ಬಾಟ್. ನಿಮ್ಮ ಯೋಜನೆಯನ್ನು ರಚಿಸಲು ಈ ಉಪಕರಣವು ಅಗತ್ಯವಿದೆಯೇ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಇದು ಸಾಕು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನೀವು ಅವನ ಬಗ್ಗೆ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೀರಾ? ಇದು ನಿಮಗೆ ಉಪಯುಕ್ತವಾಗಿದೆಯೇ? ಅವನು ಕೆಲಸ ಮಾಡಲು ಆರಾಮದಾಯಕವೇ? ಹಾಗಾದರೆ ನಾನು ಈ ಲೇಖನವನ್ನು ವ್ಯರ್ಥವಾಗಿ ಬರೆಯುತ್ತಿಲ್ಲ.
ಮತ್ತು ಮುಂದೆ. ನಾನು ವೃತ್ತಿಪರ ಸಮುದಾಯವನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೇನೆ ಬಿಲ್ಡ್‌ಬಾಟ್, ವಿಶಾಲವಾಯಿತು, ಕೈಪಿಡಿಗಳನ್ನು ಅನುವಾದಿಸಲಾಗಿದೆ ಮತ್ತು ಇನ್ನೂ ಹೆಚ್ಚಿನ ಉದಾಹರಣೆಗಳಿವೆ.
ನಿಮ್ಮ ಗಮನಕ್ಕೆ ಎಲ್ಲರಿಗೂ ಧನ್ಯವಾದಗಳು. ಒಳ್ಳೆಯದಾಗಲಿ.
ಮೂಲ: www.habr.com