மார்செல் - லினக்ஸிற்கான ஒரு நவீன ஷெல்
மார்செல் ஒரு புதிய ஷெல். இது பல வழிகளில் பாரம்பரிய குண்டுகளுக்கு ஒத்ததாக இருக்கிறது, ஆனால் இது சில விஷயங்களை வித்தியாசமாக செய்கிறது:
- குழாய் பதித்தல்: ஒரு கட்டளையின் வெளியீட்டிலிருந்து இன்னொரு உரையின் உள்ளீட்டிற்கு ஒரு உரையை அனுப்ப அனைத்து குண்டுகளும் குழாய்களைப் பயன்படுத்துகின்றன. மார்செல் குழாய்களுக்கு பதிலாக கட்டமைக்கப்பட்ட தரவு.
- பைதான்: மார்செல் பைத்தானில் செயல்படுத்தப்படுகிறது, மேலும் பைத்தானை பல வழிகளில் அம்பலப்படுத்துகிறது. உங்கள் கட்டளைகளில் உங்களுக்கு கொஞ்சம் தர்க்கம் தேவைப்பட்டால், அதை பைத்தானில் வெளிப்படுத்த மார்செல் உங்களை அனுமதிக்கிறது.
- ஸ்கிரிப்டிங்: ஸ்கிரிப்ட்டுக்கு மார்செல் ஒரு அசாதாரண அணுகுமுறையை எடுக்கிறார். நீங்கள் நிச்சயமாக, ஒரு உரை கோப்பில் மார்செல் கட்டளைகளின் வரிசையை எழுதி அவற்றை இயக்கலாம். ஆனால் மார்செல் ஒரு பைதான் தொகுதி வடிவத்தில் ஒரு API ஐ வழங்குகிறது. எளிய பைதான் மூலம் சாத்தியமானதை விட மிகவும் வசதியான முறையில் பைதான் ஸ்கிரிப்டிங் செய்ய இந்த தொகுதியை நீங்கள் இறக்குமதி செய்யலாம்.
மார்செல் GPLv3 இன் கீழ் உரிமம் பெற்றது.
லினக்ஸில் மார்செல் மாடர்ன் ஷெல் நிறுவுதல்
மார்சலுக்கு பைதான் 3.6 அல்லது அதற்குப் பிறகு தேவைப்படுகிறது. இது லினக்ஸில் உருவாக்கப்பட்டது மற்றும் சோதிக்கப்பட்டது, இது பெரும்பாலும் மேகோஸில் இயங்குகிறது. (நீங்கள் விண்டோஸுக்கு துறைமுகத்திற்கு உதவ விரும்பினால் அல்லது மேகோஸ் குறைபாடுகளை சரிசெய்ய விரும்பினால், தொடர்பு கொள்ளுங்கள்.)
உங்கள் சொந்த பயன்பாட்டிற்காக மார்சலை நிறுவ:
# python3 -m pip install marcel
அல்லது எல்லா பயனர்களுக்கும் நீங்கள் நிறுவ விரும்பினால் (எ.கா., /usr/local
க்கு):
$ sudo python3 -m pip install --prefix /usr/local marcel
நீங்கள் மார்சலை நிறுவியதும், மார்செல் கட்டளையை இயக்குவதன் மூலம் அது செயல்படுகிறதா என்று சரிபார்க்கவும், பின்னர் மார்செல் வரியில், பதிப்பு கட்டளையை இயக்கவும்:
$ marcel
மார்செல் ஷெல்லின் தனிப்பயனாக்கம்
தொடக்கத்தில் படிக்கப்படும் ~/.marcel.py
கோப்பில் மார்சலைத் தனிப்பயனாக்கலாம் (மற்றும் மாற்றியமைக்கும்போது மீண்டும் படிக்கவும்). கோப்பின் பெயரிலிருந்து நீங்கள் சொல்லக்கூடியது போல, மார்சலின் தனிப்பயனாக்கம் பைத்தானில் செய்யப்படுகிறது.
நீங்கள் செய்ய விரும்பும் ஒரு விஷயம், வரியில் தனிப்பயனாக்க வேண்டும். இதைச் செய்ய, நீங்கள் PROMPT மாறிக்கு ஒரு பட்டியலை ஒதுக்குகிறீர்கள். எடுத்துக்காட்டாக, உங்கள் வரியில் தற்போதைய கோப்பகமாக இருக்க விரும்பினால், பச்சை நிறத்தில் அச்சிடப்பட்டு, அதைத் தொடர்ந்து >
நீல நிறத்தில் அச்சிடப்படும்:
PROMPT = [ Color(0, 4, 0), lambda: PWD, Color(0, 2, 5), '> ' ]
இதன் விளைவாக வரும் வரியில் இது போல் தெரிகிறது:
இது நீங்கள் செய்ய வேண்டிய PS1
உள்ளமைவை மாற்றுகிறது. நிறம் (0, 4, 0) பச்சை நிறத்தைக் குறிக்கிறது, (வாதங்கள் RGB மதிப்புகள், 0-5 வரம்பில்). PWD என்பது உங்கள் தற்போதைய கோப்பகத்தைக் குறிக்கும் சூழல் மாறி மற்றும் lambda:
உடன் இந்த மாறியை முன்னொட்டுகிறது ஒரு செயல்பாட்டை உருவாக்குகிறது, ஒவ்வொரு முறையும் கேட்கப்படும் போது மதிப்பீடு செய்யப்படுகிறது.
~/.marcel.py
பைதான் தொகுதிகளையும் இறக்குமதி செய்யலாம். எ.கா., உங்கள் மார்செல் கட்டளைகளில் கணித தொகுதியின் செயல்பாடுகளைப் பயன்படுத்த விரும்பினால்:
from math import *
நீங்கள் இதைச் செய்தவுடன், அந்த தொகுதியிலிருந்து சின்னங்களைக் குறிப்பிடலாம், எ.கா. பை குறியீடு>:
பை
அடைப்புக்குறிப்பு என்பதை நினைவில் கொள்க. பொதுவாக, பைதான் வெளிப்பாடுகளை வரையறுக்க மார்செல் அடைப்புக்குறிகளைப் பயன்படுத்துகிறது. எனவே (pi)
பைதான் வெளிப்பாட்டை மதிப்பிடுகிறது, இது மாறி pi இன் மதிப்பை மீட்டெடுக்கிறது. இந்த வழியில் நீங்கள் பாரம்பரிய சூழல் மாறிகளையும் அணுகலாம், எ.கா. (USER) மற்றும் (HOME), அல்லது மார்சலின் பெயர்வெளியில் உள்ள சின்னங்களை நம்பியிருக்கும் சரியான பைதான் வெளிப்பாடு.
நீங்கள் நிச்சயமாக, உங்கள் சொந்த சின்னங்களை வரையறுக்கலாம். எடுத்துக்காட்டாக, இந்த செயல்பாட்டு வரையறையை ~/.marcel.py
இல் வைத்தால்:
def factorial(n): f = 1 for i in range(1, n + 1): f *= i return f
நீங்கள் கட்டளை வரியில் காரணி செயல்பாட்டைப் பயன்படுத்தலாம், எ.கா.
மார்செல் ஷெல் எடுத்துக்காட்டுகள்
இங்கே, மார்செல் ஷெல்லில் கட்டளைகளின் சில எடுத்துக்காட்டுகளைக் கற்றுக்கொள்வோம்.
தற்போதைய கோப்பகத்தை மீண்டும் மீண்டும் ஆராய்ந்து, கோப்புகளை அவற்றின் நீட்டிப்பு மூலம் தொகுக்கவும் (எ.கா. .txt
, .py
மற்றும் பல), மேலும் ஒவ்வொரு குழுவிற்கும் மொத்த கோப்பு அளவைக் கணக்கிடுங்கள்.
இதை நீங்கள் பின்வருமாறு மார்சலில் செய்யலாம்:
எல்எஸ் ஆபரேட்டர் கோப்பு பொருள்களின் ஸ்ட்ரீமை உருவாக்குகிறது, ( -fr
என்றால் கோப்பகங்களை மீண்டும் மீண்டும் பார்வையிடவும், கோப்புகளை மட்டும் திருப்பி விடவும்).
கோப்பு பொருள்கள் அடுத்த கட்டளை, வரைபடத்திற்கு அனுப்பப்படுகின்றன. வரைபடம் ஒரு பைதான் செயல்பாட்டைக் குறிப்பிடுகிறது, வெளிப்புற அடைப்புக்குறிக்குள், இது ஒவ்வொரு கோப்பையும் கோப்பின் நீட்டிப்பைக் கொண்ட ஒரு டூப்பிளுக்கு வரைபடமாக்குகிறது, மேலும் அது அளவு. (மார்செல் லாம்ப்டா முக்கிய சொல்லை தவிர்க்க அனுமதிக்கிறது.)
சிவப்பு (குறைத்தல்) ஆபரேட்டர், டூப்பிளின் (நீட்டிப்பு) முதல் பகுதியால் குழுக்கள், பின்னர் ஒவ்வொரு குழுவிலும் உள்ள அளவுகளை தொகுக்கலாம். இதன் விளைவாக நீட்டிப்பு மூலம் வரிசைப்படுத்தப்படுகிறது.
பைப்லைன்களில் மார்செல் ஆபரேட்டர்கள் மற்றும் ஹோஸ்ட் இயங்கக்கூடியவைகளின் கலவை இருக்கலாம். ஆபரேட்டர்கள் குழாய் பொருள்கள், ஆனால் ஆபரேட்டர்/இயங்கக்கூடிய எல்லைகளில், அதற்கு பதிலாக மார்செல் குழாய்களின் சரங்கள்.
எடுத்துக்காட்டாக, இந்த கட்டளை ஆபரேட்டர்கள் மற்றும் இயங்கக்கூடியவற்றை ஒருங்கிணைத்து, ஷெல் /bin/bash
ஆக இருக்கும் பயனர்களின் பயனர்பெயர்களை பட்டியலிடுகிறது.
$ cat /etc/passwd \ | map (line: line.split(':')) \ | select (*line: line[-1] == '/bin/bash') \ | map (*line: line[0]) \ | xargs echo
பூனை ஒரு லினக்ஸ் இயங்கக்கூடியது. இது/etc/passwd ஐப் படிக்கிறது, மற்றும் மார்செல் அதன் உள்ளடக்கங்களை மார்செல் ஆபரேட்டர் வரைபடத்திற்கு கீழ்நோக்கி செலுத்துகிறது.
வரைபடத்திற்கான அடைப்புக்குறிப்பு வாதம் ஒரு பைதான் செயல்பாடாகும், இது :
பிரிப்பான்களில் வரிகளைப் பிரிக்கிறது, இது 7-டுப்பிள்களைக் கொடுக்கும். ஒரு தேர்வு என்பது ஒரு மார்செல் ஆபரேட்டராகும், இதன் வாதம் பைதான் செயல்பாடு ஆகும், இது கடைசி புலம்/பின்/பாஷ் ஆகும்.
அடுத்த ஆபரேட்டர், மற்றொரு வரைபடம் ஒவ்வொரு உள்ளீட்டு டூப்பிளின் பயனர்பெயர் புலத்தை வைத்திருக்கிறது. இறுதியாக, xargs எதிரொலி உள்வரும் பயனர்பெயர்களை ஒரு வரியாக இணைக்கிறது, இது stdout க்கு அச்சிடப்படுகிறது.
மார்செல் ஷெல்லில் ஸ்கிரிப்டிங்
பைதான் சில நேரங்களில் ஸ்கிரிப்டிங் மொழியாகக் கருதப்பட்டாலும், அது உண்மையில் அந்த நோக்கத்திற்காக சிறப்பாக செயல்படாது. சிக்கல் என்னவென்றால், ஷெல் கட்டளைகளை இயக்குவது, மற்றும் பைத்தானிலிருந்து பிற இயங்கக்கூடியவை சிக்கலானவை. நீங்கள் os.system()
ஐப் பயன்படுத்தலாம், இது stdin, stdout மற்றும் stderr உடன் கையாள்வதற்கு எளிமையானது ஆனால் பெரும்பாலும் போதாது. subprocess.Popen()
மிகவும் சக்திவாய்ந்த ஆனால் பயன்படுத்த மிகவும் சிக்கலானது.
மார்சலின் அணுகுமுறை மார்செல் ஆபரேட்டர்களை பைத்தானின் மொழி அம்சங்களுடன் ஒருங்கிணைக்கும் ஒரு தொகுதியை வழங்குவதாகும். முந்தைய உதாரணத்தை மறுபரிசீலனை செய்ய, கோப்பு அளவுகளின் தொகையை நீட்டிப்பு மூலம் கணக்கிடுவதற்கான பைதான் குறியீடு இங்கே:
from marcel.api import * for ext, size in (ls(file=True, recursive=True) | map(lambda f: (f.suffix, f.size)) | red('.', '+')): print(f'{ext}: {size})
ஷெல் கட்டளைகள் முந்தையதைப் போலவே இருக்கின்றன, தொடரியல் மரபுகளைத் தவிர. எனவே ls -fr
ls ஆக மாறுகிறது (கோப்பு = உண்மை, சுழல்நிலை = உண்மை). ஷெல் பதிப்பைப் போலவே, வரைபடமும் சிவப்பு ஆபரேட்டர்களும் குழாய்களுடன் இணைக்கப்பட்டுள்ளன. முழு ஷெல் கட்டளை (ls… red) ஒரு பைதான் மறு செய்கையை அளிக்கிறது, இதனால் கட்டளையை பைத்தானுடன் ஒரு வட்டத்திற்கு பயன்படுத்தலாம்.
மார்செல் ஷெல் உடன் தரவுத்தள அணுகல்
நீங்கள் தரவுத்தள அணுகலை மார்செல் குழாய்களுடன் ஒருங்கிணைக்க முடியும். முதலில், நீங்கள் கட்டமைப்பு கோப்பில் தரவுத்தள அணுகலை உள்ளமைக்க வேண்டும், ~/.marcel.py
, எ.கா.
define_db(name='jao', driver='psycopg2', dbname='acme', user='jao') DB_DEFAULT = 'jao'
இது psycopg2 இயக்கியைப் பயன்படுத்தி acme என்ற போஸ்ட்கிரெஸ் தரவுத்தளத்திற்கான அணுகலை உள்ளமைக்கிறது. ஜாவோ பயனரைப் பயன்படுத்தி மார்சலில் இருந்து இணைப்புகள் செய்யப்படும், மேலும் தரவுத்தள சுயவிவரத்திற்கு ஜாவோ என்று பெயரிடப்பட்டுள்ளது. (DB_DEFAULT எந்த சுயவிவரமும் குறிப்பிடப்படாவிட்டால் பயன்படுத்தப்பட வேண்டிய ஜாவோ தரவுத்தள சுயவிவரத்தைக் குறிப்பிடுகிறது.) இந்த உள்ளமைவுடன், தரவுத்தளத்தை இப்போது SQL ஆபரேட்டரைப் பயன்படுத்தி வினவலாம், எ.கா.
sql 'select part_name, quantity from part where quantity < 10' \ | out --csv –-file ~/reorder.csv
இந்த கட்டளை பகுதி என்ற அட்டவணையை வினவுகிறது, மேலும் வினவல் முடிவை CSV வடிவத்தில் ~/reorder.csv
கோப்பில் செலுத்துகிறது.
மார்செல் ஷெல்லுடன் தொலைநிலை அணுகல்
தரவுத்தள அணுகலைப் போலவே, தொலைநிலை அணுகலை ~/.marcel.py
இல் கட்டமைக்க முடியும். எடுத்துக்காட்டாக, இது 4-முனை கிளஸ்டரை உள்ளமைக்கிறது:
define_remote(name='lab', user='frankenstein', identity='/home/frankenstein/.ssh/id_rsa', host=['10.0.0.100', '10.0.0.101', '10.0.0.102', '10.0.0.103'])
கொத்து மார்செல் கட்டளைகளில் ஒரு ஆய்வகமாக அடையாளம் காணப்படலாம். பயனர் மற்றும் அடையாள அளவுருக்கள் உள்நுழைவு தகவலைக் குறிப்பிடுகின்றன, மேலும் ஹோஸ்ட் அளவுரு கிளஸ்டரில் உள்ள முனைகளின் ஐபி முகவரிகளைக் குறிப்பிடுகிறது.
கொத்து கட்டமைக்கப்பட்டதும், அனைத்து முனைகளையும் ஒரே நேரத்தில் இயக்க முடியும். எடுத்துக்காட்டாக, கிளஸ்டர் முழுவதும் செயல்முறை பிட்கள் மற்றும் கட்டளை வரிகளின் பட்டியலைப் பெற:
@lab [ps | map (proc: (proc.pid, proc.commandline))]
இது (ஐபி முகவரி, பிஐடி, கட்டளை வரி) டுபில்களின் ஸ்ட்ரீமை வழங்குகிறது.
மேலும் தகவலுக்கு வருகை:
- https://www.marceltheshell.org/
- https://github.com/geophile/marcel
மார்செல் மிகவும் புதியது மற்றும் செயலில் வளர்ச்சியில் உள்ளது. நீங்கள் உதவ விரும்பினால் தொடர்பு கொள்ளுங்கள்.