pull-filter పాఠ్యాన్ని సరిపోల్చుతుంది, సబ్నెట్లను కాదు: దాన్ని ప్రిఫిక్స్గా చదవండి

ఉద్దేశ్యం నెట్టబడిన ఒక మార్గాన్ని వదిలించడం. మార్పు తర్వాత మరో రూటింగ్ ఎంపిక లేదు, లేదా క్లయింట్ లూప్లో మళ్లీ కనెక్ట్ అవుతుంది. రెండు ఫలితాలూ ఫిల్టర్ పాఠ్యాన్ని పోలుస్తున్నప్పుడు దాన్ని సబ్నెట్ నియమంగా చదవడం వల్ల వస్తాయి. క్లయింట్ నెట్టబడిన ఎంపిక మీరు ఇచ్చిన అక్షరాలతో మొదలవుతుందో లేదో తనిఖీ చేస్తుంది, ఏ దశలోనూ చిరునామా తర్కం పాల్గొనదు.

ఫిల్టర్ నిజంగా ఏమి పోలుస్తుంది

ప్రతి నెట్టబడిన ఎంపిక పేరు మరియు దాని ఆర్గ్యుమెంట్లతో ఏర్పడిన పంక్తిగా వస్తుంది. ఫిల్టర్ మీ అక్షరాలను ఆ పంక్తి ప్రారంభంతో పోలుస్తుంది, ఏ చిరునామా విశ్లేషించబడక ముందే మరియు ఏ మార్గం ఇన్స్టాల్ కాక ముందే. అందుకే ఒక పేరు కోసం రాసిన నియమం ఆ అక్షరాలతో మొదలయ్యే ప్రతి ఎంపికను పడుతుంది, మీరు చూస్తున్నది ఒక్కటే కాదు. అందుకే ఫిల్టర్ విడిగా సరిగ్గా కనిపించినా సంబంధం లేని దాన్ని తీసేయగలదు.

నెట్వర్క్ పరిధిలా కనిపించే స్ట్రింగ్ ఇంకా అక్షరాలే. అది ఏ ప్రిఫిక్స్నూ ఎంచుకోదు, నెట్వర్క్ బిట్లపై లెక్క చేయదు, గమ్యాల సమితిని వ్యక్తపరచలేదు. అలాంటి నియమం పని చేస్తున్నట్టు కనిపించి తర్వాత ఆగిపోతే, నెట్టబడిన పాఠ్యం సాధారణంగా ఆకారం మార్చుకుంది.

ఒక ఖాళీ సరిపోలికల సమితిని మారుస్తుంది

అదే ఎంపిక పేరు చివరి విభజనతో మరియు దాని లేకుండా వేర్వేరు పంక్తులను ఎంచుకుంటుంది. విభజన లేకుండా సరిపోలిక తెరిచే ఉంటుంది, దానితో ఆర్గ్యుమెంట్లు మొదలయ్యే ముందు ఎంపిక పేరు సరిగ్గా అక్కడే ముగియాలి.

pull-filter ignore "route"
pull-filter ignore "route "

తెరిచిన రూపం అదే అక్షరాలతో మాత్రమే మొదలయ్యే ఎంపికలనూ పడుతుంది, అలా మీరు వదిలించాలనుకున్న మార్గంతో పాటు సంబంధం లేని రూటింగ్ ప్రవర్తన కూడా మాయమవుతుంది. ఫిల్టర్ రాసే ముందు లాగ్ నుండి నెట్టబడిన పంక్తిని కాపీ చేయండి. సవరించిన ప్రొఫైల్ పక్కన మార్చని కాపీని ఉంచండి, ఎందుకంటే విశాల సరిపోలికను జ్ఞాపకం నుండి కాకుండా ఫైల్ నుండి తిరిగి తీసుకోవడం సులభం.

క్రమం మరియు చర్య వేర్వేరు లక్షణాలను కలిగిస్తాయి

నియమాలు క్రమంగా మూల్యాంకనం అవుతాయి, మొదటి సరిపోలిక ఫలితాన్ని నిర్ణయిస్తుంది, కాబట్టి ముందుగా ఉంచిన విశాల నియమం తర్వాతి ప్రతి నిర్దిష్ట నియమాన్ని అందుబాటులో లేనిదిగా చేస్తుంది. చర్య కూడా లోపాన్ని మారుస్తుంది: సరిపోలికను పట్టించుకోకపోతే ఎంపిక వదిలిపోయి సెషన్ కొనసాగుతుంది, తిరస్కరిస్తే కనెక్షన్ను మళ్లీ ప్రారంభించే లోపం లేస్తుంది. అందుకే పదే పదే నెట్టబడే పంక్తి తిరస్కరణ చర్యతో కలిసి పునఃకనెక్షన్ చక్రాన్ని కలిగిస్తుంది. ఆ చక్రాన్ని నెట్వర్క్ లోపంగా చదవడం సులభం, సరిపోలిన ఎంపికను పేర్కొనే లాగ్ పంక్తి రెండింటినీ వేరు చేస్తుంది.

ఏ పంక్తి సరిపోలింది, ఏ చర్య జరిగింది నమోదు చేయండి. వదిలించిన మార్గానికి, పునఃప్రారంభ చక్రానికి వేర్వేరు మరమ్మతులు కావాలి, రెండింటినీ తెరిచే ఉంచకుండా ఏది జరిగిందో గమనిక చెప్పాలి.

హోస్ట్ ఏమి ఇన్స్టాల్ చేసిందో తనిఖీ చేయండి

మళ్లీ కనెక్ట్ అయిన తర్వాత వర్తించిన మార్గాలను చదవండి, మీరు ఉంచుకోదలచిన గమ్యాన్ని మరియు తీసేయదలచిన దాన్ని పరీక్షించండి. నెట్టబడిన మార్గాన్ని వదిలించడం ఏ ప్రత్యామ్నాయాన్నీ ఇవ్వదు, కాబట్టి అనవసర మార్గం పోయినప్పుడు వనరు మరో మార్గంలో అందుబాటులో లేకపోవచ్చు. ఇప్పుడు ఒక పేరు మరెక్కడో పరిష్కారమవుతుంటే, నెట్టబడిన రిజాల్వర్ ఎంపిక అదే విశాల ప్రిఫిక్స్ పట్టిందో లేదో చూడండి. మీరు నడిపిన పరీక్షలో ఉత్తీర్ణమై ఉద్దేశించిన పరీక్షలో విఫలమయ్యే మార్పు ఇక్కడ సాధారణ ఫలితం.

ఆ భేదాన్ని టికెట్లో ఉంచండి: మీరు తీసేసిన మార్గం, ఉంచుకోవాలని ఆశించిన మార్గం, ఇప్పుడు పట్టిక చూపుతున్నది. తదుపరి మార్పు ఆ నమోదుకు వ్యతిరేకంగా అంచనా వేయబడుతుంది.

దాన్ని విశ్వాస సరిహద్దుగా పరిగణించవద్దు

పాఠ్యంపై ఫిల్టర్ అనేది కాన్ఫిగరేషన్ సౌలభ్యం, మీరు నమ్మని సర్వర్పై నియంత్రణ కాదు. ఆకృతి భేదాలే దాన్ని ఓడిస్తాయి, అందుకే మాన్యువల్ ఆ వాదనను పరిమితం చేస్తుంది. సర్వర్ మీ సంస్థదైతే, స్థానిక మినహాయింపులు సేకరించడం కంటే పుష్ విధానాన్ని సరిచేయడం స్పష్టం.

స్థానిక ఫిల్టర్ అసలు ఎందుకు ఉందో రాయండి, తద్వారా తదుపరి వ్యక్తి ఇంకా అవసరమా అని నిర్ణయించుకోగలడు. కారణం పోయిన చాలా కాలం తర్వాత కూడా ఫిల్టర్లు పోగవుతాయి.