วิธีการอ่านเชลล์สคริปต์ทั้งหมดก่อนที่จะรันมัน?

โดยปกติหากคุณแก้ไขการเจาะลึกการใช้สคริปต์ที่ทำงานอยู่ทั้งหมดมักจะเกิดข้อผิดพลาด

เท่าที่ฉันเข้าใจทุบตี (กระสุนอื่น ๆ ด้วย?) อ่านสคริปต์เพิ่มขึ้นดังนั้นถ้าคุณแก้ไขไฟล์สคริปต์ภายนอกมันเริ่มอ่านสิ่งผิดปกติ มีวิธีป้องกันไหม?

ตัวอย่าง:

sleep 20

echo test

หากคุณรันสคริปต์นี้ทุบตีจะอ่านบรรทัดแรก (พูด 10 ไบต์) และไปที่โหมดสลีป เมื่อดำเนินการต่ออาจมีเนื้อหาต่าง ๆ ในสคริปต์เริ่มต้นที่ 10 ไบต์ ฉันอาจจะอยู่ตรงกลางบรรทัดในสคริปต์ใหม่ ดังนั้นสคริปต์ที่ใช้งานจะเสียหาย

ใช่เชลล์bashโดยเฉพาะอย่างยิ่งระมัดระวังในการอ่านไฟล์ทีละบรรทัดดังนั้นมันจะทำงานเหมือนกับเมื่อคุณใช้แบบโต้ตอบ

คุณจะสังเกตเห็นว่าเมื่อไฟล์ไม่สามารถค้นหาได้ (เช่นไพพ์) ให้bashอ่านทีละหนึ่งไบต์เพื่อให้แน่ใจว่าจะไม่อ่าน\nอักขระที่ผ่านมา เมื่อไฟล์ถูก seekable มันเพิ่มประสิทธิภาพโดยการอ่านบล็อกเต็มรูปแบบได้ตลอดเวลา \nแต่ขอกลับไปหลังจากที่

นั่นหมายความว่าคุณสามารถทำสิ่งต่าง ๆ เช่น:

bash << \EOF
read var
var's content
echo "$var"
EOF

หรือเขียนสคริปต์ที่อัปเดตตัวเอง ซึ่งคุณจะไม่สามารถทำได้หากไม่ได้ให้การรับประกันแก่คุณ

ทีนี้มันเป็นเรื่องยากที่คุณต้องการทำสิ่งต่าง ๆ เช่นนั้นและตามที่คุณค้นพบคุณลักษณะนั้นมีแนวโน้มที่จะได้รับประโยชน์มากกว่าที่เป็นอยู่

เพื่อหลีกเลี่ยงคุณสามารถลองและตรวจสอบให้แน่ใจว่าคุณไม่ได้แก้ไขไฟล์ในสถานที่ (ตัวอย่างเช่นแก้ไขสำเนาและย้ายสำเนาในสถานที่ (เช่นsed -iหรือperl -piและบรรณาธิการบางคนทำเช่น))

หรือคุณสามารถเขียนสคริปต์ของคุณเช่น:

{
  sleep 20
  echo test
}; exit

(โปรดทราบว่าเป็นสิ่งสำคัญที่exitจะต้องอยู่ในบรรทัดเดียวกันกับ}; แม้ว่าคุณสามารถใส่ไว้ในวงเล็บปีกกาก่อนที่จะปิดหนึ่ง)

หรือ:

main() {
  sleep 20
  echo test
}
main "$@"; exit

เชลล์จะต้องอ่านสคริปต์จนถึงexitก่อนที่จะเริ่มทำอะไร เพื่อให้แน่ใจว่าเชลล์จะไม่อ่านจากสคริปต์อีกครั้ง

นั่นหมายความว่าสคริปต์ทั้งหมดจะถูกเก็บไว้ในหน่วยความจำ

ที่สามารถส่งผลกระทบต่อการแยกวิเคราะห์สคริปต์

ตัวอย่างเช่นในbash:

export LC_ALL=fr_FR.UTF-8
echo $'St\ue9phane'

จะส่งออกที่ U + 00E9 เข้ารหัสใน UTF-8 อย่างไรก็ตามหากคุณเปลี่ยนเป็น:

{
  export LC_ALL=fr_FR.UTF-8
  echo $'St\ue9phane'
}

\ue9จะได้รับการขยายตัวใน charset ที่อยู่ในผลในเวลาที่ถูกคำสั่งแยกวิเคราะห์ซึ่งในกรณีนี้คือก่อนที่จะexportคำสั่งจะถูกดำเนินการ

โปรดทราบด้วยว่าหากใช้คำสั่งsourceaka .พร้อมกับเชลล์บางตัวคุณจะมีปัญหาแบบเดียวกันกับไฟล์ที่มา

นั่นไม่ใช่กรณีที่bashแม้ว่าจะมีsourceคำสั่งอ่านแฟ้มอย่างเต็มที่ก่อนที่จะแปลความหมายของมัน หากเขียนbashเฉพาะคุณสามารถใช้สิ่งนั้นได้โดยเพิ่มเมื่อเริ่มต้นสคริปต์:

if [[ ! $already_sourced ]]; then
  already_sourced=1
  source "$0"; exit
fi

(ฉันจะไม่พึ่งพาสิ่งนั้นแม้ว่าคุณจะจินตนาการได้ว่าเวอร์ชันในอนาคตของbashสามารถเปลี่ยนพฤติกรรมที่สามารถมองเห็นได้ในปัจจุบันเป็นข้อ จำกัด (ทุบตีและ AT&T ksh เป็นเปลือกหอย POSIX เท่านั้นที่ทำงานเช่นนั้นเท่าที่จะบอก) และalready_sourcedกลอุบายนั้นค่อนข้างบอบบางเพราะถือว่าตัวแปรนั้นไม่ได้อยู่ในสภาพแวดล้อมไม่ต้องพูดถึงว่ามันส่งผลกระทบต่อเนื้อหาของตัวแปร BASH_SOURCE)

คุณเพียงแค่ต้องลบไฟล์ (เช่นคัดลอกลบเปลี่ยนชื่อคัดลอกกลับไปเป็นชื่อเดิม) ในความเป็นจริงผู้แก้ไขจำนวนมากสามารถกำหนดค่าให้ทำเช่นนี้เพื่อคุณ เมื่อคุณแก้ไขไฟล์และบันทึกบัฟเฟอร์ที่ถูกเปลี่ยนไปแทนที่การเขียนทับไฟล์มันจะเปลี่ยนชื่อไฟล์เก่าสร้างใหม่และสร้างเนื้อหาใหม่ในไฟล์ใหม่ ดังนั้นสคริปต์ที่รันควรดำเนินการต่อโดยไม่มีปัญหา

ด้วยการใช้ระบบควบคุมเวอร์ชันง่าย ๆ เช่น RCS ซึ่งพร้อมใช้งานสำหรับ vim และ emacs คุณจะได้รับประโยชน์สองอย่างของการมีประวัติของการเปลี่ยนแปลงของคุณและระบบการเช็คเอาท์ควรจะลบไฟล์ปัจจุบันและสร้างใหม่ด้วยโหมดที่ถูกต้อง (ระวังการเชื่อมโยงไฟล์ดังกล่าวแน่นอน)

วิธีที่ง่ายที่สุด:

{
  ... your code ...

  exit
}

ด้วยวิธีนี้ทุบตีจะอ่าน{}บล็อกทั้งหมดก่อนที่จะดำเนินการและexitคำสั่งจะทำให้แน่ใจว่าไม่มีอะไรจะอ่านนอกบล็อกรหัส

หากคุณไม่ต้องการ "รัน" สคริปต์ แต่ต้องการ "ซอร์ส" สคริปต์คุณต้องมีโซลูชันอื่น สิ่งนี้ควรใช้งานได้แล้ว:

{
  ... your code ...

  return 2>/dev/null || exit
}

หรือหากคุณต้องการควบคุมรหัสออกโดยตรง:

{
  ... your code ...

  ret="$?";return "$ret" 2>/dev/null || exit "$ret"
}

Voila! สคริปต์นี้มีความปลอดภัยในการแก้ไขแหล่งและดำเนินการ คุณยังต้องแน่ใจว่าคุณไม่ได้แก้ไขในมิลลิวินาทีเหล่านั้นเมื่อเริ่มอ่าน

พิสูจน์แนวคิด นี่คือสคริปต์ที่ปรับเปลี่ยนตัวเอง:

cat <<EOF >/tmp/scr
#!/bin/bash
sed  s/[k]ept/changed/  /tmp/scr > /tmp/scr2

# this next line overwites the on disk copy of the script
cat /tmp/scr2 > /tmp/scr
# this line ends up changed.
echo script content kept
EOF
chmod u+x /tmp/scr
/tmp/scr

เราเห็นการพิมพ์เวอร์ชันที่เปลี่ยนไป

นี่เป็นเพราะการโหลด bash ช่วยให้ตัวจัดการไฟล์เปิดให้สคริปต์ดังนั้นการเปลี่ยนแปลงไฟล์จะเห็นได้ทันที

หากคุณไม่ต้องการอัปเดตสำเนาในหน่วยความจำให้ยกเลิกการเชื่อมโยงไฟล์ดั้งเดิมและแทนที่

วิธีหนึ่งในการทำเช่นนั้นคือการใช้ sed -i

sed -i '' filename

พิสูจน์แนวคิด

cat <<EOF >/tmp/scr
#!/bin/bash
sed  s/[k]ept/changed/  /tmp/scr > /tmp/scr2

# this next line unlinks the original and creates a new copy.
sed -i ''  /tmp/scr

# now overwriting it has no immediate effect
cat /tmp/scr2 > /tmp/scr
echo script content kept
EOF

chmod u+x /tmp/scr
/tmp/scr

หากคุณกำลังใช้โปรแกรมแก้ไขเพื่อเปลี่ยนสคริปต์การเปิดใช้งานคุณลักษณะ "เก็บสำเนาสำรอง" อาจเป็นสิ่งที่จำเป็นทั้งหมดในการทำให้ตัวแก้ไขเขียนเวอร์ชันที่เปลี่ยนแปลงไปยังไฟล์ใหม่แทนที่จะเขียนทับไฟล์ที่มีอยู่เดิม

การตัดสคริปต์ของคุณในบล็อก{}น่าจะเป็นตัวเลือกที่ดีที่สุด แต่ต้องเปลี่ยนสคริปต์ของคุณ

F=$(mktemp) && cp test.sh $F && bash $F; rm $F;

จะเป็นตัวเลือกที่ดีที่สุดที่สอง (สมมติว่าtmpfs ) ข้อเสียคือมันแบ่ง $ 0 ถ้าสคริปต์ของคุณใช้มัน

การใช้บางอย่างเช่นF=test.sh; tail -n $(cat "$F" | wc -l) "$F" | bashนั้นไม่เหมาะอย่างยิ่งเพราะจะต้องเก็บไฟล์ทั้งหมดไว้ในหน่วยความจำและแบ่งเป็น $ 0

ควรหลีกเลี่ยงการสัมผัสไฟล์ต้นฉบับดังนั้นเวลาแก้ไขล่าสุดล็อคการอ่านและลิงก์ถาวรจะไม่ถูกรบกวน วิธีนี้ทำให้คุณสามารถเปิดโปรแกรมแก้ไขไว้ในขณะที่เรียกใช้ไฟล์และ rsync ไม่จำเป็นต้องตรวจสอบไฟล์สำหรับการสำรองข้อมูลและฮาร์ดลิงก์ตามที่คาดไว้

การแทนที่ไฟล์ในการแก้ไขจะใช้งานได้ แต่มีประสิทธิภาพน้อยกว่าเพราะไม่สามารถบังคับใช้กับสคริปต์ / ผู้ใช้ / หรืออาจลืมได้ และอีกครั้งมันจะทำลายการเชื่อมโยงอย่างหนัก