ਬਿਲਡਬੋਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਿਰੰਤਰ ਏਕੀਕਰਣ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ

(ਇਸ ਦੁਆਰਾ ਚਿੱਤਰ ਕੰਪਿਊਟਰਾਈਜ਼ਰ ਤੱਕ Pixabay)

ਹੈਲੋ!

ਮੇਰਾ ਨਾਮ ਹੈ ਇਵਗੇਨੀ ਚੈਰਕਿਨ, ਮੈਂ ਇੱਕ ਮਾਈਨਿੰਗ ਕੰਪਨੀ ਵਿੱਚ ਇੱਕ ਵਿਕਾਸ ਟੀਮ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਹਾਂ ਪੌਲੀਮੇਟਲ.

ਕੋਈ ਵੀ ਵੱਡਾ ਪ੍ਰੋਜੈਕਟ ਸ਼ੁਰੂ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਇਹ ਸੋਚਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ: "ਇਸ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਕਿਹੜਾ ਸਾਫਟਵੇਅਰ ਵਰਤਣਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ?" ਇੱਕ IT ਪ੍ਰੋਜੈਕਟ ਅਗਲਾ ਸੰਸਕਰਣ ਜਾਰੀ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ। ਇਹ ਚੰਗਾ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇਹਨਾਂ ਪੜਾਵਾਂ ਦੀ ਲੜੀ ਸਵੈਚਲਿਤ ਹੁੰਦੀ ਹੈ। ਇੱਕ IT ਪ੍ਰੋਜੈਕਟ ਦੇ ਇੱਕ ਨਵੇਂ ਸੰਸਕਰਣ ਨੂੰ ਜਾਰੀ ਕਰਨ ਦੀ ਸਵੈਚਾਲਤ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਲਗਾਤਾਰ ਏਕਤਾ. ਬਿਲਡਬੋਟ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਸਾਡੇ ਲਈ ਇੱਕ ਵਧੀਆ ਸਹਾਇਕ ਸਾਬਤ ਹੋਇਆ।

ਇਸ ਲੇਖ ਵਿੱਚ ਮੈਂ ਸੰਭਾਵਨਾਵਾਂ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਬਿਲਡਬੋਟ. ਇਹ ਸਾਫਟਵੇਅਰ ਕੀ ਕਰਨ ਦੇ ਯੋਗ ਹੈ? ਉਸ ਨਾਲ ਕਿਵੇਂ ਸੰਪਰਕ ਕਰਨਾ ਹੈ ਅਤੇ ਉਸ ਨਾਲ ਇੱਕ ਆਮ ਪ੍ਰਭਾਵੀ ਕੰਮ ਕਰਨ ਵਾਲਾ ਰਿਸ਼ਤਾ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ? ਤੁਸੀਂ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਟੈਸਟ ਕਰਨ ਲਈ ਕਾਰਜਸ਼ੀਲ ਸੇਵਾ ਬਣਾ ਕੇ ਸਾਡੇ ਅਨੁਭਵ ਨੂੰ ਖੁਦ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ।

ਸਮੱਗਰੀ

ਸਮੱਗਰੀ

1. ਬਿਲਡਬੋਟ ਕਿਉਂ?
2. ਬਿਲਡਮਾਸਟਰ ਦੀ ਅਗਵਾਈ ਵਾਲੀ ਧਾਰਨਾ
3. ਸਥਾਪਨਾ
4. ਪਹਿਲੇ ਕਦਮ

5. ਸੰਰਚਨਾ. ਕਦਮ ਦਰ ਕਦਮ ਵਿਅੰਜਨ

5.1 ਬਿਲਡਮਾਸਟਰ ਕੌਂਫਿਗ
5.2 ਕਰਮਚਾਰੀ
5.3 ਤਬਦੀਲੀ_ਸਰੋਤ
5.4 ਸ਼ਡਿਊਲਰ

5.5 ਬਿਲਡ ਫੈਕਟਰੀ
5.6 ਬਿਲਡਰ

6. ਤੁਹਾਡੀ ਆਪਣੀ ਸੰਰਚਨਾ ਦੀ ਉਦਾਹਰਨ

6.1 ਤੁਹਾਡੇ master.cfg ਦੇ ਰਸਤੇ 'ਤੇ
6.2 svn ਨਾਲ ਕੰਮ ਕਰਨਾ
6.3 ਤੁਹਾਨੂੰ ਪੱਤਰ: ਪੱਤਰਕਾਰਾਂ ਨੂੰ ਘੋਸ਼ਣਾ ਕਰਨ ਲਈ ਅਧਿਕਾਰਤ ਹਨ

ਅਸੀਂ ਇਹ ਕੀਤਾ! ਵਧਾਈਆਂ

1. ਬਿਲਡਬੋਟ ਕਿਉਂ?

ਪਹਿਲਾਂ habr-e 'ਤੇ ਮੈਨੂੰ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਲੇਖ ਮਿਲੇ ਸਨ ਲਗਾਤਾਰ ਏਕਤਾ ਵਰਤ ਬਿਲਡਬੋਟ. ਜਿਵੇਂ, ਇਹ ਵਾਲਾ ਮੈਨੂੰ ਇਹ ਸਭ ਤੋਂ ਵੱਧ ਜਾਣਕਾਰੀ ਭਰਪੂਰ ਲੱਗਿਆ। ਇੱਕ ਹੋਰ ਉਦਾਹਰਣ ਹੈ - ਸਰਲ. ਇਹ ਲੇਖ ਤਜਰਬੇਕਾਰ ਹੋ ਸਕਦੇ ਹਨ ਮੈਨੂਅਲ ਤੋਂ ਉਦਾਹਰਨਅਤੇ ਇਸ ਨੂੰ ਉਸ ਤੋਂ ਬਾਅਦ, ਅੰਗਰੇਜ਼ੀ ਵਿੱਚ। ਕੂਪ ਇੱਕ ਵਧੀਆ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਬਣਾਉਂਦਾ ਹੈ। ਇਹਨਾਂ ਲੇਖਾਂ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਸ਼ਾਇਦ ਤੁਰੰਤ ਕੁਝ ਚਾਹੁੰਦੇ ਹੋ ਬਿਲਡਬੋਟ ਕਰਨ ਲਈ.

ਰੂਕੋ! ਕੀ ਕਿਸੇ ਨੇ ਅਸਲ ਵਿੱਚ ਇਸਨੂੰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਵਰਤਿਆ ਹੈ? ਇਹ yes ਬਾਹਰ ਕਾਮੁਕ ਬਹੁਤ ਸਾਰੇ ਇਸ ਨੂੰ ਆਪਣੇ ਕੰਮਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ। ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਉਦਾਹਰਣ использования ਬਿਲਡਬੋਟ ਅਤੇ Google ਕੋਡ ਪੁਰਾਲੇਖਾਂ ਵਿੱਚ।

ਇਸ ਲਈ ਲੋਕ ਕੀ ਤਰਕ ਵਰਤ ਰਹੇ ਹਨ ਬਿਲਡਬੋਟ? ਆਖ਼ਰਕਾਰ, ਇੱਥੇ ਹੋਰ ਸਾਧਨ ਹਨ: ਕਰੂਜ਼ ਕੰਟਰੋਲ и ਜੇਨਕਿੰਸ. ਮੈਂ ਇਸ ਤਰ੍ਹਾਂ ਜਵਾਬ ਦੇਵਾਂਗਾ। ਜ਼ਿਆਦਾਤਰ ਕੰਮਾਂ ਲਈ ਜੇਨਕਿੰਸ ਅਤੇ ਸੱਚ ਕਾਫ਼ੀ ਹੋਵੇਗਾ। ਇਸਦੇ ਬਦਲੇ ਵਿੱਚ, ਬਿਲਡਬੋਟ - ਵਧੇਰੇ ਅਨੁਕੂਲ, ਜਦੋਂ ਕਿ ਸਮੱਸਿਆਵਾਂ ਦਾ ਹੱਲ ਉੱਥੇ ਹੀ ਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਅੰਦਰ ਜੇਨਕਿੰਸ. ਚੋਣ ਤੁਹਾਡੀ ਹੈ। ਪਰ ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ ਵਿਕਾਸਸ਼ੀਲ ਟੀਚਾ ਪ੍ਰੋਜੈਕਟ ਲਈ ਇੱਕ ਸਾਧਨ ਲੱਭ ਰਹੇ ਹਾਂ, ਕਿਉਂ ਨਾ ਇੱਕ ਅਜਿਹਾ ਚੁਣੋ ਜੋ ਸਧਾਰਨ ਕਦਮਾਂ ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਬਿਲਡ ਸਿਸਟਮ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ ਜਿਸ ਵਿੱਚ ਇੰਟਰਐਕਟੀਵਿਟੀ ਅਤੇ ਇੱਕ ਵਿਲੱਖਣ ਇੰਟਰਫੇਸ ਹੋਵੇ।

ਉਹਨਾਂ ਲਈ ਜਿਨ੍ਹਾਂ ਦਾ ਟੀਚਾ ਪ੍ਰੋਜੈਕਟ python ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਸਵਾਲ ਉੱਠਦਾ ਹੈ: "ਕਿਉਂ ਨਾ ਇੱਕ ਏਕੀਕਰਣ ਪ੍ਰਣਾਲੀ ਦੀ ਚੋਣ ਕਰੋ ਜਿਸਦਾ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਵਰਤੀ ਗਈ ਭਾਸ਼ਾ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਸਪਸ਼ਟ ਇੰਟਰਫੇਸ ਹੋਵੇ?" ਅਤੇ ਹੁਣ ਇਹ ਲਾਭ ਪੇਸ਼ ਕਰਨ ਦਾ ਸਮਾਂ ਹੈ ਬਿਲਡਬੋਟ.

ਇਸ ਲਈ, ਸਾਡਾ "ਇੰਸਟ੍ਰੂਮੈਂਟਲ ਚੌਂਕ"। ਆਪਣੇ ਲਈ, ਮੈਂ ਚਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਪਛਾਣ ਕੀਤੀ ਹੈ ਬਿਲਡਬੋਟ:

1. ਇਹ GPL ਲਾਇਸੰਸ ਦੇ ਅਧੀਨ ਇੱਕ ਓਪਨ ਸੋਰਸ ਫਰੇਮਵਰਕ ਹੈ
2. ਇਹ python ਦੀ ਇੱਕ ਸੰਰਚਨਾ ਟੂਲ ਅਤੇ ਲੋੜੀਂਦੀਆਂ ਕਾਰਵਾਈਆਂ ਦੇ ਵਰਣਨ ਵਜੋਂ ਵਰਤੋਂ ਹੈ
3. ਇਹ ਮਸ਼ੀਨ ਤੋਂ ਜਵਾਬ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਇੱਕ ਮੌਕਾ ਹੈ ਜਿਸ 'ਤੇ ਅਸੈਂਬਲੀ ਹੁੰਦੀ ਹੈ
4. ਇਹ, ਅੰਤ ਵਿੱਚ, ਇੱਕ ਮੇਜ਼ਬਾਨ ਲਈ ਘੱਟੋ-ਘੱਟ ਲੋੜਾਂ ਹਨ. ਤੈਨਾਤੀ ਲਈ python ਅਤੇ ਮਰੋੜਿਆ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਅਤੇ java ਮਸ਼ੀਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

2. ਬਿਲਡਮਾਸਟਰ ਦੀ ਅਗਵਾਈ ਵਾਲੀ ਧਾਰਨਾ

ਟਾਸਕ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਆਰਕੀਟੈਕਚਰ ਦਾ ਕੇਂਦਰੀ ਹੈ ਬਿਲਡਮਾਸਟਰ. ਇਹ ਇੱਕ ਸੇਵਾ ਹੈ ਜੋ:

• ਟਰੈਕ ਰੱਖਦਾ ਹੈ ਪ੍ਰੋਜੈਕਟ ਸਰੋਤ ਰੁੱਖ ਵਿੱਚ ਤਬਦੀਲੀਆਂ
• ਭੇਜਦਾ ਹੈ ਕਮਾਂਡਾਂ ਜੋ ਕਿ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਇਸਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਵਰਕਰ ਸੇਵਾ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤੀਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ
• ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕੀਤੀਆਂ ਕਾਰਵਾਈਆਂ ਦੇ ਨਤੀਜਿਆਂ ਬਾਰੇ ਉਪਭੋਗਤਾ

ਬਿਲਡਮਾਸਟਰ ਫਾਈਲ ਦੁਆਰਾ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ master.cfg. ਇਹ ਫਾਈਲ ਰੂਟ ਵਿੱਚ ਹੈ ਬਿਲਡਮਾਸਟਰ. ਬਾਅਦ ਵਿੱਚ ਮੈਂ ਦਿਖਾਵਾਂਗਾ ਕਿ ਇਹ ਰੂਟ ਕਿਵੇਂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਫਾਈਲ ਆਪਣੇ ਆਪ master.cfg ਇੱਕ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਕਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਬਿਲਡਬੋਟ.

ਅਗਲੀ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਵਸਤੂ ਬਿਲਡਬੋਟ ਇੱਕ ਨਾਮ ਹੈ ਕਾਮਾ. ਇਹ ਸੇਵਾ ਕਿਸੇ ਹੋਰ ਹੋਸਟ 'ਤੇ ਇੱਕ ਵੱਖਰੇ OS ਦੇ ਨਾਲ ਲਾਂਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਾਂ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇੱਕ ਜਿੱਥੇ ਬਿਲਡਮਾਸਟਰ. ਇਹ ਆਪਣੇ ਪੈਕੇਜਾਂ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਦੇ ਨਾਲ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਤਿਆਰ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵੀ ਮੌਜੂਦ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਵਰਚੁਅਲ ਵਾਤਾਵਰਣ python ਉਪਯੋਗਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤਿਆਰ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ virtualenv, venv.

ਬਿਲਡਮਾਸਟਰ ਹਰ ਕਿਸੇ ਨੂੰ ਹੁਕਮਾਂ ਦਾ ਪ੍ਰਸਾਰਣ ਕਰਦਾ ਹੈ ਕਾਮਾ-y, ਅਤੇ ਉਹ, ਬਦਲੇ ਵਿੱਚ, ਉਹਨਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ। ਭਾਵ, ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਅਤੇ ਟੈਸਟ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਚੱਲ ਸਕਦੀ ਹੈ ਕਾਮਾ-e ਵਿੰਡੋਜ਼ ਚਲਾ ਰਿਹਾ ਹੈ ਅਤੇ ਲੀਨਕਸ ਚਲਾਉਣ ਵਾਲੇ ਕਿਸੇ ਹੋਰ ਵਰਕਰ 'ਤੇ।

ਕਮਰਾ ਛੱਡ ਦਿਓ ਪ੍ਰੋਜੈਕਟ ਸਰੋਤ ਕੋਡ ਹਰੇਕ 'ਤੇ ਹੁੰਦਾ ਹੈ ਕਾਮਾ-ਈ.

3. ਸਥਾਪਨਾ

ਇਸ ਲਈ, ਆਓ ਚੱਲੀਏ। ਮੈਂ ਹੋਸਟ ਵਜੋਂ ਉਬੰਟੂ 18.04 ਦੀ ਵਰਤੋਂ ਕਰਾਂਗਾ. ਮੈਂ ਇਸ 'ਤੇ ਇੱਕ ਰੱਖਾਂਗਾ ਬਿਲਡਮਾਸਟਰ-a ਅਤੇ ਇੱਕ ਕਾਮਾ-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. ਪਹਿਲੇ ਕਦਮ

ਬਣਾਉਣ ਦਾ ਸਮਾਂ ਬਿਲਡਮਾਸਟਰ. ਇਹ ਸਾਡੇ ਫੋਲਡਰ ਵਿੱਚ ਹੋਵੇਗਾ /ਘਰ/ਹੈਬਰ/ਮਾਸਟਰ.

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.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 ਬਿਲਡਮਾਸਟਰ ਕੌਂਫਿਗ

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

ਕੁੰਜੀ ਦੁਆਰਾ ਤਬਦੀਲੀ_ਸਰੋਤ ਡਿਕਸ਼ਨਰੀ ਸੀ ਸਾਨੂੰ ਸੂਚੀ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ ਜਿੱਥੇ ਅਸੀਂ ਇੱਕ ਵਸਤੂ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜੋ ਪ੍ਰੋਜੈਕਟ ਦੇ ਸਰੋਤ ਕੋਡ ਨਾਲ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਪੋਲ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਇੱਕ Git ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਜੋ ਕੁਝ ਅੰਤਰਾਲਾਂ 'ਤੇ ਪੋਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਪਹਿਲੀ ਦਲੀਲ ਤੁਹਾਡੀ ਰਿਪੋਜ਼ਟਰੀ ਦਾ ਮਾਰਗ ਹੈ।

workdir ਫੋਲਡਰ ਦੇ ਮਾਰਗ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਪਾਸੇ ਹੈ ਕਾਮਾ- ਮਾਰਗ ਦਾ ਰਿਸ਼ਤੇਦਾਰ /home/habr/worker/yourProject/build git ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਸਥਾਨਕ ਸੰਸਕਰਣ ਨੂੰ ਸਟੋਰ ਕਰੇਗਾ.

ਸ਼ਾਖਾ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਇੱਕ ਖਾਸ ਸ਼ਾਖਾ ਸ਼ਾਮਲ ਹੈ ਜਿਸਦਾ ਅਨੁਸਰਣ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

pollInterval ਜਿਸ ਤੋਂ ਬਾਅਦ ਸਕਿੰਟਾਂ ਦੀ ਸੰਖਿਆ ਸ਼ਾਮਿਲ ਹੈ ਬਿਲਡਮਾਸਟਰ ਤਬਦੀਲੀਆਂ ਲਈ ਰਿਪੋਜ਼ਟਰੀ ਪੋਲ ਕਰੇਗਾ।

ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਦੀ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਕਈ ਤਰੀਕੇ ਹਨ।

ਸਭ ਤੋਂ ਸਰਲ ਤਰੀਕਾ ਹੈ ਪੋਲਿੰਗ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਬਿਲਡਮਾਸਟਰ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਸਰਵਰ ਨੂੰ ਪੋਲ ਕਰਦਾ ਹੈ। ਜੇ ਕਮਿਟ ਕਰੋ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਫਿਰ ਬਿਲਡਮਾਸਟਰ ਕੁਝ ਦੇਰੀ ਨਾਲ ਇੱਕ ਅੰਦਰੂਨੀ ਵਸਤੂ ਬਣਾਵੇਗਾ ਬਦਲੋ ਅਤੇ ਇਸਨੂੰ ਇਵੈਂਟ ਹੈਂਡਲਰ ਨੂੰ ਭੇਜੋ ਸੈਡਿਊਲਰ, ਜੋ ਕਿ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਟੈਸਟ ਕਰਨ ਲਈ ਕਦਮਾਂ ਨੂੰ ਲਾਂਚ ਕਰੇਗਾ ਕਾਮਾ-ਈ. ਇਹਨਾਂ ਕਦਮਾਂ ਵਿੱਚ ਸੰਕੇਤ ਕੀਤਾ ਜਾਵੇਗਾ ਅੱਪਡੇਟ ਰਿਪੋਜ਼ਟਰੀ. ਬਿਲਕੁਲ 'ਤੇ ਕਾਮਾਇਹ ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਇੱਕ ਸਥਾਨਕ ਕਾਪੀ ਬਣਾਏਗਾ। ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੇ ਵੇਰਵੇ ਅਗਲੇ ਦੋ ਭਾਗਾਂ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਾਣਗੇ। (5.4 и 5.5).

ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਵੀ ਸ਼ਾਨਦਾਰ ਤਰੀਕਾ ਹੈ ਸਰਵਰ ਤੋਂ ਸਿੱਧੇ ਸੁਨੇਹੇ ਭੇਜਣਾ ਬਿਲਡਮਾਸਟਰ- ਪ੍ਰੋਜੈਕਟ ਸਰੋਤ ਕੋਡਾਂ ਨੂੰ ਬਦਲਣ ਬਾਰੇ। ਇਸ ਕੇਸ ਵਿੱਚ, ਜਿਵੇਂ ਹੀ ਡਿਵੈਲਪਰ ਬਣਾਉਂਦਾ ਹੈ ਕਮਿਟ ਕਰੋ, ਪ੍ਰੋਜੈਕਟ ਰਿਪੋਜ਼ਟਰੀ ਵਾਲਾ ਸਰਵਰ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜੇਗਾ ਬਿਲਡਮਾਸਟਰ-y. ਅਤੇ ਉਹ, ਬਦਲੇ ਵਿੱਚ, ਇੱਕ ਵਸਤੂ ਬਣਾ ਕੇ ਇਸਨੂੰ ਰੋਕ ਦੇਵੇਗਾ 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"]))

ਸ਼ਡਿਊਲਰ - ਇਹ ਇੱਕ ਅਜਿਹਾ ਤੱਤ ਹੈ ਜੋ ਇੱਕ ਟਰਿੱਗਰ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਪ੍ਰੋਜੈਕਟ ਦੀ ਅਸੈਂਬਲੀ ਅਤੇ ਟੈਸਟਿੰਗ ਦੀ ਪੂਰੀ ਲੜੀ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।


ਉਹ ਬਦਲਾਅ ਜੋ ਰਿਕਾਰਡ ਕੀਤੇ ਗਏ ਸਨ ਤਬਦੀਲੀ_ਸਰੋਤ, ਕੰਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਤਬਦੀਲ ਬਿਲਡਬੋਟ- ਇੱਕ ਇਤਰਾਜ਼ ਕਰਨ ਲਈ ਬਦਲੋ ਅਤੇ ਹੁਣ ਹਰ ਸ਼ੈਡਿਊਲਰ ਉਹਨਾਂ ਦੇ ਅਧਾਰ ਤੇ, ਇਹ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਬੇਨਤੀਆਂ ਬਣਾਉਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਇਹ ਵੀ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਇਹਨਾਂ ਬੇਨਤੀਆਂ ਨੂੰ ਕਤਾਰ ਵਿੱਚ ਕਦੋਂ ਤਬਦੀਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਵਸਤੂ ਬਿਲਡਰ ਬੇਨਤੀਆਂ ਦੀ ਇੱਕ ਕਤਾਰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਮੌਜੂਦਾ ਅਸੈਂਬਲੀ ਦੀ ਸਥਿਤੀ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਟਰੈਕ ਕਰਦਾ ਹੈ ਕਾਮਾ-ਈ. ਬਿਲਡਰ 'ਤੇ ਮੌਜੂਦ ਹੈ ਬਿਲਡਮਾਸਟਰ-e ਅਤੇ 'ਤੇ ਕਾਮਾ-ਈ. ਨਾਲ ਭੇਜਦਾ ਹੈ ਬਿਲਡਮਾਸਟਰ- ਇੱਕ 'ਤੇ ਕਾਮਾ- ਅਤੇ ਪਹਿਲਾਂ ਹੀ ਖਾਸ ਨੂੰ ਬਣਾਉਣ - ਕਦਮਾਂ ਦੀ ਇੱਕ ਲੜੀ ਜਿਸਦੀ ਪਾਲਣਾ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।
ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਮੌਜੂਦਾ ਉਦਾਹਰਣ ਵਿੱਚ ਅਜਿਹਾ ਹੈ ਸ਼ਡਿਊਲਰ 2 ਟੁਕੜੇ ਬਣਾਏ ਗਏ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਹਰੇਕ ਦੀ ਆਪਣੀ ਕਿਸਮ ਹੈ.

ਸਿੰਗਲਬ੍ਰਾਂਚ ਸ਼ੈਡਿਊਲਰ - ਅਨੁਸੂਚੀ 'ਤੇ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਕਲਾਸਾਂ ਵਿੱਚੋਂ ਇੱਕ। ਇਹ ਇੱਕ ਸ਼ਾਖਾ ਨੂੰ ਦੇਖਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਇੱਕ ਰਿਕਾਰਡ ਕੀਤੀ ਤਬਦੀਲੀ ਦੁਆਰਾ ਚਾਲੂ ਹੁੰਦਾ ਹੈ। ਜਦੋਂ ਉਹ ਤਬਦੀਲੀਆਂ ਦੇਖਦਾ ਹੈ, ਤਾਂ ਉਹ ਬਿਲਡ ਬੇਨਤੀ ਭੇਜਣ ਵਿੱਚ ਦੇਰੀ ਕਰ ਸਕਦਾ ਹੈ (ਵਿਸ਼ੇਸ਼ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਨਿਰਧਾਰਤ ਮਿਆਦ ਲਈ ਮੁਲਤਵੀ ਕਰ ਸਕਦਾ ਹੈ ਟ੍ਰੀ ਸਟੈਬਲ ਟਾਈਮਰ) ਵਿਚ ਨਾਮ ਅਨੁਸੂਚੀ ਦਾ ਨਾਮ ਸੈੱਟ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ ਬਿਲਡਬੋਟ- ਵੈੱਬ ਇੰਟਰਫੇਸ. IN ਫਿਲਟਰ ਬਦਲੋ ਇੱਕ ਫਿਲਟਰ ਸੈਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਪਾਸ ਕਰਨ ਤੋਂ ਬਾਅਦ ਸ਼ਾਖਾ ਵਿੱਚ ਕਿਹੜੀਆਂ ਤਬਦੀਲੀਆਂ ਉਸਾਰੀ ਲਈ ਬੇਨਤੀ ਭੇਜਣ ਲਈ ਕਾਰਜਕ੍ਰਮ ਨੂੰ ਪ੍ਰੋਂਪਟ ਕਰਦੀਆਂ ਹਨ। IN ਬਿਲਡਰ ਦੇ ਨਾਮ ਨਾਮ ਦਰਸਾਇਆ ਗਿਆ ਹੈ ਬਿਲਡਰ-a, ਜਿਸ ਨੂੰ ਅਸੀਂ ਥੋੜੀ ਦੇਰ ਬਾਅਦ ਸੈਟ ਕਰਾਂਗੇ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਨਾਮ ਪ੍ਰੋਜੈਕਟ ਨਾਮ ਦੇ ਸਮਾਨ ਹੋਵੇਗਾ: ਤੁਹਾਡਾ ਪ੍ਰੋਜੈਕਟ.

ਫੋਰਸ ਸ਼ੈਡਿਊਲਰ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਚੀਜ਼. ਇਸ ਕਿਸਮ ਦੀ ਸਮਾਂ-ਸਾਰਣੀ ਇੱਕ ਮਾਊਸ ਕਲਿੱਕ ਦੁਆਰਾ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਬਿਲਡਬੋਟ- ਵੈੱਬ ਇੰਟਰਫੇਸ. ਪੈਰਾਮੀਟਰਾਂ ਦਾ ਉਹੀ ਤੱਤ ਹੈ ਜਿਵੇਂ ਕਿ ਵਿੱਚ ਸਿੰਗਲਬ੍ਰਾਂਚ ਸ਼ੈਡਿਊਲਰ.

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": "."}))

ਪੀਰੀਅਡਿਕ ਬਿਲਡ ਟਾਈਮਰ ਇਸ ਮਿਆਦ ਦਾ ਸਮਾਂ ਸਕਿੰਟਾਂ ਵਿੱਚ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ।

ਬਿਲਡ ਫੈਕਟਰੀ ਇੱਕ ਖਾਸ ਬਣਾਉਂਦਾ ਹੈ ਨੂੰ ਬਣਾਉਣ, ਜੋ ਫਿਰ ਬਿਲਡਰ ਨੂੰ ਭੇਜਦਾ ਹੈ ਕਾਮਾ. The ਬਿਲਡ ਫੈਕਟਰੀ ਪਾਲਣ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਕਦਮਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਾਮਾ-y. ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਕੇ ਕਦਮ ਜੋੜੇ ਜਾਂਦੇ ਹਨ addStep

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਪਹਿਲਾ ਜੋੜਿਆ ਗਿਆ ਕਦਮ ਹੈ git ਸਾਫ਼ -d -f -f -xਫਿਰ git ਚੈਕਆਉਟ. ਇਹ ਕਾਰਵਾਈਆਂ ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ ਢੰਗ ਹੈ, ਜੋ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਨਹੀਂ ਦੱਸਿਆ ਗਿਆ ਹੈ ਪਰ ਇੱਕ ਡਿਫੌਲਟ ਮੁੱਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਤਾਜ਼ਾ. ਪੈਰਾਮੀਟਰ ਮੋਡ = 'ਵਧਾਈ' ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਫਾਈਲਾਂ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਹਨ ਜਿੱਥੇ chechout, ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਗੁੰਮ ਹੋਣ ਦੇ ਦੌਰਾਨ, ਅਛੂਤ ਰਹੇ।

ਦੂਜਾ ਜੋੜਿਆ ਗਿਆ ਕਦਮ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕਾਲ ਕਰ ਰਿਹਾ ਹੈ ਮੁਕੱਦਮੇ ਪੈਰਾਮੀਟਰ ਦੇ ਨਾਲ ਸਤ ਸ੍ਰੀ ਅਕਾਲ ਪਾਸੇ 'ਤੇ ਕਾਮਾ- ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਏ /home/habr/worker/yourProject/build ਇਨਵਾਇਰਮੈਂਟ ਵੇਰੀਏਬਲ PATHONPATH=... ਨਾਲ, ਤੁਸੀਂ ਆਪਣੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਪਾਸੇ 'ਤੇ ਚਲਾ ਸਕਦੇ ਹੋ। ਕਾਮਾ- ਹਰ ਕਦਮ util.ShellCommand. ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸਿੱਧੇ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਫਿਰ 'ਤੇ chechout-e ਉਹ ਵਿੱਚ ਡਿੱਗ ਜਾਵੇਗਾ /home/habr/worker/yourProject/build. ਹਾਲਾਂਕਿ, ਫਿਰ ਦੋ "ਪਰ" ਹਨ:

1. ਕਾਮਾ ਇੱਕ ਕੁੰਜੀ ਨਾਲ ਬਣਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ --ਉਮਾਸਕ ਤਾਂ ਕਿ ਇਹ ਬਾਅਦ ਵਿੱਚ ਫਾਂਸੀ ਦੇ ਅਧਿਕਾਰਾਂ ਨੂੰ ਬਲੌਕ ਨਾ ਕਰੇ ਕਮਰਾ ਛੱਡ ਦਿਓ-ਦ.
2. 'ਤੇ git ਧੱਕਾ-e ਇਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚੋਂ ਤੁਹਾਨੂੰ ਸੰਪੱਤੀ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਚਲਾਉਣਯੋਗਇਸ ਲਈ ਬਾਅਦ ਵਿੱਚ chechout-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. ਰਿਪੋਜ਼ਟਰੀ ਖੁਦ ਕਿਸੇ ਕਿਸਮ ਦੇ ਕਲਾਉਡ ਵਿੱਚ ਸਥਿਤ ਹੋਵੇਗੀ। ਇੱਥੇ ਇਸ ਬੱਦਲ ਦਾ ਪਤਾ ਹੈ svn.host/svn/yourProject/trunk. ਬੱਦਲ ਹੇਠ svn ਇੱਕ ਖਾਤਾ ਉਪਭੋਗਤਾ ਨਾਮ ਹੈ: ਉਪਭੋਗੀ ਨੂੰ, ਪਾਸਵਰਡ: ਪਾਸਵਰਡ. ਸਕ੍ਰਿਪਟਾਂ ਜੋ ਕਦਮਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਨੂੰ ਬਣਾਉਣ-a ਦੀ ਸ਼ਾਖਾ ਵਿੱਚ ਵੀ ਹੋਵੇਗੀ svn, ਇੱਕ ਵੱਖਰੇ ਫੋਲਡਰ ਵਿੱਚ buildbot/worker_linux. ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਸੁਰੱਖਿਅਤ ਕੀਤੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਨਾਲ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਥਿਤ ਹਨ ਚੱਲਣਯੋਗ.

ਬਿਲਡਮਾਸਟਰ и ਕਾਮਾ ਉਸੇ ਮੇਜ਼ਬਾਨ 'ਤੇ ਚਲਾਓ project.host .ਬਿਲਡਮਾਸਟਰ ਇਸ ਦੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਇੱਕ ਫੋਲਡਰ ਵਿੱਚ ਸਟੋਰ ਕਰਦਾ ਹੈ /ਘਰ/ਹੈਬਰ/ਮਾਸਟਰ. ਕਾਮਾ ਇਸ ਨੂੰ ਹੇਠ ਦਿੱਤੇ ਮਾਰਗ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ /ਘਰ/ਹਾਬਰ/ਕਰਮਚਾਰੀ. ਪ੍ਰਕਿਰਿਆ ਸੰਚਾਰ ਬਿਲਡਮਾਸਟਰ-a ਅਤੇ ਕਾਮਾ-a ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਅਨੁਸਾਰ ਪੋਰਟ 4000 ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਬਿਲਡਬੋਟ-a, ਇਹ ਹੈ 'pb' ਪ੍ਰੋਟੋਕੋਲ।

ਟੀਚਾ ਪ੍ਰੋਜੈਕਟ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪਾਈਥਨ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਕੰਮ ਇਸ ਦੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨਾ, ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਬਣਾਉਣਾ, ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕਰਨਾ ਅਤੇ ਟੈਸਟਿੰਗ ਕਰਨਾ ਹੈ। ਅਸਫਲਤਾ ਦੀ ਸਥਿਤੀ ਵਿੱਚ, ਸਾਰੇ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਈਮੇਲ ਦੁਆਰਾ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਕਿ ਇੱਕ ਅਸਫਲ ਕਾਰਵਾਈ ਹੈ।

ਵੈੱਬ ਡਿਸਪਲੇ ਬਿਲਡਬੋਟ ਅਸੀਂ ਇਸ ਲਈ ਪੋਰਟ 80 ਨਾਲ ਜੁੜਾਂਗੇ project.host. Apatch ਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ। ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਮਰੋੜਿਆ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਵੈੱਬ ਸਰਵਰ ਹੈ, ਬਿਲਡਬੋਟ ਇਸ ਨੂੰ ਵਰਤਦਾ ਹੈ.

ਲਈ ਅੰਦਰੂਨੀ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕਰਨ ਲਈ ਬਿਲਡਬੋਟ ਅਸੀਂ ਵਰਤਾਂਗੇ sqlite.

ਮੇਲਿੰਗ ਲਈ ਇੱਕ ਹੋਸਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ smtp.your.domain - ਇਹ ਮੇਲ ਤੋਂ ਚਿੱਠੀਆਂ ਭੇਜਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ [ਈਮੇਲ ਸੁਰੱਖਿਅਤ] ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ ਬਿਨਾਂ. ਮੇਜ਼ਬਾਨ 'ਤੇ ਵੀ.SMTP ' ਪੋਸਟ 1025 'ਤੇ ਮਿੰਟ ਸੁਣੇ ਜਾ ਰਹੇ ਹਨ।

ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਦੋ ਲੋਕ ਹਨ: ਪਰਬੰਧਕ и ਉਪਭੋਗੀ ਨੂੰ. admin ਪ੍ਰਸ਼ਾਸਕ ਬਿਲਡਬੋਟ. ਉਪਭੋਗਤਾ ਵਚਨਬੱਧ ਵਿਅਕਤੀ ਹੈ ਕਮਿਟ ਕਰੋ-ਸ.

ਦੁਆਰਾ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਪਾਈਇੰਸਟਾਲਰ. ਦੁਆਰਾ ਦਸਤਾਵੇਜ਼ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ doxygen.

ਇਸ ਆਰਕੀਟੈਕਚਰ ਲਈ ਮੈਂ ਇਹ ਲਿਖਿਆ: 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 в /ਘਰ/ਹੈਬਰ/ਮਾਸਟਰ.

ਅਗਲਾ ਕਦਮ ਸੇਵਾ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ ਬਿਲਡਮਾਸਟਰaa

sudo buildbot start /home/habr/master

ਫਿਰ ਸੇਵਾ ਸ਼ੁਰੂ ਕਰੋ ਕਾਮਾ-a

buildbot-worker start /home/habr/worker

ਤਿਆਰ! ਹੁਣ ਬਿਲਡਬੋਟ ਤਬਦੀਲੀਆਂ ਨੂੰ ਟਰੈਕ ਕਰੇਗਾ ਅਤੇ ਟਰਿੱਗਰ ਕਰੇਗਾ ਕਮਿਟ ਕਰੋ-y ਵਿੱਚ svn, ਉਪਰੋਕਤ ਆਰਕੀਟੈਕਚਰ ਦੇ ਨਾਲ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣ ਅਤੇ ਟੈਸਟ ਕਰਨ ਦੇ ਕਦਮਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨਾ।

ਹੇਠਾਂ ਮੈਂ ਉਪਰੋਕਤ ਦੀਆਂ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਾਂਗਾ master.cfg.

6.1 ਤੁਹਾਡੇ master.cfg ਦੇ ਰਸਤੇ 'ਤੇ

ਲਿਖਣ ਵੇਲੇ ਮੇਰੀ master.cfg ਬਹੁਤ ਸਾਰੀਆਂ ਗਲਤੀਆਂ ਹੋਣਗੀਆਂ, ਇਸ ਲਈ ਲੌਗ ਫਾਈਲ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਬਿਲਡਮਾਸਟਰ-EC ਪੂਰਨ ਮਾਰਗ /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_alwaystrunk ਨਿਯਮ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ: ਫੋਲਡਰ ਬਣਤਰ ਨੂੰ ਕਿਵੇਂ ਤੋੜਨਾ ਹੈ svn ਸ਼ਾਖਾਵਾਂ 'ਤੇ. ਉਹ ਉਹਨਾਂ ਨੂੰ ਰਿਸ਼ਤੇਦਾਰ ਮਾਰਗ ਵੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ। ਇਸਦੀ ਵਾਰੀ ਵਿੱਚ 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]

ਉਹ ਸੁਨੇਹੇ ਭੇਜ ਸਕਦਾ ਹੈ ਵੱਖ-ਵੱਖ ਤਰੀਕੇ.

ਮੇਲ ਨੋਟੀਫਾਇਰ ਸੂਚਨਾਵਾਂ ਭੇਜਣ ਲਈ ਈਮੇਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

ਟੈਂਪਲੇਟ_html ਨਿਊਜ਼ਲੈਟਰ ਲਈ ਟੈਕਸਟ ਟੈਮਪਲੇਟ ਸੈੱਟ ਕਰਦਾ ਹੈ। HTML ਦੀ ਵਰਤੋਂ ਮਾਰਕਅੱਪ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਨੂੰ ਇੰਜਣ ਦੁਆਰਾ ਸੋਧਿਆ ਗਿਆ ਹੈ jinja2 (ਨਾਲ ਤੁਲਨਾ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ django). ਬਿਲਡਬੋਟ ਵਿੱਚ ਵੇਰੀਏਬਲਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੁੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸੁਨੇਹਾ ਟੈਕਸਟ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਟੈਂਪਲੇਟ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਵੇਰੀਏਬਲ {{ ਡਬਲ ਕਰਲੀ ਬਰੇਸ }} ਵਿੱਚ ਬੰਦ ਹਨ। ਉਦਾਹਰਣ ਲਈ, ਸਾਰ ਪੂਰੇ ਹੋਏ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਯਾਨੀ ਸਫਲਤਾ ਜਾਂ ਅਸਫਲਤਾ। ਏ ਪ੍ਰਾਜੈਕਟ ਆਉਟਪੁੱਟ ਕਰੇਗਾ ਤੁਹਾਡਾ ਪ੍ਰੋਜੈਕਟ. ਇਸ ਲਈ, ਕੰਟਰੋਲ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ jinja2, ਵੇਰੀਏਬਲ ਬਿਲਡਬੋਟ-a ਅਤੇ python ਸਟ੍ਰਿੰਗ ਫਾਰਮੈਟਿੰਗ ਟੂਲ, ਤੁਸੀਂ ਕਾਫ਼ੀ ਜਾਣਕਾਰੀ ਭਰਪੂਰ ਸੁਨੇਹਾ ਬਣਾ ਸਕਦੇ ਹੋ।

ਮੇਲ ਨੋਟੀਫਾਇਰ ਹੇਠ ਲਿਖੀਆਂ ਦਲੀਲਾਂ ਸ਼ਾਮਲ ਹਨ।

addr ਤੋਂ - ਉਹ ਪਤਾ ਜਿਸ ਤੋਂ ਹਰ ਕੋਈ ਨਿਊਜ਼ਲੈਟਰ ਪ੍ਰਾਪਤ ਕਰੇਗਾ।

InterestedUsers ਨੂੰ ਭੇਜੋ=ਸੱਚਾ ਮਾਲਕ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ ਜਿਸਨੇ ਬਣਾਇਆ ਹੈ ਕਮਿਟ ਕਰੋ.

ਝਾਂਕਨਾ — ਇੱਕ ਪਿਛੇਤਰ ਜੋ ਨਿਊਜ਼ਲੈਟਰ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਨਾਵਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਲਈ ਪਰਬੰਧਕ ਉਪਭੋਗਤਾ ਪਤੇ 'ਤੇ ਨਿਊਜ਼ਲੈਟਰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰੇਗਾ [ਈਮੇਲ ਸੁਰੱਖਿਅਤ].

relayhost ਹੋਸਟ-ਨਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਸਰਵਰ ਖੋਲ੍ਹਿਆ ਗਿਆ ਹੈ SMTP, ਇੱਕ smptPort ਸੁਣਨ ਵਾਲਾ ਪੋਰਟ ਨੰਬਰ ਦੱਸਦਾ ਹੈ SMTP ਸਰਵਰ

ਮੋਡ="ਚੇਤਾਵਨੀ" ਕਹਿੰਦਾ ਹੈ ਕਿ ਮੇਲਿੰਗ ਸਿਰਫ ਤਾਂ ਹੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਜੇਕਰ ਘੱਟੋ ਘੱਟ ਇੱਕ ਕਦਮ ਹੈ ਨੂੰ ਬਣਾਉਣ-a, ਜੋ ਸਥਿਤੀ ਦੀ ਅਸਫਲਤਾ ਜਾਂ ਚੇਤਾਵਨੀ ਦੇ ਨਾਲ ਖਤਮ ਹੋਇਆ। ਸਫਲਤਾ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇੱਕ ਨਿਊਜ਼ਲੈਟਰ ਭੇਜਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ.

ਵਾਧੂ ਪ੍ਰਾਪਤਕਰਤਾ ਮਾਲਕ ਅਤੇ ਉਸ ਵਿਅਕਤੀ ਤੋਂ ਇਲਾਵਾ ਜਿਨ੍ਹਾਂ ਨੂੰ ਡਾਕ ਭੇਜੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ ਕਮਿਟ ਕਰੋ.

ਸੁਨੇਹਾ ਫਾਰਮੈਟਰ ਇੱਕ ਵਸਤੂ ਹੈ ਜੋ ਸੁਨੇਹਾ ਫਾਰਮੈਟ, ਇਸਦੇ ਟੈਂਪਲੇਟ, ਅਤੇ ਇਸ ਤੋਂ ਉਪਲਬਧ ਵੇਰੀਏਬਲਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ jinja2. ਵਿਕਲਪ ਜਿਵੇਂ ਕਿ wantProperties=ਸੱਚਾ и wantSteps=ਸੱਚਾ ਉਪਲਬਧ ਵੇਰੀਏਬਲਾਂ ਦੇ ਇਸ ਸੈੱਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।

ਨਾਲ['services']=[sendMessageToAll] ਸੇਵਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਾਡੀ ਹੋਵੇਗੀ ਰਿਪੋਰਟਰ.

ਅਸੀਂ ਇਹ ਕੀਤਾ! ਵਧਾਈਆਂ

ਅਸੀਂ ਆਪਣੀ ਖੁਦ ਦੀ ਸੰਰਚਨਾ ਬਣਾਈ ਹੈ ਅਤੇ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਦੇਖਿਆ ਹੈ ਜੋ ਇਹ ਸਮਰੱਥ ਹੈ. ਬਿਲਡਬੋਟ. ਇਹ, ਮੈਨੂੰ ਲਗਦਾ ਹੈ, ਇਹ ਸਮਝਣ ਲਈ ਕਾਫ਼ੀ ਹੈ ਕਿ ਕੀ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇਸ ਸਾਧਨ ਦੀ ਲੋੜ ਹੈ ਜਾਂ ਨਹੀਂ. ਕੀ ਤੁਸੀਂ ਉਸ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ? ਕੀ ਇਹ ਤੁਹਾਡੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ? ਕੀ ਉਹ ਕੰਮ ਕਰਨ ਲਈ ਆਰਾਮਦਾਇਕ ਹੈ? ਫਿਰ ਮੈਂ ਇਹ ਲੇਖ ਵਿਅਰਥ ਨਹੀਂ ਲਿਖ ਰਿਹਾ।

ਅਤੇ ਅੱਗੇ. ਮੈਂ ਪੇਸ਼ੇਵਰ ਭਾਈਚਾਰੇ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹਾਂਗਾ ਬਿਲਡਬੋਟ, ਚੌੜਾ ਹੋ ਗਿਆ, ਮੈਨੂਅਲ ਅਨੁਵਾਦ ਕੀਤੇ ਗਏ, ਅਤੇ ਹੋਰ ਵੀ ਉਦਾਹਰਨਾਂ ਸਨ।

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਸਭ ਦਾ ਧੰਨਵਾਦ। ਖੁਸ਼ਕਿਸਮਤੀ.

ਸਰੋਤ: www.habr.com