ਕ੍ਰੋਨ ਜੌਬਸ ਸੰਰਚਨਾ

ਕ੍ਰੋਨ is a commonly confusing and misconfigured aspect of the operating system. Technically, cron is just the clock daemon (/usr/sbin/cron or perhaps /usr/sbin/crond) that executes commands at specific times. However, a handful of configuration files and programs go into making up the cron package. Like many system processes, cron never ends.

The controlling files for cron are the cron-tables or crontabs. The crontabs are often located in /var/spool/cron/crontab. However, on SuSE you will find them in /var/spool/cron/tabs. The names of the files in this directory are the names of the users that submit the cron jobs.

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

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

ਸ਼ੁਰੂ ਵਿੱਚ, ਇਹ ਥੋਡ਼ਾ ਤੰਗ ਕਰਨ ਵਾਲਾ ਲੱਗ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਆਓ ਇੱਕ ਨੌਕਰੀ ਨੂੰ "ਜੋਡ਼ਨ" ਦੀ ਪ੍ਰਕਿਰਿਆ ਉੱਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ। ਇੱਕ ਕ੍ਰੋਨ ਨੌਕਰੀ ਨੂੰ ਜੋਡ਼ਨ ਲਈ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ-l ਵਿਕਲਪ ਦੇ ਨਾਲ ਮੌਜੂਦਾ ਕ੍ਰੋਨਟੈਬ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ root ਹੋ ਅਤੇ ਕਿਸੇ ਹੋਰ ਉਪਭੋਗਤਾ ਦੇ ਕ੍ਰੋਨਟੈਬ ਵਿੱਚ ਕੁਝ ਜੋਡ਼ਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ-u ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਸ ਤੋਂ ਬਾਅਦ ਉਪਭੋਗਤਾ ਦਾ ਲੌਗਨਮ ਹੈ। ਫਿਰ ਇਸ ਕ੍ਰੋਨਟੈਬ ਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਮੁਡ਼ ਨਿਰਦੇਸ਼ਿਤ ਕਰੋ, ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਫਿਰ ਸੰਪਾਦਿਤ ਕਰ ਸਕਦੇ ਹੋ। (ਨੋਟ ਕਰੋ ਕਿ ਕੁਝ ਸਿਸਟਮਾਂ ਉੱਤੇ ਕ੍ਰੋਨਟੈਬ ਵਿੱਚ-e ("ਸੋਧ" ਲਈ) ਹੈ, ਜੋ ਤੁਹਾਡੇ ਲਈ ਸਾਰਾ ਕੰਮ ਕਰੇਗਾ। ਵਧੇਰੇ ਵੇਰਵਿਆਂ ਲਈ ਮੈਨ-ਪੇਜ ਦੇਖੋ।)

ਉਦਾਹਰਨ ਲਈ, ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ root ਉਪਭੋਗਤਾ ਹੋ ਅਤੇ ਯੂ. ਯੂ. ਸੀ. ਪੀ. ਉਪਭੋਗਤਾ ਦੇ ਕ੍ਰੋਨਟੈਬ ਵਿੱਚ ਕੁਝ ਜੋਡ਼ਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਪਹਿਲਾਂ, ਇਸ ਕਮਾਂਡ ਨਾਲ ਮੌਜੂਦਾ ਕ੍ਰੋਨਟੈਬ ਐਂਟਰੀ ਦਾ ਆਉਟਪੁੱਟ ਪ੍ਰਾਪਤ ਕਰੋ।

crontab -l -u uucp >/tmp/crontab.uucp

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

The file /tmp/crontab.uucp now contains the contents of UUCPs crontab. It might look something like this:

39,9 * * * * /usr/lib/uucp/uudemon.hour > /dev/null
10 * * * * /usr/lib/uucp/uudemon.poll > /dev/null
45 23 * * * ulimit 5000; /usr/lib/uucp/uudemon.clean > /dev/null
48 10,14 * * 1-5 /usr/lib/uucp/uudemon.admin > /dev/null

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

ਮਿੰਟ (0-59)
ਘੰਟਾ (0-23)
ਮਹੀਨੇ ਦਾ ਦਿਨ (1-31)
ਸਾਲ ਦਾ ਮਹੀਨਾ (1-12)
ਹਫ਼ਤੇ ਦਾ ਦਿਨ (0-6,0 = ਐਤਵਾਰ)
ਸਾਰੇ ਸੰਭਵ ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ, ਇੱਕ ਐਸਟਰਿਸਕ (*) ਦੀ ਵਰਤੋਂ ਕਰੋ। ਤੁਸੀਂ ਸਿਰਫ਼ ਉਸ ਇੱਕ ਮੁੱਲ ਨੂੰ ਸ਼ਾਮਲ ਕਰਕੇ ਇੱਕ ਸਿੰਗਲ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਣ ਵਜੋਂ, ਪਿਛਲੀ ਉਦਾਹਰਣ ਵਿੱਚ ਦੂਜੀ ਲਾਈਨ ਦਾ ਮੁੱਲ ਪਹਿਲੇ ਖੇਤਰ ਵਿੱਚ 10 ਹੈ, ਭਾਵ ਘੰਟੇ ਤੋਂ 10 ਮਿੰਟ ਬਾਅਦ। ਕਿਉਂਕਿ ਬਾਕੀ ਸਾਰੇ ਚਾਰ ਟਾਈਮ ਫੀਲਡ ਐਸਟਰਿਸਕਸ ਹਨ, ਇਸ ਦਾ ਅਰਥ ਹੈ ਕਿ ਕਮਾਂਡ ਹਰ ਦਿਨ ਦੇ ਹਰ ਘੰਟੇ ਨੂੰ ਘੰਟੇ ਤੋਂ 10 ਮਿੰਟ ਬਾਅਦ ਚੱਲਦੀ ਹੈ।

ਮੁੱਲਾਂ ਦੀਆਂ ਸੀਮਾਵਾਂ ਪਹਿਲੇ ਮੁੱਲ, ਇੱਕ ਡੈਸ਼ ਅਤੇ ਅੰਤਿਮ ਮੁੱਲ ਨਾਲ ਬਣੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਉਦਾਹਰਣ ਵਜੋਂ, ਚੌਥੀ ਲਾਈਨ ਵਿੱਚ ਹਫ਼ਤੇ ਦੇ ਕਾਲਮ ਦੇ ਦਿਨ ਇੱਕ ਸੀਮਾ (1-5) ਹੁੰਦੀ ਹੈ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕਮਾਂਡ ਸਿਰਫ 1-5 ਦਿਨਾਂ, ਸੋਮਵਾਰ ਤੋਂ ਸ਼ੁੱਕਰਵਾਰ ਤੱਕ ਚਲਾਈ ਜਾਂਦੀ ਹੈ।

ਵੱਖ-ਵੱਖ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਜੋ ਇੱਕ ਸੀਮਾ ਦੇ ਅੰਦਰ ਨਹੀਂ ਹਨ, ਵਿਅਕਤੀਗਤ ਮੁੱਲਾਂ ਨੂੰ ਇੱਕ ਕੋਮਾ ਦੁਆਰਾ ਵੱਖ ਕਰੋ। ਚੌਥੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਘੰਟੇ ਦੀ ਫੀਲਡ ਦੇ ਦੋ ਮੁੱਲ 10 ਅਤੇ 14 ਹਨ। ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ ਕਮਾਂਡ ਸਵੇਰੇ 10 ਵਜੇ ਅਤੇ ਦੁਪਹਿਰ 2 ਵਜੇ ਚੱਲਦੀ ਹੈ।

ਧਿਆਨ ਦਿਓ ਕਿ ਸਮਾਂ ਜੋਡ਼ ਯੋਗ ਹੁੰਦਾ ਹੈ। ਆਓ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖੀਏਃ


10 * 1,16 * 1-5 /usr/local/bin/command


ਕਮਾਂਡ ਹਰ ਘੰਟੇ ਦੇ 10 ਮਿੰਟ ਬਾਅਦ ਪਹਿਲੇ ਅਤੇ ਸੋਲ੍ਹਵੇਂ ਦਿਨ, ਅਤੇ ਨਾਲ ਹੀ ਸੋਮਵਾਰ ਤੋਂ ਸ਼ੁੱਕਰਵਾਰ ਤੱਕ ਚਲਾਈ ਜਾਂਦੀ ਹੈ। ਜੇ ਪਹਿਲਾ ਜਾਂ ਸੋਲ੍ਹਵਾਂ ਹਫਤੇ ਦੇ ਅੰਤ ਵਿੱਚ ਹੁੰਦਾ, ਤਾਂ ਕਮਾਂਡ ਅਜੇ ਵੀ ਚੱਲਦੀ ਕਿਉਂਕਿ ਮਹੀਨੇ ਦਾ ਦਿਨ ਫੀਲਡ ਲਾਗੂ ਹੁੰਦਾ। ਹਾਲਾਂਕਿ, ਇਸ ਦਾ ਇਹ ਮਤਲਬ ਨਹੀਂ ਹੈ ਕਿ ਜੇ ਪਹਿਲਾ ਸੋਮਵਾਰ ਹੈ, ਤਾਂ ਕਮਾਂਡ ਦੋ ਵਾਰ ਚਲਾਈ ਜਾਂਦੀ ਹੈ।

ਕ੍ਰੋਨਟੈਬ ਐਂਟਰੀ ਨੂੰ ਸਿਰਫ਼ ਹਰ ਘੰਟੇ ਜਾਂ ਹਰ ਦਿਨ ਨਾਲੋਂ ਵੱਖ-ਵੱਖ ਅੰਤਰਾਲਾਂ'ਤੇ ਚਲਾਉਣ ਲਈ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਗ੍ਰੈਨੂਲਰਟੀ ਨੂੰ ਹਰ ਦੋ ਮਿੰਟ ਜਾਂ ਹਰ ਤਿੰਨ ਘੰਟੇ ਲਈ ਕ੍ਰੋਨਟੈਬ ਵਿੱਚ ਹਰੇਕ ਵਿਅਕਤੀਗਤ ਐਂਟਰੀ ਨੂੰ ਰੱਖੇ ਬਿਨਾਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਮੰਨ ਲਓ ਕਿ ਅਸੀਂ ਪਿਛਲੀ ਕਮਾਂਡ ਨੂੰ ਘੰਟੇ ਤੋਂ 10 ਮਿੰਟ ਬਾਅਦ ਨਹੀਂ, ਬਲਕਿ ਹਰ ਦਸ ਮਿੰਟ ਬਾਅਦ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਸੀ। ਅਸੀਂ ਇੱਕ ਐਂਟਰੀ ਕਰ ਸਕਦੇ ਸੀ ਜੋ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਸੀ।


0,10,20,30,40,50 * 1,16 * 1-5 /usr/local/bin/command


ਇਹ ਹਰ 10 ਮਿੰਟ ਵਿੱਚ ਚਲਦਾ ਹੈਃ ਘੰਟੇ ਦੇ ਸਿਖਰ'ਤੇ, 10 ਮਿੰਟ ਬਾਅਦ, 20 ਮਿੰਟ ਬਾਅਦ, ਆਦਿ। ਜੀਵਨ ਨੂੰ ਅਸਾਨ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਸਿਰਫ਼ ਇਸ ਤਰ੍ਹਾਂ ਐਂਟਰੀ ਬਣਾ ਸਕਦੇ ਹਾਂਃ


*/10 * 1,16 * 1-5 /usr/local/bin/command


ਇਹ ਸੰਟੈਕਸ ਕੁੱਝ ਪ੍ਰਸ਼ਾਸਕਾਂ ਲਈ ਨਵਾਂ ਹੋ ਸਕਦਾ ਹੈ। (ਇਹ ਮੇਰੇ ਲਈ ਸੀ।) ਸਲੈਸ਼ (/) ਕਹਿੰਦਾ ਹੈ ਕਿ ਵਿਸ਼ੇਸ਼ ਅੰਤਰਾਲ ਦੇ ਅੰਦਰ (ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਹਰ ਮਿੰਟ), ਹਰ ਮਿੰਟ ਵਿੱਚ ਕਮਾਂਡ ਚਲਾਓ; ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਹਰ 10 ਮਿੰਟ ਵਿੱਚ।

ਅਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਉਦੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹਾਂ ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਸੀਮਾ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ। ਉਦਾਹਰਣ ਵਜੋਂ, ਜੇ ਕੰਮ ਸਿਰਫ ਘੰਟੇ ਤੋਂ 20 ਮਿੰਟ ਬਾਅਦ ਅਤੇ ਘੰਟੇ ਤੋਂ 40 ਮਿੰਟ ਬਾਅਦ ਚੱਲਣਾ ਸੀ, ਤਾਂ ਐਂਟਰੀ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈਃ


20-40 * 1,16 * 1-5 /usr/local/bin/command


ਕੀ ਹੋਵੇਗਾ ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹ ਇਨ੍ਹਾਂ ਸਮਿਆਂ'ਤੇ ਚੱਲੇ, ਪਰ ਸਿਰਫ ਹਰ ਤਿੰਨ ਮਿੰਟ ਵਿੱਚ? ਲਾਈਨ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈਃ


20-40/3 * 1,16 * 1-5 /usr/local/bin/command


ਚੀਜ਼ਾਂ ਨੂੰ ਹੋਰ ਵੀ ਗੁੰਝਲਦਾਰ ਬਣਾਉਣ ਲਈ, ਤੁਸੀਂ ਕਹਿ ਸਕਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕਮਾਂਡ ਘੰਟੇ ਤੋਂ 20 ਮਿੰਟ ਬਾਅਦ ਹਰ ਦੋ ਮਿੰਟ ਵਿੱਚ, 20 ਤੋਂ 40 ਮਿੰਟ ਬਾਅਦ ਹਰ ਤਿੰਨ ਮਿੰਟ ਵਿੱਚ, ਫਿਰ 40 ਮਿੰਟ ਬਾਅਦ ਅਤੇ ਘੰਟੇ ਦੇ ਵਿਚਕਾਰ ਹਰ 5 ਮਿੰਟ ਵਿੱਚ ਚੱਲੇ।


0-20/2,21-40/3,41-59/5 * 1,16 * 1-5 /usr/local/bin/command


ਇੱਕ ਬਹੁਤ ਚੰਗੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਲੀਨਕਸ ਉਪਭਾਸ਼ਾਵਾਂ ਤੁਹਾਨੂੰ ਹਫ਼ਤੇ ਦੇ ਦਿਨਾਂ ਅਤੇ ਮਹੀਨਿਆਂ ਲਈ ਸੰਖੇਪ ਵਿੱਚ ਦੱਸਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ। ਇਹ ਯਾਦ ਰੱਖਣਾ ਬਹੁਤ ਅਸਾਨ ਹੈ ਕਿ fri 5 ਦੀ ਬਜਾਏ ਸ਼ੁੱਕਰਵਾਰ ਲਈ ਹੈ।

ਟਾਈਮ ਫੀਲਡਾਂ ਵਿੱਚ ਕੁੱਝ ਗਲਤੀਆਂ ਨੂੰ ਛੱਡ ਕੇ, ਗਲਤੀਆਂ ਦੀ ਰਿਪੋਰਟ ਉਦੋਂ ਤੱਕ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਜਦੋਂ ਤੱਕ ਕ੍ਰੋਨ ਕਮਾਂਡ ਨਹੀਂ ਚਲਾਉਂਦਾ। ਸਾਰੇ ਗਲਤੀ ਸੰਦੇਸ਼ ਅਤੇ ਆਉਟਪੁੱਟ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਮੇਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਘੱਟੋ ਘੱਟ ਕ੍ਰੋਨਟੈਬ ਮੈਨ-ਪੇਜ ਉਹੀ ਕਹਿੰਦਾ ਹੈ ਅਤੇ ਇਹ ਅਸਲ ਵਿੱਚ ਸੱਚ ਹੈ। ਹਾਲਾਂਕਿ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਪਿਛਲੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਦੇਖਦੇ ਹੋ, ਤੁਸੀਂ stdout ਨੂੰ/dev/null ਵੱਲ ਮੁਡ਼ ਨਿਰਦੇਸ਼ਿਤ ਕਰ ਰਹੇ ਹੋ। ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉੱਥੇ stderr ਨੂੰ ਵੀ ਮੁਡ਼ ਨਿਰਦੇਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਵੇਖੋਗੇ ਕਿ ਕੀ ਕੋਈ ਗਲਤੀਆਂ ਸਨ।

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

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

ਯਾਦ ਰੱਖੋ ਕਿ ਕ੍ਰੋਨ ਸਹੀ ਨਹੀਂ ਹੈ। ਇਹ ਆਪਣੇ ਆਪ ਨੂੰ ਹਰ ਮਿੰਟ ਦੇ ਸਿਖਰ ਨਾਲ ਸਮਕਾਲੀ ਕਰਦਾ ਹੈ। ਇੱਕ ਵਿਅਸਤ ਪ੍ਰਣਾਲੀ ਵਿੱਚ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਘਡ਼ੀ ਦੀਆਂ ਟਿੱਕਾਂ ਗੁਆ ਦਿੰਦੇ ਹੋ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਨਿਰਧਾਰਤ ਸਮੇਂ ਤੋਂ ਕੁਝ ਮਿੰਟਾਂ ਬਾਅਦ ਤੱਕ ਕੰਮ ਨਾ ਕੀਤਾ ਜਾਵੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਉੱਚ ਤਰਜੀਹਾਂ ਵਾਲੀਆਂ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵੀ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਕ੍ਰੋਨ ਦੇ ਕੰਮਾਂ ਵਿੱਚ ਦੇਰੀ ਕਰਦੀਆਂ ਹਨ। ਕੁੱਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, (ਖਾਸ ਕਰਕੇ ਬਹੁਤ ਵਿਅਸਤ ਪ੍ਰਣਾਲੀਆਂ ਉੱਤੇ) ਕੰਮਾਂ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੇ ਉਹ ਹਰ ਮਿੰਟ ਚੱਲਦੀਆਂ ਹਨ।

ਕ੍ਰੋਨ ਸਹੂਲਤ ਤੱਕ ਪਹੁੰਚ ਦੀ ਆਗਿਆ ਦੋ ਫਾਈਲਾਂ ਰਾਹੀਂ ਹੈ, ਦੋਵੇਂ/ਆਦਿ ਵਿੱਚ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਫਾਈਲ cron.allow ਹੈ, ਤਾਂ ਤੁਸੀਂ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿਹਡ਼ੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਕ੍ਰੋਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਹੈ। cron.deny ਕਹਿੰਦਾ ਹੈ ਕਿ ਕਿਸ ਨੂੰ ਵਿਸ਼ੇਸ਼ ਤੌਰ'ਤੇ ਕ੍ਰੋਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਆਗਿਆ ਨਹੀਂ ਹੈ। ਜੇ ਕੋਈ ਵੀ ਫਾਈਲ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਤਾਂ ਸਿਰਫ ਸਿਸਟਮ ਉਪਭੋਗਤਾਵਾਂ ਕੋਲ ਪਹੁੰਚ ਹੈ। ਹਾਲਾਂਕਿ, ਜੇ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਹਰ ਕਿਸੇ ਨੂੰ ਪਹੁੰਚ ਹੋਵੇ, ਤਾਂ ਇੱਕ ਐਂਟਰੀ cron.deny ਫਾਈਲ ਬਣਾਓ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਕਿਸੇ ਨੂੰ ਵੀ ਪਹੁੰਚ ਤੋਂ ਇਨਕਾਰ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

It is often useful for root to run jobs as a different user without having to switch users (for example, using the su command). Most Linux dialects provide a mechanism in the form of the /etc/crontab file. This file is typically only writable by root and in some cases, only root can read it (which is often necessary in high security environments). The general syntax is the same as the standard crontabs, with a couple of exceptions.

ਪਹਿਲਾ ਅੰਤਰ ਹੈਡਰ ਹੈ, ਜੋ ਤੁਸੀਂ ਇੱਥੇ ਦੇਖ ਸਕਦੇ ਹੋਃ


ਐੱਸਐੱਚਈਐੱਲਐੱਲ =/ਬਿਨ/ਐੱਸਐੱਚ
ਪਥ =/ਯੂ. ਐੱਸ. ਆਰ./ਬਿਨਃ/ਯੂ. ਐੱਸ. ਆਰ./ਐੱਸ. ਬੀ. ਐੱਨਃ/ਐੱਸ. ਬੀ. ਐੱਨਃ/ਐੱਸ. ਬੀ. ਐੱਨਃ/ਐੱਸ. ਐੱਸ. ਆਰ./ਲਿਬ/ਨਿਊਜ਼/ਬਿਨ
ਮੈਲਟੋ = root
#
#cron.hourly, cron.daily, cron.weekly, ਅਤੇ cron.monthly ਵਿੱਚ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਜਾਂਚ ਕਰੋ।
#

59 * * * * root rm -f /var/spool/cron/lastrun/cron.hourly
14 0 * * * root rm -f /var/spool/cron/lastrun/cron.daily
29 0 * * 6 root rm -f /var/spool/cron/lastrun/cron.weekly
44 0 1 * * root rm -f /var/spool/cron/lastrun/cron.monthly

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

The structure of the actual entries is pretty much the same with the exception of the user name (root in each case here). This way, the root users (or whoever can edit /etc/crontab) can define which user executes the command. Keep in mind that this can be a big security hole. If someone can write to this file, they can create an entry that runs as root and therefore has complete control of the system.

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

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

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

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


ਹੁਣ + 1 ਘੰਟਾ <ਕਮਾਂਡ _ ਲਿਸਟ


ਜਿੱਥੇ ਕਮਾਂਡ _ ਲਿਸਟ ਇੱਕ ਫਾਇਲ ਹੈ ਜਿਸ ਵਿੱਚ ਕਮਾਂਡਾਂ ਦੀ ਸੂਚੀ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਪਾਈਪ ਦੇ ਅੰਤ ਵਿੱਚ (ਜਾਂ ਬੈਚ) ਵੀ ਹੋ ਸਕਦਾ ਹੈ।


ਕੈਟ ਕਮਾਂਡ ਲਿਸਟ। ਹੁਣ + 1 ਘੰਟਾ

ਕੈਟ ਕਮਾਂਡ ਲਿਸਟ। ਬੈਚ (_ l)

Another interesting thing about both at and batch is that they create a kind of shell script to execute your command. When you run at or batch, a file is created in /usr/spool/cron/atjobs. This file contains the system variables that you would normally have defined, plus some other information that is contained in /usr/lib/cron.proto. This essentially creates an environment as though you had logged in.