BuildBot સાથે સતત એકીકરણનું ઉદાહરણ અમલીકરણ

(ચિત્ર દ્વારા કોમ્પ્યુટરાઇઝર થી Pixabay)

હેલો!

મારું નામ છે એવજેની ચેર્કિન, હું ખાણકામ કંપનીમાં વિકાસ ટીમમાં પ્રોગ્રામર છું પોલિમેટલ.

કોઈપણ મોટો પ્રોજેક્ટ શરૂ કરતી વખતે, તમે વિચારવાનું શરૂ કરો છો: "તેને જાળવવા માટે કયા સોફ્ટવેરનો ઉપયોગ કરવો શ્રેષ્ઠ છે?" આગલું સંસ્કરણ બહાર પાડતા પહેલા IT પ્રોજેક્ટ સંખ્યાબંધ તબક્કાઓમાંથી પસાર થાય છે. જ્યારે આ તબક્કાઓની સાંકળ સ્વયંસંચાલિત હોય ત્યારે તે સારું છે. આઇટી પ્રોજેક્ટના નવા સંસ્કરણને પ્રકાશિત કરવાની સ્વયંસંચાલિત પ્રક્રિયા કહેવામાં આવે છે સતત એકીકરણ. બિલ્ડબોટ આ પ્રક્રિયાના અમલીકરણમાં અમારા માટે સારો સહાયક બન્યો.

આ લેખમાં મેં શક્યતાઓની ઝાંખી આપવાનું નક્કી કર્યું છે બિલ્ડબોટ. આ સોફ્ટવેર શું સક્ષમ છે? તેની સાથે કેવી રીતે સંપર્ક કરવો અને તેની સાથે સામાન્ય અસરકારક કાર્ય સંબંધ કેવી રીતે બનાવવો? તમે તમારા મશીન પર તમારા પ્રોજેક્ટના નિર્માણ અને પરીક્ષણ માટે કાર્યકારી સેવા બનાવીને અમારો અનુભવ જાતે લાગુ કરી શકો છો.

અનુક્રમણિકા

અનુક્રમણિકા

1. શા માટે બિલ્ડબોટ?
2. બિલ્ડમાસ્ટરની આગેવાની હેઠળનો ખ્યાલ
3. સ્થાપન
4. પ્રથમ પગલાં

5. રૂપરેખાંકન. સ્ટેપ બાય સ્ટેપ રેસીપી

5.1 BuildmasterConfig
5.2 કામદારો
5.3 ફેરફાર_સ્રોત
5.4 શેડ્યુલર્સ

5.5 બિલ્ડ ફેક્ટરી
5.6 બિલ્ડરો

6. તમારી પોતાની ગોઠવણીનું ઉદાહરણ

6.1 તમારા master.cfg ના માર્ગ પર
6.2 svn સાથે કામ કરવું
6.3 તમને પત્ર: પત્રકારો જાહેર કરવા માટે અધિકૃત છે

અમે તે કર્યું! અભિનંદન

1. શા માટે બિલ્ડબોટ?

અગાઉ habr-e પર મને અમલીકરણ વિશેના લેખો મળ્યા સતત એકીકરણ ઉપયોગ કરીને બિલ્ડબોટ. દાખ્લા તરીકે, આ એક મને તે સૌથી માહિતીપ્રદ લાગ્યું. બીજું ઉદાહરણ છે - સરળ. આ લેખો અનુભવી શકાય છે મેન્યુઅલમાંથી ઉદાહરણઅને તે તે પછી, અંગ્રેજીમાં. કૂપ એક સારો પ્રારંભિક બિંદુ બનાવે છે. આ લેખો વાંચ્યા પછી, તમને કદાચ તરત જ કંઈક જોઈએ છે બિલ્ડબોટ શું કરવું.

બંધ! શું કોઈએ ખરેખર તેનો ઉપયોગ તેમના પ્રોજેક્ટ્સમાં કર્યો છે? તે હા બહાર વળે છે ઘણા તેને તેમના કાર્યોમાં લાગુ કરો. મળી શકે છે ઉદાહરણો использования બિલ્ડબોટ અને Google કોડ આર્કાઇવ્સમાં.

તો લોકો શું તર્ક વાપરે છે બિલ્ડબોટ? છેવટે, ત્યાં અન્ય સાધનો છે: ક્રુઝ નિયંત્રણ и જેનકિન્સ. હું આ રીતે જવાબ આપીશ. મોટા ભાગના કાર્યો માટે જેનકિન્સ અને સત્ય પૂરતું હશે. તેના બદલામાં, બિલ્ડબોટ - વધુ અનુકૂલનશીલ, જ્યારે સમસ્યાઓ ત્યાં જેટલી સરળ રીતે ઉકેલવામાં આવે છે જેનકિન્સ. પસંદગી તમારી છે. પરંતુ અમે વિકાસશીલ લક્ષ્ય પ્રોજેક્ટ માટે એક સાધન શોધી રહ્યા હોવાથી, શા માટે સરળ પગલાઓથી શરૂ કરીને, ક્રિયાપ્રતિક્રિયા અને અનન્ય ઇન્ટરફેસ ધરાવતી બિલ્ડ સિસ્ટમ મેળવવા માટે પરવાનગી આપે તેવું એક પસંદ ન કરો.

જેમનો ટાર્ગેટ પ્રોજેક્ટ અજગરમાં લખાયેલો છે, તેમના માટે પ્રશ્ન ઊભો થાય છે: "પ્રોજેક્ટમાં વપરાતી ભાષાના સંદર્ભમાં સ્પષ્ટ ઇન્ટરફેસ ધરાવતી એકીકરણ સિસ્ટમ કેમ પસંદ ન કરવી?" અને હવે લાભો રજૂ કરવાનો સમય છે બિલ્ડબોટ.

તેથી, અમારી "વાદ્ય ચોકડી". મારા માટે, મેં ચાર લક્ષણો ઓળખ્યા છે બિલ્ડબોટ:

1. તે GPL લાયસન્સ હેઠળ એક ઓપન સોર્સ ફ્રેમવર્ક છે
2. આ રૂપરેખાંકન સાધન તરીકે પાયથોનનો ઉપયોગ અને જરૂરી ક્રિયાઓનું વર્ણન છે
3. જે મશીન પર એસેમ્બલી થાય છે તેમાંથી પ્રતિસાદ મેળવવાની આ એક તક છે
4. આ, છેવટે, યજમાન માટેની ન્યૂનતમ આવશ્યકતાઓ છે. જમાવટ માટે પાયથોન અને ટ્વિસ્ટેડની જરૂર છે, અને વર્ચ્યુઅલ મશીન અને જાવા મશીનની જરૂર નથી.

2. બિલ્ડમાસ્ટરની આગેવાની હેઠળનો ખ્યાલ

કાર્ય વિતરણ આર્કિટેક્ચરમાં કેન્દ્રિય છે બિલ્ડમાસ્ટર. તે એક સેવા છે જે:

• ટ્રેક રાખે છે પ્રોજેક્ટ સ્ત્રોત વૃક્ષમાં ફેરફારો
• મોકલે છે આદેશો કે જે પ્રોજેક્ટ બનાવવા અને તેનું પરીક્ષણ કરવા માટે કાર્યકર સેવા દ્વારા અમલમાં મૂકવા જોઈએ
• સૂચિત કરે છે લેવામાં આવેલા પગલાંના પરિણામો વિશે વપરાશકર્તાઓ

બિલ્ડમાસ્ટર ફાઇલ દ્વારા ગોઠવેલ master.cfg. આ ફાઇલ રૂટમાં છે બિલ્ડમાસ્ટર. પછી હું બતાવીશ કે આ રુટ કેવી રીતે બને છે. ફાઇલ પોતે master.cfg એક પાયથોન સ્ક્રિપ્ટ ધરાવે છે જે કૉલ્સનો ઉપયોગ કરે છે બિલ્ડબોટ.

આગામી સૌથી મહત્વપૂર્ણ પદાર્થ બિલ્ડબોટ એક નામ છે કામદાર. આ સેવાને અન્ય હોસ્ટ પર અલગ OS સાથે અથવા કદાચ એક પર લોંચ કરી શકાય છે બિલ્ડમાસ્ટર. તે તેના પોતાના પેકેજો અને ચલો સાથે ખાસ તૈયાર વર્ચ્યુઅલ વાતાવરણમાં પણ અસ્તિત્વ ધરાવે છે. આ વર્ચ્યુઅલ વાતાવરણને પાયથોન યુટિલિટીઝનો ઉપયોગ કરીને તૈયાર કરી શકાય છે virtualenv, venv.

બિલ્ડમાસ્ટર દરેકને આદેશોનું પ્રસારણ કરે છે કામદાર-y, અને તે, બદલામાં, તેમને પરિપૂર્ણ કરે છે. એટલે કે, તે તારણ આપે છે કે પ્રોજેક્ટ બનાવવા અને પરીક્ષણ કરવાની પ્રક્રિયા ચાલુ થઈ શકે છે કામદાર-e વિન્ડોઝ ચલાવી રહ્યા છે અને Linux ચલાવતા અન્ય વર્કર પર.

ચેકઆઉટ પ્રોજેક્ટ સ્ત્રોત કોડ દરેક પર થાય છે કામદાર-e.

3. સ્થાપન

તો, ચાલો જઈએ. હું યજમાન તરીકે ઉબુન્ટુ 18.04 નો ઉપયોગ કરીશ. હું તેના પર એક મૂકીશ બિલ્ડમાસ્ટર-એ અને એક કામદાર-a પરંતુ પ્રથમ તમારે 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. પ્રથમ પગલાં

બનાવવાનો સમય બિલ્ડમાસ્ટર. તે અમારા ફોલ્ડરમાં હશે /home/habr/master.

mkdir master
buildbot create-master master # Собственно сдесь и создаем

આગળનું પગલું. ચાલો બનાવીએ કામદાર. તે અમારા ફોલ્ડરમાં હશે /home/habr/worker.

mkdir worker
buildbot-worker create-worker --umask=0o22 --keepalive=60 worker localhost:4000 yourWorkerName password

જ્યારે તમે ચલાવો છો કામદાર, પછી મૂળભૂત રીતે તે માં બનાવશે /home/habr/worker પ્રોજેક્ટના નામ સાથે ફોલ્ડર, જેમાં ઉલ્લેખિત છે master.cfg. અને પ્રોજેક્ટના નામ સાથેના ફોલ્ડરમાં તે ડિરેક્ટરી બનાવશે બિલ્ડ કરો, અને તે કરવાનું ચાલુ રાખશે ચેકઆઉટ. માટે કાર્યકારી નિર્દેશિકા કામદાર-અને તે ડિરેક્ટરી બની જશે /home/habr/yourProject/build.

"ગોલ્ડન કી
અને હવે મેં પાછલો ફકરો જેના માટે લખ્યો છે: એક સ્ક્રિપ્ટ કે જે માસ્ટર પાસેથી માંગણી કરશે કામદાર-અને આ નિર્દેશિકામાં દૂરસ્થ રીતે કરવામાં આવશે તે ચલાવવામાં આવશે નહીં કારણ કે સ્ક્રિપ્ટને ચલાવવાના અધિકારો નથી. પરિસ્થિતિને સુધારવા માટે, તમારે કીની જરૂર પડશે --umask=0o22, જે આ નિર્દેશિકામાં લખવા પર પ્રતિબંધ મૂકે છે, પરંતુ લોન્ચ અધિકારો જાળવી રાખશે. અને તે જ આપણને જોઈએ છે.

બિલ્ડમાસ્ટર и કામદાર એકબીજા સાથે જોડાણ સ્થાપિત કરો. એવું બને છે કે તે તૂટી જાય છે અને કામદાર તરફથી પ્રતિસાદ માટે થોડો સમય રાહ જુઓ બિલ્ડમાસ્ટર-એ. જો ત્યાં કોઈ પ્રતિસાદ નથી, તો કનેક્શન પુનઃપ્રારંભ થાય છે. કી --keepalive=60 ફક્ત તે પછીનો સમય સૂચવવા માટે જરૂરી છે જોડાવા રીબૂટ

5. રૂપરેખાંકન. સ્ટેપ બાય સ્ટેપ રેસીપી

રૂપરેખાંકન બિલ્ડમાસ્ટર મશીનની બાજુએ હાથ ધરવામાં આવે છે જ્યાં અમે આદેશનો અમલ કર્યો હતો સર્જન-માસ્ટર. અમારા કિસ્સામાં, આ એક ડિરેક્ટરી છે /home/habr/master. રૂપરેખાંકન ફાઇલ master.cfg હજુ સુધી અસ્તિત્વમાં નથી, પરંતુ આદેશ પોતે પહેલાથી જ ફાઇલ બનાવેલ છે master.cmg.sample. તમારે તેનું નામ બદલવાની જરૂર છે master.cfg.sample в 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 BuildmasterConfig

c = BuildmasterConfig = {} 

BuildmasterConfig — રૂપરેખાંકન ફાઇલનો મૂળભૂત શબ્દકોશ. તે રૂપરેખાંકન ફાઇલમાં શામેલ હોવું આવશ્યક છે. ઉપયોગમાં સરળતા માટે, રૂપરેખાંકન કોડમાં ઉપનામ રજૂ કરવામાં આવ્યું છે "c". શીર્ષકો કીઓ в c["keyFromDist"] સાથે ક્રિયાપ્રતિક્રિયા માટે નિશ્ચિત તત્વો છે બિલ્ડમાસ્ટર. દરેક કી માટે, અનુરૂપ ઑબ્જેક્ટને મૂલ્ય તરીકે બદલવામાં આવે છે.

5.2 કામદારો

c['workers'] = [worker.Worker("example-worker", "pass")]

આ વખતે અમે સૂચવીએ છીએ બિલ્ડમાસ્ટર-y ની યાદી કામદાર-ઓ. મારી જાત કામદાર અમે બનાવ્યું ઉચ્ચ, સૂચવે છે તમે-કામદાર-નામ и પાસવર્ડ. હવે તેના બદલે તેમને સ્પષ્ટ કરવાની જરૂર છે ઉદાહરણ-કાર્યકર и પાસ .

5.3 ફેરફાર_સ્રોત

c['change_source'] = []
c['change_source'].append(changes.GitPoller(
                            'git://github.com/buildbot/hello-world.git',
                             workdir='gitpoller-workdir', branch='master',
                             pollInterval=300))                

કી દ્વારા ફેરફાર_સ્રોત શબ્દકોશ c અમને સૂચિની ઍક્સેસ મળે છે જ્યાં અમે એક ઑબ્જેક્ટ મૂકવા માંગીએ છીએ જે પ્રોજેક્ટના સ્રોત કોડ સાથે રિપોઝીટરીનું મતદાન કરે છે. ઉદાહરણ ગિટ રિપોઝીટરીનો ઉપયોગ કરે છે જે ચોક્કસ અંતરાલો પર મતદાન કરવામાં આવે છે.

પ્રથમ દલીલ એ તમારા ભંડારનો માર્ગ છે.

વર્કડીર ફોલ્ડર જ્યાં બાજુ પર છે તેના પાથને રજૂ કરે છે કામદાર- માર્ગ સાથે સંબંધિત /home/habr/worker/yourProject/build git રીપોઝીટરીના સ્થાનિક સંસ્કરણને સંગ્રહિત કરશે.

શાખા રિપોઝીટરીમાં ચોક્કસ શાખા ધરાવે છે જેને અનુસરવી જોઈએ.

મતદાન અંતરાલ તે પછીની સેકંડની સંખ્યા સમાવે છે બિલ્ડમાસ્ટર ફેરફારો માટે રીપોઝીટરીનું મતદાન કરશે.

પ્રોજેક્ટના રિપોઝીટરીમાં ફેરફારોને ટ્રૅક કરવા માટે ઘણી પદ્ધતિઓ છે.

સૌથી સરળ પદ્ધતિ છે મતદાન, જે સૂચવે છે કે બિલ્ડમાસ્ટર સમયાંતરે રીપોઝીટરી સાથે સર્વરનું મતદાન કરે છે. જો મોકલવું રીપોઝીટરીમાં ફેરફારોને પ્રતિબિંબિત કરે છે, પછી બિલ્ડમાસ્ટર કેટલાક વિલંબ સાથે આંતરિક પદાર્થ બનાવશે બદલો અને તેને ઇવેન્ટ હેન્ડલરને મોકલો શેડ્યૂલર, જે પ્રોજેક્ટને બિલ્ડ કરવા અને ચકાસવા માટેના પગલાઓ શરૂ કરશે કામદાર-e. આ પગલાંઓ વચ્ચે સૂચવવામાં આવશે સુધારો ભંડાર બરાબર ચાલુ કામદારઆ રીપોઝીટરીની સ્થાનિક નકલ બનાવશે. આ પ્રક્રિયાની વિગતો આગામી બે વિભાગોમાં નીચે આવરી લેવામાં આવશે. (5.4 и 5.5).

રિપોઝીટરીમાં થતા ફેરફારોને ટ્રૅક કરવાની એક વધુ ભવ્ય પદ્ધતિ એ છે કે તેને હોસ્ટ કરતા સર્વરથી સીધા જ સંદેશાઓ મોકલવા બિલ્ડમાસ્ટર- પ્રોજેક્ટ સોર્સ કોડ બદલવા વિશે. આ કિસ્સામાં, જલદી વિકાસકર્તા બનાવે છે મોકલવું, પ્રોજેક્ટ રીપોઝીટરી સાથેનું સર્વર એક સંદેશ મોકલશે બિલ્ડમાસ્ટર-y. અને તે, બદલામાં, ઑબ્જેક્ટ બનાવીને તેને અટકાવશે PBCchangeSource. આગળ, આ ઑબ્જેક્ટ પર સ્થાનાંતરિત કરવામાં આવશે શેડ્યૂલર, જે પ્રોજેક્ટ બનાવવા અને તેનું પરીક્ષણ કરવાનાં પગલાંને સક્રિય કરે છે. આ પદ્ધતિનો એક મહત્વપૂર્ણ ભાગ કામ કરી રહ્યો છે હૂક- રિપોઝીટરીમાં સર્વર સ્ક્રિપ્ટો. સ્ક્રિપ્ટમાં હૂક-a, જ્યારે પ્રક્રિયા કરવાની ક્રિયાઓ માટે જવાબદાર મોકલવું-e, તમારે ઉપયોગિતાને કૉલ કરવાની જરૂર છે મોકલવું અને નેટવર્ક સરનામું સ્પષ્ટ કરો બિલ્ડમાસ્ટર-એ. તમારે નેટવર્ક પોર્ટનો પણ ઉલ્લેખ કરવાની જરૂર છે જે સાંભળશે PBCchangeSource. PBCchangeSource, માર્ગ દ્વારા, ભાગ છે બિલ્ડમાસ્ટર-એ. આ પદ્ધતિને પરવાનગીની જરૂર પડશે સંચાલક-એ સર્વર પર જ્યાં પ્રોજેક્ટ રીપોઝીટરી સ્થિત છે. તમારે પહેલા રીપોઝીટરીનો બેકઅપ લેવાની જરૂર પડશે.

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"]))

શેડ્યુલર્સ - આ એક તત્વ છે જે ટ્રિગર તરીકે કાર્ય કરે છે જે પ્રોજેક્ટની એસેમ્બલી અને પરીક્ષણની સમગ્ર સાંકળ શરૂ કરે છે.


તે ફેરફારો કે જે રેકોર્ડ કરવામાં આવ્યા હતા ફેરફાર_સ્રોત, કામની પ્રક્રિયામાં રૂપાંતરિત બિલ્ડબોટ-એ વાંધો ઉઠાવવો બદલો અને હવે દરેક શેડ્યુલર તેમના આધારે, તે પ્રોજેક્ટ બિલ્ડ પ્રક્રિયા શરૂ કરવા વિનંતીઓ બનાવે છે. જો કે, તે એ પણ નિર્ધારિત કરે છે કે આ વિનંતીઓ કતારમાં આગળ ક્યારે ટ્રાન્સફર કરવામાં આવશે. એક પદાર્થ બિલ્ડર વિનંતીઓની કતાર સંગ્રહિત કરે છે અને વર્તમાન એસેમ્બલીની સ્થિતિને અલગ પર ટ્રૅક કરે છે કામદાર-e. બિલ્ડર પર અસ્તિત્વ ધરાવે છે બિલ્ડમાસ્ટર-e અને ચાલુ કામદાર-e. તે સાથે મોકલે છે બિલ્ડમાસ્ટર-એક પર કામદાર- અને પહેલેથી જ ચોક્કસ બિલ્ડ કરો - પગલાંઓની શ્રેણી કે જે અનુસરવું આવશ્યક છે.
આપણે તે વર્તમાન ઉદાહરણમાં જોઈએ છીએ શેડ્યુલર્સ 2 ટુકડાઓ બનાવવામાં આવે છે. તદુપરાંત, દરેકનો પોતાનો પ્રકાર છે.

સિંગલબ્રાન્ચ શેડ્યૂલર - શેડ્યૂલ પરના સૌથી લોકપ્રિય વર્ગોમાંનો એક. તે એક શાખાને જુએ છે અને તેમાં નોંધાયેલા ફેરફારથી તે ટ્રિગર થાય છે. જ્યારે તે ફેરફારો જુએ છે, ત્યારે તે બિલ્ડ વિનંતી મોકલવામાં વિલંબ કરી શકે છે (વિશેષ પરિમાણમાં ઉલ્લેખિત સમયગાળા માટે મુલતવી રાખો ટ્રી સ્ટેબલ ટાઈમર). વી નામ શેડ્યૂલનું નામ સેટ કરે છે જે પ્રદર્શિત થશે બિલ્ડબોટ- વેબ ઈન્ટરફેસ. IN ફિલ્ટર બદલો એક ફિલ્ટર સેટ કરવામાં આવે છે, જે પસાર કર્યા પછી શાખામાં કયા ફેરફારો શેડ્યૂલને બાંધકામ માટે વિનંતી મોકલવા માટે સંકેત આપે છે. IN બિલ્ડરના નામો નામ દર્શાવેલ છે બિલ્ડર-a, જે આપણે થોડી વાર પછી સેટ કરીશું. અમારા કિસ્સામાં નામ પ્રોજેક્ટના નામ જેવું જ હશે: તમારો પ્રોજેક્ટ.

ફોર્સ શેડ્યુલર એક ખૂબ જ સરળ વસ્તુ. આ પ્રકારનું શેડ્યૂલ માઉસ ક્લિક થ્રુ દ્વારા ટ્રિગર થાય છે બિલ્ડબોટ- વેબ ઈન્ટરફેસ. પરિમાણોમાં સમાન સાર છે સિંગલબ્રાન્ચ શેડ્યૂલર.

પીએસ નંબર 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": "."}))

સામયિક બિલ્ડ ટાઈમર આ સામયિકતાનો સમય સેકન્ડોમાં સ્પષ્ટ કરે છે.

બિલ્ડ ફેક્ટરી ચોક્કસ બનાવે છે બિલ્ડ કરો, જે પછી બિલ્ડર ને મોકલે છે કામદાર. આ બિલ્ડ ફેક્ટરી અનુસરવાના પગલાં સૂચવે છે કામદાર-y. પદ્ધતિને કૉલ કરીને પગલાં ઉમેરવામાં આવે છે પગલું ઉમેરો

આ ઉદાહરણમાં પ્રથમ ઉમેરાયેલ પગલું છે git સ્વચ્છ -d -f -f -xપછી ગિટ ચેકઆઉટ. આ ક્રિયાઓ પરિમાણમાં શામેલ છે પદ્ધતિ, જે સ્પષ્ટપણે જણાવેલ નથી પરંતુ ડિફોલ્ટ મૂલ્ય સૂચવે છે તાજા. પરિમાણ મોડ = 'વૃદ્ધિશીલ' સૂચવે છે કે ફાઇલો ડિરેક્ટરીમાંથી છે જ્યાં ચેચઆઉટ, જ્યારે રીપોઝીટરીમાંથી ખૂટે છે, ત્યારે અસ્પૃશ્ય રહે છે.

બીજું ઉમેરાયેલ પગલું સ્ક્રિપ્ટને કૉલ કરવાનું છે ટ્રાયલ પરિમાણ સાથે હેલો બાજુ પર કામદાર- એ ડિરેક્ટરીમાંથી /home/habr/worker/yourProject/build પર્યાવરણ ચલ સાથે PATHONPATH=... આમ, તમે તમારી પોતાની સ્ક્રિપ્ટો લખી શકો છો અને તેને બાજુ પર ચલાવી શકો છો. કામદાર- દરેક પગલું util.ShellCommand. આ સ્ક્રિપ્ટો સીધી રીપોઝીટરીમાં મૂકી શકાય છે. પછી મુ ચેચઆઉટ-e તેઓ પડી જશે /home/habr/worker/yourProject/build. જો કે, પછી ત્યાં બે "પરંતુ" છે:

1. કામદાર કી વડે બનાવવું જોઈએ --ઉમાસ્ક જેથી તે પછી અમલના અધિકારોને અવરોધે નહીં ચેકઆઉટ-આ.
2. અંતે ગીટ દબાણ-e આ સ્ક્રિપ્ટોમાંથી તમારે મિલકતનો ઉલ્લેખ કરવાની જરૂર છે એક્ઝિક્યુટેબલજેથી પછીથી ચેચઆઉટ-e એ ગિટ સ્ક્રિપ્ટ ચલાવવાનો અધિકાર ગુમાવ્યો નથી.

5.6 બિલ્ડરો

c['builders'] = []
c['builders'].append(util.BuilderConfig(name="runtests",
                                        workernames=["example-worker"],
                                        factory=factory))

શું છે તે વિશે બિલ્ડર કહેવામાં આવ્યું હતું અહીં. હવે હું તમને તે કેવી રીતે બનાવવું તે વિશે વધુ વિગતવાર જણાવીશ. બિલ્ડરકોન્ફિગ એક કન્સ્ટ્રક્ટર છે બિલ્ડર. માં આવા ડિઝાઇનરો c['બિલ્ડરો'] તમે ઘણાને સ્પષ્ટ કરી શકો છો, કારણ કે આ ઑબ્જેક્ટ્સની શીટ છે બિલ્ડર પ્રકાર હવે માંથી ઉદાહરણ ફરી લખીએ બિલ્ડબોટ, તેને અમારા કાર્યની નજીક લાવીએ છીએ.

c['builders'] = []
c['builders'].append(util.BuilderConfig(name="yourProject",
                                            workernames=["yourWorkerName"],
                                            factory=factory))

હવે હું તમને પરિમાણો વિશે કહીશ બિલ્ડરકોન્ફિગ.

નામ નામ સ્પષ્ટ કરે છે બિલ્ડર-a અહીં અમે તેનું નામ આપ્યું છે તમારો પ્રોજેક્ટ... આનો અર્થ છે કે ચાલુ કામદાર- આ જ રસ્તો બનાવવામાં આવશે /home/habr/worker/yourProject/build. શેડ્યુલર ની સોધ મા હોવુ બિલ્ડર ફક્ત આ નામથી.

કામદારોના નામ શીટ સમાવે છે કામદાર-ઓ. જેમાંના દરેકમાં ઉમેરવું આવશ્યક છે c['કામદારો'].

ફેક્ટરી - ચોક્કસ બિલ્ડ કરો, જેની સાથે તે સંકળાયેલ છે બિલ્ડર. તે ઑબ્જેક્ટ મોકલશે બિલ્ડ કરો પર કામદાર આમાં સમાવિષ્ટ તમામ પગલાઓ પૂર્ણ કરવા માટે બિલ્ડ કરો-આ.

6. તમારી પોતાની ગોઠવણીનું ઉદાહરણ

અહીં પ્રોજેક્ટ આર્કિટેક્ચરનું ઉદાહરણ છે જેને હું અમલમાં મૂકવાનો પ્રસ્તાવ મૂકું છું બિલ્ડબોટ
.

અમે વર્ઝન કંટ્રોલ સિસ્ટમ તરીકે ઉપયોગ કરીશું એસવીએન. રીપોઝીટરી પોતે અમુક પ્રકારના વાદળમાં સ્થિત હશે. આ વાદળનું સરનામું આ રહ્યું svn.host/svn/yourProject/trunk. વાદળ નીચે એસવીએન ત્યાં એક એકાઉન્ટ વપરાશકર્તા નામ છે: વપરાશકર્તા, passwd: પાસવર્ડ. સ્ક્રિપ્ટો જે પગલાંઓનું પ્રતિનિધિત્વ કરે છે બિલ્ડ કરો-એ પણ બ્રાન્ચમાં હશે એસવીએન, એક અલગ ફોલ્ડરમાં બિલ્ડબોટ/વર્કર_લિનક્સ. આ સ્ક્રિપ્ટો સંગ્રહિત મિલકત સાથે રીપોઝીટરીમાં સ્થિત છે એક્ઝેક્યુટેબલ.

બિલ્ડમાસ્ટર и કામદાર સમાન હોસ્ટ પર ચલાવો પ્રોજેક્ટ.હોસ્ટ .બિલ્ડમાસ્ટર તેની ફાઇલોને ફોલ્ડરમાં સંગ્રહિત કરે છે /home/habr/master. કામદાર તે નીચેના પાથમાં સંગ્રહિત છે /home/habr/worker. પ્રક્રિયા સંચાર બિલ્ડમાસ્ટર-a અને કામદાર-એ પ્રોટોકોલ અનુસાર પોર્ટ 4000 દ્વારા હાથ ધરવામાં આવે છે બિલ્ડબોટ-એ, એટલે કે 'pb' પ્રોટોકોલ

લક્ષ્ય પ્રોજેક્ટ સંપૂર્ણપણે પાયથોનમાં લખાયેલ છે. કાર્ય તેના ફેરફારોને ટ્રૅક કરવા, એક્ઝિક્યુટેબલ ફાઇલ બનાવવા, દસ્તાવેજીકરણ બનાવવા અને પરીક્ષણ હાથ ધરવાનું છે. નિષ્ફળતાના કિસ્સામાં, બધા વિકાસકર્તાઓએ એક અસફળ ક્રિયા હોવાનું જણાવતા ઇમેઇલ દ્વારા સંદેશ મોકલવાની જરૂર છે.

વેબ પ્રદર્શન બિલ્ડબોટ માટે અમે પોર્ટ 80 થી કનેક્ટ કરીશું પ્રોજેક્ટ.હોસ્ટ. Apatch ઇન્સ્ટોલ કરવું જરૂરી નથી. પુસ્તકાલયના ભાગરૂપે ટ્વિસ્ટેડ ત્યાં પહેલેથી જ વેબ સર્વર છે, બિલ્ડબોટ તેનો ઉપયોગ કરે છે.

માટે આંતરિક માહિતી સંગ્રહિત કરવા બિલ્ડબોટ использовать использовать ચોરસ.

મેઇલિંગ માટે હોસ્ટ જરૂરી છે smtp.your.domain - તે મેઇલથી પત્રો મોકલવાની મંજૂરી આપે છે [ઇમેઇલ સુરક્ષિત] પ્રમાણીકરણ વિના. યજમાન પર પણ'SMTP ' પોસ્ટ 1025 પર મિનિટ્સ સાંભળવામાં આવી રહી છે.

પ્રક્રિયામાં બે લોકો સામેલ છે: સંચાલક и વપરાશકર્તા. એડમિન વહીવટ કરે છે બિલ્ડબોટ. વપરાશકર્તા પ્રતિબદ્ધ વ્યક્તિ છે મોકલવું-ઓ.

એક્ઝેક્યુટેબલ ફાઇલ મારફતે જનરેટ થાય છે pyinstaller. દ્વારા દસ્તાવેજીકરણ જનરેટ થાય છે ડોક્સિજન.

આ આર્કિટેક્ચર માટે મેં આ લખ્યું: 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"
}

પ્રથમ તમારે જરૂર છે બનાવવું બિલ્ડમાસ્ટર-a અને કામદાર-a પછી આ ફાઈલ પેસ્ટ કરો master.cfg в /home/habr/master.

આગળનું પગલું સેવા શરૂ કરવાનું છે બિલ્ડમાસ્ટરએ

sudo buildbot start /home/habr/master

પછી સેવા શરૂ કરો કામદાર-a

buildbot-worker start /home/habr/worker

તૈયાર! હવે બિલ્ડબોટ ફેરફારોને ટ્રૅક કરશે અને ટ્રિગર કરશે મોકલવું-y માં એસવીએન, ઉપરોક્ત આર્કિટેક્ચર સાથે પ્રોજેક્ટ બનાવવા અને પરીક્ષણ કરવાનાં પગલાં.

નીચે હું ઉપરના કેટલાક લક્ષણોનું વર્ણન કરીશ master.cfg.

6.1 તમારા master.cfg ના માર્ગ પર

લખતી વખતે મારા master.cfg ઘણી ભૂલો કરવામાં આવશે, તેથી લોગ ફાઇલ વાંચવાની જરૂર પડશે. તરીકે સંગ્રહિત થાય છે બિલ્ડમાસ્ટર-ઇસી સંપૂર્ણ માર્ગ /home/habr/master/twistd.log, અને બાજુ પર કામદાર-એ સંપૂર્ણ માર્ગ સાથે /home/habr/worker/twistd.log. જેમ જેમ તમે ભૂલ વાંચો અને તેને ઠીક કરો તેમ, તમારે સેવા પુનઃપ્રારંભ કરવાની જરૂર પડશે બિલ્ડમાસ્ટર-a તે કેવી રીતે થાય છે તે અહીં છે:

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_alwaystruk નિયમો સુયોજિત કરે છે: ફોલ્ડર માળખું કેવી રીતે તોડવું એસવીએન શાખાઓ પર. તે તેમને સંબંધિત માર્ગો પણ આપે છે. તેના વળાંકમાં split_file_alwaystruk માત્ર રીપોઝીટરી સમાવે છે એમ કહીને પ્રક્રિયાને સરળ બનાવે છે ટ્રંક.

В સમયપત્રક સૂચવેલ ફિલ્ટર બદલોકોણ જુએ છે કંઈ અને તેની સાથે એક શાખાને સાંકળે છે ટ્રંક દ્વારા આપેલ એસોસિએશન અનુસાર split_file_alwaystruk. માં ફેરફારોનો પ્રતિસાદ ટ્રંક, લોન્ચ કરે છે બિલ્ડર નામ સાથે તમારો પ્રોજેક્ટ.

ગુણધર્મો અહીં તે જરૂરી છે જેથી એડમિન પ્રક્રિયાના માલિક તરીકે બિલ્ડ અને પરીક્ષણ પરિણામોની મેઇલિંગ સૂચિ મેળવે.

પગલું બિલ્ડ કરો-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]

તે સંદેશા મોકલી શકે છે અલગ રસ્તાઓ.

MailNotifier સૂચનાઓ મોકલવા માટે ઈમેલનો ઉપયોગ કરે છે.

ટેમ્પલેટ_html ન્યૂઝલેટર માટે ટેક્સ્ટ ટેમ્પલેટ સેટ કરે છે. HTML નો ઉપયોગ માર્કઅપ બનાવવા માટે થાય છે. તે એન્જિન દ્વારા સુધારેલ છે જીન્જા2 (સાથે સરખાવી શકાય છે જાંગો). બિલ્ડબોટ ચલોનો સમૂહ છે જેની કિંમતો સંદેશ ટેક્સ્ટ જનરેટ કરવાની પ્રક્રિયા દરમિયાન ટેમ્પલેટમાં અવેજી કરવામાં આવે છે. આ ચલો {{ ડબલ કર્લી કૌંસ }} માં બંધ છે. દાખ્લા તરીકે, સારાંશ પૂર્ણ થયેલ કામગીરીની સ્થિતિ દર્શાવે છે, એટલે કે સફળતા કે નિષ્ફળતા. એ પ્રોજેક્ટ આઉટપુટ કરશે તમારો પ્રોજેક્ટ. તેથી, માં નિયંત્રણ આદેશોનો ઉપયોગ કરીને જીન્જા2, ચલો બિલ્ડબોટ-a અને python સ્ટ્રિંગ ફોર્મેટિંગ ટૂલ્સ, તમે તદ્દન માહિતીપ્રદ સંદેશ બનાવી શકો છો.

MailNotifier નીચેની દલીલો સમાવે છે.

માંથી ઉમેરો - સરનામું જ્યાંથી દરેકને ન્યૂઝલેટર પ્રાપ્ત થશે.

રસ ધરાવતા વપરાશકર્તાઓને મોકલો=True બનાવનાર માલિક અને વપરાશકર્તાને સંદેશ મોકલે છે મોકલવું.

જુઓ — એક પ્રત્યય કે જે ન્યૂઝલેટર પ્રાપ્ત કરનારા વપરાશકર્તાઓના નામોમાં ઉમેરવો આવશ્યક છે. તેથી સંચાલક વપરાશકર્તાને સરનામાં પર ન્યૂઝલેટર કેવી રીતે પ્રાપ્ત થશે [ઇમેઇલ સુરક્ષિત].

relayhost હોસ્ટનામ સ્પષ્ટ કરે છે કે જેના પર સર્વર ખુલે છે SMTPએક smptPort પોર્ટ નંબરનો ઉલ્લેખ કરે છે જે સાંભળે છે SMTP સર્વર

મોડ="ચેતવણી" કહે છે કે મેઇલિંગ ફક્ત ત્યારે જ થવું જોઈએ જો ત્યાં ઓછામાં ઓછું એક પગલું હોય બિલ્ડ કરો-a, જે સ્થિતિ નિષ્ફળતા અથવા ચેતવણી સાથે સમાપ્ત થાય છે. સફળતાના કિસ્સામાં, ન્યૂઝલેટર મોકલવાની જરૂર નથી.

વધારાના પ્રાપ્તકર્તાઓ માલિક અને તે વ્યક્તિ કે જેમણે મેઇલિંગ મોકલવું જોઈએ તે વ્યક્તિઓની સૂચિ ધરાવે છે મોકલવું.

સંદેશ ફોર્મેટર એ એક ઑબ્જેક્ટ છે જે સંદેશ ફોર્મેટ, તેનો નમૂનો અને ઉપલબ્ધ ચલોનો સમૂહ સ્પષ્ટ કરે છે જીન્જા2. જેવા વિકલ્પો wantProperties=સાચું и wantSteps=સાચું ઉપલબ્ધ ચલોના આ સમૂહને વ્યાખ્યાયિત કરો.

સાથે['services']=[sendMessageToAll] સેવાઓની સૂચિ પ્રદાન કરે છે, જેમાંથી અમારી હશે પત્રકાર.

અમે તે કર્યું! અભિનંદન

અમે અમારું પોતાનું રૂપરેખાંકન બનાવ્યું છે અને તે કાર્યક્ષમતા જોઈ છે જે તે સક્ષમ છે. બિલ્ડબોટ. મને લાગે છે કે, તમારા પ્રોજેક્ટને બનાવવા માટે આ સાધનની જરૂર છે કે કેમ તે સમજવા માટે આ પૂરતું છે. શું તમને તેનામાં રસ છે? શું તે તમારા માટે ઉપયોગી થશે? શું તે તેની સાથે કામ કરવા માટે આરામદાયક છે? તો પછી હું આ લેખ વ્યર્થ નથી લખી રહ્યો.

અને આગળ. હું વ્યાવસાયિક સમુદાયનો ઉપયોગ કરવા માંગુ છું બિલ્ડબોટ, વ્યાપક બન્યું, માર્ગદર્શિકાઓનું ભાષાંતર કરવામાં આવ્યું, અને ત્યાં પણ વધુ ઉદાહરણો છે.

તમારા ધ્યાન માટે બધાનો આભાર. સારા નસીબ.

સોર્સ: www.habr.com