64898 2011-07-20 15:52:27 -0700 Make kill-old-processes kill httpd on mac 2011-07-27 10:50:21 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 eric eric abarth abecsi aroben loki ojan ossy webkit.review.bot oldest_to_newest 440072 0 eric 2011-07-20 15:52:27 -0700 Make kill-old-processes kill httpd on mac 440076 1 101522 eric 2011-07-20 15:53:38 -0700 Created attachment 101522 Patch 440078 2 eric 2011-07-20 15:55:05 -0700 Snow Leopard is stuck again: http://build.webkit.org/builders/SnowLeopard%20Intel%20Release%20%28Tests%29/builds/31595/steps/layout-test/logs/stdio There was a typo in http_lock.py earlier this afternoon, which was shortly corrected, but I think it left an httpd process running without the corresponding lock file. I believe the bots will be more robust if we just kill httpd as an "old process" like how windows does. We can remove this line if we ever believe that NRWT's locking is bulletproof. 440079 3 101522 abarth 2011-07-20 15:56:34 -0700 Comment on attachment 101522 Patch Is this going to cause a problem for folks who run multiple slaves on the same box? 440082 4 101522 abarth 2011-07-20 15:57:14 -0700 Comment on attachment 101522 Patch IMHO, this whole locking business isn't worth the hassle. We shouldn't support running multiple instances of the tests on the same machine at the same time. 440083 5 eric 2011-07-20 15:58:12 -0700 (In reply to comment #3) > (From update of attachment 101522 [details]) > Is this going to cause a problem for folks who run multiple slaves on the same box? The only people who do that currently are the Qt bots, I believe. But yes, it would. Then again killing "DumpRenderTree" (which the script already does) would do that too, so there must be no mac bots running multiple copies of RWT at this time. 440106 6 101522 webkit.review.bot 2011-07-20 16:28:39 -0700 Comment on attachment 101522 Patch Clearing flags on attachment: 101522 Committed r91421: <http://trac.webkit.org/changeset/91421> 440107 7 webkit.review.bot 2011-07-20 16:28:43 -0700 All reviewed patches have been landed. Closing bug. 442243 8 ossy 2011-07-26 07:40:10 -0700 (In reply to comment #4) > (From update of attachment 101522 [details]) > IMHO, this whole locking business isn't worth the hassle. We shouldn't support running multiple instances of the tests on the same machine at the same time. We should support running multiple instances of RWT, because we don't have separated physical machines for all bots. We run 8 tester bots on 4 machines. I hate this locking thing, but the root of the problem is the hard coded TCP port numbers into layout tests and expected files. That's why we can't run multiple httpd on a same machine. 442347 9 abarth 2011-07-26 10:41:45 -0700 There's a trade-off with complexity. IMHO, the complexity isn't worthwhile given the availability of cheap virtual machines. 442355 10 abecsi 2011-07-26 10:52:28 -0700 (In reply to comment #9) > There's a trade-off with complexity. IMHO, the complexity isn't worthwhile given the availability of cheap virtual machines. We already had this discussion, is this going to turn up over and over again? https://bugs.webkit.org/show_bug.cgi?id=33153#c10 Virtual machines are absolutely not cheap, they are a huge overhead when only used for running tests on them. ORWT has http locking which turned out to be really simple, but it seems that the NRWT infrastructure is getting more and more complex and is not able to do simple things ORWT did. Our whole testing infrastructure for Qt bots needs the http locking and switching to VMs and maintaning them is far more complex than fixing http locking to work correctly. 442380 11 abarth 2011-07-26 11:09:19 -0700 > We already had this discussion, is this going to turn up over and over again? > https://bugs.webkit.org/show_bug.cgi?id=33153#c10 Probably. :) In any case, I stand by what I've said above. Including this functionality in the test harness has some costs and some benefits. Whether we should support this configuration is a matter of weighing the costs against the benefits. The whole world is moving to virtual-machine-based hosting, for everything from web servers to databases to big-data computing. Fighting that trend is a losing battle. 442394 12 abecsi 2011-07-26 11:24:51 -0700 (In reply to comment #11) > > We already had this discussion, is this going to turn up over and over again? > > https://bugs.webkit.org/show_bug.cgi?id=33153#c10 > > Probably. :) > > In any case, I stand by what I've said above. Including this functionality in the test harness has some costs and some benefits. Whether we should support this configuration is a matter of weighing the costs against the benefits. > > The whole world is moving to virtual-machine-based hosting, for everything from web servers to databases to big-data computing. Fighting that trend is a losing battle. I agree in some extent but I think running layout tests still consumes much less resources than running a virtual machine with a complete linux distribution and absolutely not comparable to big-data computing. Moving to NRWT (currently running single-thread for known reasons) made layout testing almost 3x slower than it was with ORWT, moving to VMs would make it another 5x slower. This is waste of resources. Once NRWT can reliably run tests in multiple threads, by sharding tests accordingly or by fixing the inter-test dependencies we might want to consider moving to a hypervisor based system. So rather than fighting the trends, I personally want to prevent throwing out the baby with the bath water :) 442410 13 abarth 2011-07-26 11:39:15 -0700 > Moving to NRWT (currently running single-thread for known reasons) made layout testing almost 3x slower than it was with ORWT Really? That shouldn't be the case. If that's true, we have a bug that we need to fix. 442457 14 abecsi 2011-07-26 12:34:52 -0700 (In reply to comment #13) > > Moving to NRWT (currently running single-thread for known reasons) made layout testing almost 3x slower than it was with ORWT > > Really? That shouldn't be the case. If that's true, we have a bug that we need to fix. 3x slower was an extreme when we swithched to NRWT, but I can measure the current slownown tomorrow, which should be the half of that, if you have concerns it is caused by a bug. I think it is caused by the way NRWT works. NRWT runs the failing and flacky tests multiple times to be sure they are flacky, and aquires and releases the httpd lock for each individual http test if I'm correct. Whereas ORWT did not run any tests twice and only aquired the lock at the end of the testing session when all the http tests where run at once then the lock was released. Further more NRWT produces much more stdio output than ORWT did, which also makes our bot slower, and would make a VM a server killer because of the crappy IO of VMWare. Once running NRWT with multiple threads is reliably and reproducibly possible I think this should improve. 442481 15 abarth 2011-07-26 13:05:59 -0700 NRWT was slow when we first turned it on, and we changed a few things to make it faster. If it's still slow, please let me know and we'll make it faster. In single-child mode, NRWT should be about 5% slower than ORWT. Anything more than is something we want to fix irrespective of whether we support running multiple instances on one machine. 442920 16 abecsi 2011-07-27 07:20:46 -0700 (In reply to comment #15) > NRWT was slow when we first turned it on, and we changed a few things to make it faster. If it's still slow, please let me know and we'll make it faster. In single-child mode, NRWT should be about 5% slower than ORWT. Anything more than is something we want to fix irrespective of whether we support running multiple instances on one machine. You can see a good comparison between ORWT: http://build.webkit.sed.hu/waterfall?show=x86-32%20Linux%20Qt-4.8.x%20Release NRWT: http://build.webkit.org/waterfall?show=Qt%20Linux%20Release The first bot is still using ORWT (NRWT does not understand qt-4.8) and runs the tests with few failing tests (and 3 additionaly skipped) in approximately 700 seconds whereas the release bot runs NRWT in approximately 1100s which is almost 40% slower on average. 443002 17 abarth 2011-07-27 10:50:21 -0700 Ok. I assume these are comparable machines. I've created https://bugs.webkit.org/show_bug.cgi?id=65268 to track that issue. 101522 2011-07-20 15:53:38 -0700 2011-07-20 16:28:39 -0700 Patch bug-64898-20110720155337.patch text/plain 7283 eric U3VidmVyc2lvbiBSZXZpc2lvbjogOTE0MTEKZGlmZiAtLWdpdCBhL1Rvb2xzL0J1aWxkU2xhdmVT dXBwb3J0L2tpbGwtb2xkLXByb2Nlc3NlcyBiL1Rvb2xzL0J1aWxkU2xhdmVTdXBwb3J0L2tpbGwt b2xkLXByb2Nlc3NlcwppbmRleCAzZmExZmJjMGFmNjk3Njc3YTgxMTcxM2VlYWY4YjkwOWE0NzFi YzQzLi4xYWU5ZTk0Yzc0YTc1MjA2YzhiMjVkMWEwZTAxZjg0MDJkNGMyM2E1IDEwMDc1NQotLS0g YS9Ub29scy9CdWlsZFNsYXZlU3VwcG9ydC9raWxsLW9sZC1wcm9jZXNzZXMKKysrIGIvVG9vbHMv QnVpbGRTbGF2ZVN1cHBvcnQva2lsbC1vbGQtcHJvY2Vzc2VzCkBAIC0xLDg4ICsxLDg5IEBACi0j IS91c3IvYmluL3B5dGhvbg0KLSMgQ29weXJpZ2h0IChDKSAyMDEwIEFwcGxlIEluYy4gIEFsbCBy aWdodHMgcmVzZXJ2ZWQuDQotIyBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4gIEFsbCBy aWdodHMgcmVzZXJ2ZWQuDQotIw0KLSMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0DQotIyBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMNCi0jIGFyZSBt ZXQ6DQotIw0KLSMgMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0DQotIyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLg0KLSMgMi4gIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0DQotIyAg ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQ0KLSMgICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uDQotIw0KLSMgVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkN Ci0jIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgVEhFIElNUExJRUQNCi0jIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUNCi0jIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkNCi0jIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTDQotIyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7DQotIyBMT1NT IE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQNCi0jIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUDQotIyAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YN Ci0jIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuDQotDQotaW1wb3J0IG9zLCBzeXMNCi0NCi0NCi1kZWYgbWFpbigpOg0KLSAg ICB0YXNrc1RvS2lsbFdpbiA9IFsNCi0gICAgICAgICJjbC5leGUiLA0KLQkJImRldmVudi5jb20i LA0KLQkJImRldmVudi5leGUiLA0KLQkJIkR1bXBSZW5kZXJUcmVlLmV4ZSIsDQotCQkiRHVtcFJl bmRlclRyZWVfZGVidWcuZXhlIiwNCi0JCSJodHRwZC5leGUiLA0KLQkJImltYWdlZGlmZi5leGUi LA0KLQkJImltYWdlZGlmZl9kZWJ1Zy5leGUiLA0KLQkJImpzYy5leGUiLA0KLQkJImpzY19kZWJ1 Zy5leGUiLA0KLQkJIkxpZ2h0VFBELmV4ZSIsDQotCQkibGluay5leGUiLA0KLQkJIm1pZGwuZXhl IiwNCi0JCSJwZXJsLmV4ZSIsDQotCQkiU2FmYXJpLmV4ZSIsDQotCQkic3ZuLmV4ZSIsDQotCQki dGVzdGFwaS5leGUiLA0KLQkJInRlc3RhcGlfZGVidWcuZXhlIiwNCi0JCSJWY0J1aWxkSGVscGVy LmV4ZSIsDQotCQkid2RpZmYuZXhlIiwNCi0JCSJXZWJLaXQyV2ViUHJvY2Vzcy5leGUiLA0KLQkJ IldlYktpdDJXZWJQcm9jZXNzX2RlYnVnLmV4ZSIsDQotCQkiV2ViS2l0VGVzdFJ1bm5lci5leGUi LA0KLQkJIldlYktpdFRlc3RSdW5uZXJfZGVidWcuZXhlIiwNCi0JXQ0KLQ0KLSAgICB0YXNrc1Rv S2lsbE1hYyA9IFsNCi0JCSJqc2MiLA0KLQkJIm1ha2UiLA0KLQkJInBlcjUuMTIiLA0KLQkJInBl cmwiLA0KLQkJIlByb2JsZW0gUmVwb3J0ZXIiLA0KLQkJInJ1YnkiLA0KLQkJIlNhZmFyaSBXZWIg Q29udGVudCIsDQotCQkiU2FmYXJpIiwNCi0JCSJzdm4iLA0KLQkJIkR1bXBSZW5kZXJUcmVlIiwN Ci0JCSJUZXN0V2ViS2l0QVBJIFdlYiBDb250ZW50IiwNCi0JCSJUZXN0V2ViS2l0QVBJIiwNCi0J CSJXZWJLaXRQbHVnaW5BZ2VuIiwgIyBXaHkgbm8gJ3QnPw0KLQkJIldlYktpdFRlc3RSdW5uZXIg V2ViIENvbnRlbnQiLA0KLQkJIldlYktpdFRlc3RSdW5uZXIiLA0KLQkJIldlYlByb2Nlc3MiLA0K LQldDQotDQotICAgIGlmIHN5cy5wbGF0Zm9ybSA9PSAnZGFyd2luJzoNCi0gICAgICAgIGZvciB0 YXNrIGluIHRhc2tzVG9LaWxsTWFjOg0KLSAgICAgICAgICAgIG9zLnN5c3RlbSgia2lsbGFsbCAt OSAtdiAtbSAiICsgdGFzaykNCi0gICAgZWxpZiBzeXMucGxhdGZvcm0gPT0gJ2N5Z3dpbicgb3Ig c3lzLnBsYXRmb3JtID09ICd3aW4zMic6DQotICAgICAgICBmb3IgdGFzayBpbiB0YXNrc1RvS2ls bFdpbjoNCi0gICAgICAgICAgICBvcy5zeXN0ZW0oInRhc2traWxsIC90IC9mIC9pbSAiICsgdGFz aykNCi0gICAgZWxzZToNCi0gICAgICAgIHJhaXNlIEV4Y2VwdGlvbigiSGF2ZSBub3QgaW1wbGVt ZW50ZWQga2lsbC1vbGQtcHJvY2Vzc2VzIGZvciB0aGlzIHBsYXRmb3JtIikNCi0gICAgIyBGSVhN RTogU2hvdWxkIHdlIHJldHVybiBhbiBleGl0IGNvZGUgYmFzZWQgb24gaG93IHRoZSBraWxscyB3 ZW50Pw0KLQ0KLQ0KLWlmIF9fbmFtZV9fID09ICdfX21haW5fXyc6DQotICAgIHN5cy5leGl0KG1h aW4oKSkNCisjIS91c3IvYmluL3B5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgQXBwbGUgSW5j LiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMgQ29weXJpZ2h0IChDKSAyMDExIEdvb2dsZSBJbmMu ICBBbGwgcmlnaHRzIHJlc2VydmVkLgorIworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNv dXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisjIGFy ZSBtZXQ6CisjCisjIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIyAyLiAgUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyMgICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisjIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgVEhFIElNUExJRUQKKyMgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorIyBESVNDTEFJTUVELiBJTiBOTyBFVkVO VCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisjIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTCisjIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyMgTE9TUyBPRiBVU0UsIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5ECisjIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorIyBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor CitpbXBvcnQgb3MsIHN5cworCisKK2RlZiBtYWluKCk6CisgICAgdGFza3NUb0tpbGxXaW4gPSBb CisgICAgICAgICJjbC5leGUiLAorICAgICAgICAiZGV2ZW52LmNvbSIsCisgICAgICAgICJkZXZl bnYuZXhlIiwKKyAgICAgICAgIkR1bXBSZW5kZXJUcmVlLmV4ZSIsCisgICAgICAgICJEdW1wUmVu ZGVyVHJlZV9kZWJ1Zy5leGUiLAorICAgICAgICAiaHR0cGQuZXhlIiwKKyAgICAgICAgImltYWdl ZGlmZi5leGUiLAorICAgICAgICAiaW1hZ2VkaWZmX2RlYnVnLmV4ZSIsCisgICAgICAgICJqc2Mu ZXhlIiwKKyAgICAgICAgImpzY19kZWJ1Zy5leGUiLAorICAgICAgICAiTGlnaHRUUEQuZXhlIiwK KyAgICAgICAgImxpbmsuZXhlIiwKKyAgICAgICAgIm1pZGwuZXhlIiwKKyAgICAgICAgInBlcmwu ZXhlIiwKKyAgICAgICAgIlNhZmFyaS5leGUiLAorICAgICAgICAic3ZuLmV4ZSIsCisgICAgICAg ICJ0ZXN0YXBpLmV4ZSIsCisgICAgICAgICJ0ZXN0YXBpX2RlYnVnLmV4ZSIsCisgICAgICAgICJW Y0J1aWxkSGVscGVyLmV4ZSIsCisgICAgICAgICJ3ZGlmZi5leGUiLAorICAgICAgICAiV2ViS2l0 MldlYlByb2Nlc3MuZXhlIiwKKyAgICAgICAgIldlYktpdDJXZWJQcm9jZXNzX2RlYnVnLmV4ZSIs CisgICAgICAgICJXZWJLaXRUZXN0UnVubmVyLmV4ZSIsCisgICAgICAgICJXZWJLaXRUZXN0UnVu bmVyX2RlYnVnLmV4ZSIsCisgICAgXQorCisgICAgdGFza3NUb0tpbGxNYWMgPSBbCisgICAgICAg ICJodHRwZCIsICMgVGhpcyBzaG91bGRuJ3QgYmUgbmVlZGVkLCBleGNlcHQgY3VycmVudGx5IHRo ZXJlIGFyZSBidWdzIGluIE5SV1QncyBodHRwIGxvY2tpbmcgY29kZS4KKyAgICAgICAgImpzYyIs CisgICAgICAgICJtYWtlIiwKKyAgICAgICAgInBlcjUuMTIiLAorICAgICAgICAicGVybCIsCisg ICAgICAgICJQcm9ibGVtIFJlcG9ydGVyIiwKKyAgICAgICAgInJ1YnkiLAorICAgICAgICAiU2Fm YXJpIFdlYiBDb250ZW50IiwKKyAgICAgICAgIlNhZmFyaSIsCisgICAgICAgICJzdm4iLAorICAg ICAgICAiRHVtcFJlbmRlclRyZWUiLAorICAgICAgICAiVGVzdFdlYktpdEFQSSBXZWIgQ29udGVu dCIsCisgICAgICAgICJUZXN0V2ViS2l0QVBJIiwKKyAgICAgICAgIldlYktpdFBsdWdpbkFnZW4i LCAjIEZJWE1FOiBXaHkgbm8gJ3QnPworICAgICAgICAiV2ViS2l0VGVzdFJ1bm5lciBXZWIgQ29u dGVudCIsCisgICAgICAgICJXZWJLaXRUZXN0UnVubmVyIiwKKyAgICAgICAgIldlYlByb2Nlc3Mi LAorICAgIF0KKworICAgIGlmIHN5cy5wbGF0Zm9ybSA9PSAnZGFyd2luJzoKKyAgICAgICAgZm9y IHRhc2sgaW4gdGFza3NUb0tpbGxNYWM6CisgICAgICAgICAgICBvcy5zeXN0ZW0oImtpbGxhbGwg LTkgLXYgLW0gIiArIHRhc2spCisgICAgZWxpZiBzeXMucGxhdGZvcm0gPT0gJ2N5Z3dpbicgb3Ig c3lzLnBsYXRmb3JtID09ICd3aW4zMic6CisgICAgICAgIGZvciB0YXNrIGluIHRhc2tzVG9LaWxs V2luOgorICAgICAgICAgICAgb3Muc3lzdGVtKCJ0YXNra2lsbCAvdCAvZiAvaW0gIiArIHRhc2sp CisgICAgZWxzZToKKyAgICAgICAgcmFpc2UgRXhjZXB0aW9uKCJIYXZlIG5vdCBpbXBsZW1lbnRl ZCBraWxsLW9sZC1wcm9jZXNzZXMgZm9yIHRoaXMgcGxhdGZvcm0iKQorICAgICMgRklYTUU6IFNo b3VsZCB3ZSByZXR1cm4gYW4gZXhpdCBjb2RlIGJhc2VkIG9uIGhvdyB0aGUga2lsbHMgd2VudD8K KworCitpZiBfX25hbWVfXyA9PSAnX19tYWluX18nOgorICAgIHN5cy5leGl0KG1haW4oKSkKZGlm ZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCA0OTEwOWI1 MDZhODI5OWU4NDEwYWE1NzQ3NmY0ZmZkNzQ0NTM5OWRkLi5kMWJlNWE0NDlmYWExNWNlNDc0N2Uz ZjgxNmIxODY3ZmQ4MTFhZDg2IDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9v bHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTggQEAKIDIwMTEtMDctMjAgIEVyaWMgU2VpZGVsICA8 ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAgIE1ha2Uga2lsbC1vbGQtcHJvY2Vzc2VzIGtpbGwg aHR0cGQgb24gbWFjCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD02NDg5OAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgICogQnVpbGRTbGF2ZVN1cHBvcnQva2lsbC1vbGQtcHJvY2Vzc2VzOgorICAgICAgICAgLSBU aGUgbGluZSBlbmRpbmdzIHNlZW0gdG8gaGF2ZSBmbGlwcGVkIGFnYWluLAorICAgICAgICAgICBU aHVzIG1ha2luZyB0aGlzIGRpZmYgZ2lnYW50aWMuICBUaGUgb25seSBsaW5lCisgICAgICAgICAg IGNoYW5nZWQgaXMgdGhlICJodHRwZCIgbGluZS4gIEkgc3VzcGVjdCB3ZSdsbCBuZWVkCisgICAg ICAgICAgIHRvIHNldCB0aGUgbGluZSBlbmRpbmcgc3R5bGUgZnJvbSBhbiBzdm4gY2hlY2tvdXQu CisKKzIwMTEtMDctMjAgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCiAgICAgICAg IE1vdmUgSHR0cExvY2sgdG8gdXNpbmcgYSBGaWxlU3lzdGVtIG9iamVjdAogICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjQ4ODUKIAo=