63501 2011-06-27 18:23:58 -0700 Simplify Skipped file finding and make it wk2-aware 2011-06-29 18:36:14 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 63568 63572 63661 63676 56729 1 eric eric abarth dpranke webkit.review.bot oldest_to_newest 428543 0 eric 2011-06-27 18:23:58 -0700 Simplify skipped file finding in preparation for adding wk2 skipped list fallback 428549 1 abarth 2011-06-27 18:29:02 -0700 +dpranke. (Dirk, let me know if you'd rather not get this bugmail.) 428558 2 98842 eric 2011-06-27 18:43:10 -0700 Created attachment 98842 Patch 428586 3 98847 eric 2011-06-27 20:39:24 -0700 Created attachment 98847 Patch 428587 4 eric 2011-06-27 20:40:09 -0700 It's now possible to successfully the tests with WebKitTestRunner with this patch. About 20 or so fail for unknown reasons, so we still have some debugging to do. 428653 5 98847 dpranke 2011-06-27 23:19:28 -0700 Comment on attachment 98847 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=98847&action=review This is some sort of karmic payback for all those patches I've submitted that had fixes for umpteen different things in a single patch, isn't it? :) > Tools/Scripts/webkitpy/common/system/filesystem.py:64 > + I'm not sure this really belongs in filesystem, but then I'm not sure of a better place for it, either. Maybe add a FIXME to consider put it someplace else if there is something appropriate? > Tools/Scripts/webkitpy/layout_tests/port/base.py:546 > + # FIXME: This should be replaced by "return "%s-%s" (self.port_name(), self.version())" Sadly, %s-%s doesn't really cover it, since the fully-qualified name can also include the architecture and the graphics type, but there isn't a 1:1 mapping between classes and any particular combination of those attributes that is true across all of the ports (and I'm not sure there should be, because that might cause an explosion of subclasses). I would just delete the FIXME. > Tools/Scripts/webkitpy/layout_tests/port/base.py:550 > + # FIXME: Seems this is only used for MockDRT and should be removed. Adding a comment or a docstring that this is used only for MockDRT is great, but I'm not sure why you think this should be removed. Are you suggesting that MockDRT doesn't need this, or that MockDRT shouldn't exist, or simply that there's a better way to provide MockDRT with this info? > Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py:70 > + # FIXME: version, name, etc. should be passed separately and we should not have to parse port_name. This is a noble goal, but I'm not sure how you plan to accomplish it. Specifying a substring of the fully-qualified name is terribly useful from the users' point of view and can be flat-out necessary if you don't know the right combinations to use. Given that, if you move the logic out of the class (which is what I'm assuming you're suggesting), I don't know where else you would put it (factory.py being the obvious candidate) that wouldn't simply create a mirror of the class hierarchy or one terribly complex series of tests and branches. It's an interesting topic, and I definitely agree that the mechanisms that exist now are crufty. I look forward to your ideas. > Tools/Scripts/webkitpy/layout_tests/port/mac.py:54 > + # FIXME: There is no mac-future directory, I don't understand why this code is here. I had a long discussion with someone (mark rowe?) in #webkit that led me to create this in order to clear up some mutual confusion, but at least at the time there seemed to be a real need for something like this in order to handle pre-released versions of software that might exist inside Apple (like your comment about Lion, above). I will attempt to dig up the notes I have on it and/or reconstruct the thinking tomorrow and send it to you. It is unfortunate that I didn't comment this better. I think it had to do with people inside of Apple thinking of "platform/mac" as representing the "future" version of the o/s, while people outside of Apple thinking of "platform/mac" as the "currently shipping" version. Since just saying "--platform mac" is equivalent to "--platform mac-<version I'm running on>", we needed some way to indicate that there might be unreleased, unnamed versions that could still be referred to. At least, I think that was the conclusion. I will try to dig up more tomorrow. > Tools/Scripts/webkitpy/layout_tests/port/mac.py:70 > + # FIXME: This isn't quite right for wk2, it should include mac-VERSION as well. I never did come up with a good strategy for handling the wk2 versus wk1 versions of the ports. My half-formed thoughts were that it probably needed to be treated as a different configuration attribute, like chromium has for architecture and cpu/gpu type. > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:79 > + return self.wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name() I've been waiting through the whole patch to see what you were going to use port_name() for ... if this is the thinking, then the chromium implementations of port_name should probably be returning "chromium", not "chromium-<os>". Are you using port_name() for other things as well, that I may have missed? It's not clear to me that wk2- variants and wk1-variants should have separate expectations files. In Chrome, we've found that multiple expectations files are best avoided, but maybe it'll be better if the files are nearly always empty? Also, if I specify mac-wk2 as the port name, does that automatically set webkit_test_runner to True (i.e., as if we had also passed --2)? A general design feature of NRWT has been that you should be able to use the --platform / port name to uniquely (in a single argument) capture all of the attributes you would need (although debug/release doesn't use this feature at the moment, there's no reason it couldn't). This has been very useful in the chromium bots, among other places, where you don't have to figure out how to translate a single bot config into a potential set of different arguments. 429122 6 eric 2011-06-28 14:01:51 -0700 (In reply to comment #5) > > Tools/Scripts/webkitpy/common/system/filesystem.py:64 > > I'm not sure this really belongs in filesystem, but then I'm not sure of a better place for it, either. Maybe add a FIXME to consider put it someplace else if there is something appropriate? I figure filesystem is a good place to ask where things are on disk. But I'm happy to move it elsewhere. > > Tools/Scripts/webkitpy/layout_tests/port/base.py:546 > > + # FIXME: This should be replaced by "return "%s-%s" (self.port_name(), self.version())" > > Sadly, %s-%s doesn't really cover it, since the fully-qualified name can also include the architecture and the graphics type, but there isn't a 1:1 mapping between classes and any particular combination of those attributes that is true across all of the ports (and I'm not sure there should be, because that might cause an explosion of subclasses). I would just delete the FIXME. Yeah, so this is the problem. We don't know what "name()" actually means (or all the ways its used). But we do know what each of the components mean (I think). In webkit we use the following two formats (as far as I know): PORT (mac, win, qt) PORT-VERSION (mac-leopard, win-xp, etc.) Chromium has a bunch more though: PORT-OS (chromium-mac) PORT-OS-VERSION (chromium-win-xp) PORT-OS-ARCH (chromium-linux-x86_64) PORT-GPU-OS (chromium-gpu-linux) PORT-GPU-OS-ARCH (chromium-gpu-linux-x86_64) I think the parsing logic should be separate from the Port storage logic. Port needs to know how to construct various names from those components (for layout test directories, bot names, etc.) but parsing arbitrary user input should be the responsibility of some other class IMO. > > Tools/Scripts/webkitpy/layout_tests/port/base.py:550 > > + # FIXME: Seems this is only used for MockDRT and should be removed. > > Adding a comment or a docstring that this is used only for MockDRT is great, but I'm not sure why you think this should be removed. Are you suggesting that MockDRT doesn't need this, or that MockDRT shouldn't exist, or simply that there's a better way to provide MockDRT with this info? Mocks very rarely have to change the original classes. There is no reason why MockDRT can't just add that method itself to some Port subclass. > > Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py:70 > > + # FIXME: version, name, etc. should be passed separately and we should not have to parse port_name. > > This is a noble goal, but I'm not sure how you plan to accomplish it. Specifying a substring of the fully-qualified name is terribly useful from the users' point of view and can be flat-out necessary if you don't know the right combinations to use. Given that, if you move the logic out of the class (which is what I'm assuming you're suggesting), I don't know where else you would put it (factory.py being the obvious candidate) that wouldn't simply create a mirror of the class hierarchy or one terribly complex series of tests and branches. I dont' think we'd use a mirror of the class hierarchy. I think we'd have some sort of factory class (like we already do). It's not clear to me where all these combined strings come from. Since we have various types of strings we could have separate parsers for each. It's unclear what the generic "name" is supposed to represent or the port_name argument to the constructor. The fact that we currently use port_name in the constructor in differrent ways for different sections of code is where I think the confusion stems. > > Tools/Scripts/webkitpy/layout_tests/port/mac.py:54 > > + # FIXME: There is no mac-future directory, I don't understand why this code is here. > > I had a long discussion with someone (mark rowe?) in #webkit that led me to create this in order to clear up some mutual confusion, but at least at the time there seemed to be a real need for something like this in order to handle pre-released versions of software that might exist inside Apple (like your comment about Lion, above). I suspect it was a interesting idea from Apple, but it seems they never went forward with a "future" port. We can eventually remove it. Not urgent. > I will attempt to dig up the notes I have on it and/or reconstruct the thinking tomorrow and send it to you. It is unfortunate that I didn't comment this better. I think it had to do with people inside of Apple thinking of "platform/mac" as representing the "future" version of the o/s, while people outside of Apple thinking of "platform/mac" as the "currently shipping" version. Since just saying "--platform mac" is equivalent to "--platform mac-<version I'm running on>", we needed some way to indicate that there might be unreleased, unnamed versions that could still be referred to. Yes. My understanding of the thinking is that platform/mac always represents the future. platform/mac-VERSION represents any specific shipping OS. > > Tools/Scripts/webkitpy/layout_tests/port/mac.py:70 > > + # FIXME: This isn't quite right for wk2, it should include mac-VERSION as well. > > I never did come up with a good strategy for handling the wk2 versus wk1 versions of the ports. My half-formed thoughts were that it probably needed to be treated as a different configuration attribute, like chromium has for architecture and cpu/gpu type. Handeling it as an option has worked OK. I'm not sure I understand the ARCH or GPU flavors of the chomium ports. Like the "name" confusion, it's not clear what name variants want to include the ARCH vs. GPU sub-types and which don't. Bot names likely do, but do fallback paths? Who knows. Part of the confusion is what I mentioned above that webkit only really has two flavors of names, and Chromium has 4 factorial. :) > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:79 > > + return self.wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name() > > I've been waiting through the whole patch to see what you were going to use port_name() for ... if this is the thinking, then the chromium implementations of port_name should probably be returning "chromium", not "chromium-<os>". Are you using port_name() for other things as well, that I may have missed? Oh, this was an easy correction. Yes, I could change all chromium ports to parse out "chroimum" as port_name() instead, that's probably better. In this specific case, there are 5 test_expectation files in the repository: ./chromium/test_expectations.txt ./gtk/test_expectations.txt ./mac/test_expectations.txt ./qt/test_expectations.txt ./win/test_expectations.txt and none of them use the "name()" version of the port name, so I changed them to use port_name() which matched expectations at least for the 4 webkit-ports. This is more examples of confusion on what the various "name"s mean. > It's not clear to me that wk2- variants and wk1-variants should have separate expectations files. In Chrome, we've found that multiple expectations files are best avoided, but maybe it'll be better if the files are nearly always empty? Mostly I wanted to stop reading in the mac/test_expectations.txt for wk2, since wk2 skips several tests which are listed in mac/test_expectations.txt and thus test_expectations got mad for having duplicate entries. Initially I just disabled test_expectations for wk2, but then decided I should leave the option open, and changed it to look for test_expectations in PORTNAME-wk2 instead. > Also, if I specify mac-wk2 as the port name, does that automatically set webkit_test_runner to True (i.e., as if we had also passed --2)? No. > A general design feature of NRWT has been that you should be able to use the --platform / port name to uniquely (in a single argument) capture all of the attributes you would need (although debug/release doesn't use this feature at the moment, there's no reason it couldn't). This has been very useful in the chromium bots, among other places, where you don't have to figure out how to translate a single bot config into a potential set of different arguments. I guess I wasn't aware of that design feature. I'm not sure I agree with it, given the current architecture. Here again a factory/parser would be useful to make explicit what are acceptable user input, and separate that from how the actual Port objects store configuration parameters and synthesize the needed names for on-disk storage and bot lookup. 429127 7 dpranke 2011-06-28 14:07:06 -0700 (In reply to comment #6) > > > Tools/Scripts/webkitpy/layout_tests/port/mac.py:54 > > > + # FIXME: There is no mac-future directory, I don't understand why this code is here. > > > > I had a long discussion with someone (mark rowe?) in #webkit that led me to create this in order to clear up some mutual confusion, but at least at the time there seemed to be a real need for something like this in order to handle pre-released versions of software that might exist inside Apple (like your comment about Lion, above). > > I suspect it was a interesting idea from Apple, but it seems they never went forward with a "future" port. We can eventually remove it. Not urgent. > Okay, I dug up the notes on this, and you can look at bug 56730 for more context. The gist of it is that there needs to be a stable way to refer to the future or currently-in-development version of the o/s and the currently shipping version. Note that this is not necessarily the same thing as the actual names of the baseline directories. E.g., for people outside of Apple, as of this writing if you are running on 10.6 / Snow Leopard, you should still put new baselines into platform/mac. However, inside Apple, where you might be able to distinguish between tests that will pass on 10.7/Lion and fail on SL, you need to be able to say whether you want the Lion behavior or the SL behavior. We agreed to use "-future" as the version indicator for this. Note that the tools do not really fully support this concept yet. Also, there is nothing Apple/Mac-specific about this. We could just as easily reuse this concept for Windows 8, Ubuntu Natty, etc. So, we might want to refine this further, but I don't think we can remove it. 429128 8 eric 2011-06-28 14:07:59 -0700 Yeah, looking at the platform directory, chromium has created a ton of new names, none of which are supported by old-run-webkit-tests or any other webkit port: Chromium names: chromium chromium-gpu chromium-gpu-linux chromium-gpu-mac chromium-gpu-win chromium-linux chromium-linux-x86 chromium-mac chromium-mac-leopard chromium-win chromium-win-vista chromium-win-xp google-chrome-linux32 google-chrome-linux64 Everybody else: android android-v8 gtk mac mac-leopard mac-snowleopard mac-wk2 qt qt-4.8 qt-arm qt-linux qt-mac qt-win qt-wk2 win win-7sp0 win-wk2 win-xp The only names in that list which don't follow PORT/PORT-VERSION are Qt, which adds PORT-OS (qt-win, qt-mac) and PORT-ARCH (qt-arm). (I guess andriod vs. andriod-v8 also doesn't follow, but the android port should be deleted at this point, so I'm not sure its' a very useful example.) In any case in order to maintain any level of sanity, we need to decide what the various possible name uses are (fallback directories, test-expecation locations, skipped file locations, and bot names are the only things which come to mind) and create functions which can produce those given the right components. We also then need to understand what set of names users are expected to be allowed to provide, and then design a parser for those. 429154 9 dpranke 2011-06-28 14:42:20 -0700 (In reply to comment #6) > (In reply to comment #5) > > > > Tools/Scripts/webkitpy/common/system/filesystem.py:64 > > > > I'm not sure this really belongs in filesystem, but then I'm not sure of a better place for it, either. Maybe add a FIXME to consider put it someplace else if there is something appropriate? > > I figure filesystem is a good place to ask where things are on disk. But I'm happy to move it elsewhere. > Mostly, it feels weird to me to have filesystem.py looking at sys.modules. But, like I said, I couldn't think of a better place for it, either. 429162 10 dpranke 2011-06-28 14:49:22 -0700 (In reply to comment #6) > > > Tools/Scripts/webkitpy/layout_tests/port/base.py:550 > > > + # FIXME: Seems this is only used for MockDRT and should be removed. > > > > Adding a comment or a docstring that this is used only for MockDRT is great, but I'm not sure why you think this should be removed. Are you suggesting that MockDRT doesn't need this, or that MockDRT shouldn't exist, or simply that there's a better way to provide MockDRT with this info? > > Mocks very rarely have to change the original classes. There is no reason why MockDRT can't just add that method itself to some Port subclass. Okay, I had to go back and remember why I added this in the first place ... Generally speaking, calling code should not be aware of the difference between the "real" port and the "mock" port (this is true, to a lesser extent, of the dryrun classes as well, which could probably be removed at this point). The only *practical* difference between the real port and the mock port is that the mock ports stubs out the servers and changes the command line used to spawn off DRTs. This allows us to get virtually 100% coverage of the port-specific code. For that reason, port.name() needs to return the value that the original/un-mocked port would return. However, there is one place where we actually need to know the difference, which is when we spawn off subprocesses to run the workers, in layout_package/manager_worker_broker.py. Here it's important that we can retrieve the argument we need to pass back to --platform in the subprocess in order to re-create the MockDRT port object instead of getting the real port object by accident. It may be that real_name() is a bad name for this method, and we almost certainly need better comments or docstrings around why this exists (since it took all this just for me to remember). But, I'm not sure if there's a better way to actually get the functionality while minimizing the difference in code execution between real ports and mock ports. 429172 11 dpranke 2011-06-28 15:06:40 -0700 (In reply to comment #8) > Yeah, looking at the platform directory, chromium has created a ton of new names, none of which are supported by old-run-webkit-tests or any other webkit port: Yes, Chromium is certainly much more complicated, and that drove a lot of the complexity of this design. Rather than trying to address comments one-by-one (which I did in the bugzilla comment that got stepped on), I'll try to approach things from a different angle. NRWT needs to support multiple different ports that themselves have multiple different dimensions of variability. These differences manifest mostly in the the baseline search path / fallback path, and in the sets of modifiers that are supported in the test_expectations files, but obviously there are some aspects of variance that show up as differences in code in the different class files. Amongst all of the ports we have so far, we have: debug/release operating system operating system version architecture (x86/x86_64/arm) cpu/gpu webkit 1 / webkit 2 "implementation family" (chromium / apple / qt / gtk) obviously, not all ports use all of these dimensions. The TestConfig object only captures some of them right now, but it could be expanded to include the others. Most of these dimensions do show up in the modifiers accepted in the test_expectations.txt files (in fact, the accepted values are determined from the TestConfig object). In the code right now, choosing values on some of these axes is done by specific command line flags (notably --debug/--release) and many of the other axes are selected based on the values passed to the --platform argument. My long-term plan had been to have arguments for individual axes as well as being able to get to any point in the space from a single argument via the platform flag. Ideally, we should be able to enumerate all of the different combinations of all of the different values programmatically, so that --lint-test-files works. In addition, we probably don't want all of these possible combinations to try and co-exist in a single test_expectations.txt file (in particular, Chromium should probably stand alone since it is so much bigger). However, it might make sense for all of other ports to share a single test expectations file, or it might make sense to have one per "implementation family" (apple/chromium/qt/gtk/android/etc.). Whether it makes sense to have a separate set of classes to handle these sets of command line args and try to convert between args, --platform values, and Port objects, or to just clean up the existing classes, I don't know. I'm entirely open to suggestions here. Hopefully this makes a little more sense. I think this is actually the most important "big picture" difference between ORWT and NRWT to grasp and make sure you understand, otherwise a lot of my code structure may not make that much sense to you. 429230 12 98992 eric 2011-06-28 16:15:46 -0700 Created attachment 98992 Slightly smaller patch 429231 13 eric 2011-06-28 16:16:02 -0700 There are no changes to the patch, just ripped some stuff out. 429263 14 98992 dpranke 2011-06-28 16:42:53 -0700 Comment on attachment 98992 Slightly smaller patch The patch generally looks pretty good. My comments mostly relate to various FIXMEs, docstrings, function names, and other comments ... View in context: https://bugs.webkit.org/attachment.cgi?id=98992&action=review > Tools/Scripts/webkitpy/layout_tests/port/base.py:541 > + """The base name of the port, not including version information.""" We should probably provide examples here ... should it be "apple" or "mac"? "chromium" or "chromium-mac", etc.? How is this different from "name"? > Tools/Scripts/webkitpy/layout_tests/port/base.py:546 > + # FIXME: This should be replaced by "return "%s-%s" (self.port_name(), self.version())" As noted in other comments, this FIXME is wrong and the doc string is still simplistic. I'd replace this by something along the lines of """Returns a name that uniquely identifies this particular type of port (e.g., "mac-snowleopard" or "chromium-gpu-linux-x86_x64" and can be passed back to factory.get() or the constructor"". > Tools/Scripts/webkitpy/layout_tests/port/base.py:551 > + """Returns the actual name of the port, not the delegate's.""" """Returns the name of the port as passed to the --platform command line argument. This can be different from port.name() for ports like the MockDRT port.""" > Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py:71 > + self._parse_port_name(port_name) I'm always a little uncomfortable with calling other routines from inside constructors. Maybe we should add a comment to _parse_port_name() that this may be called from inside a constructor and the object may not be fully initialized? Alternatively, we could make this a static member function, and pass a tuple back or something like that ... > Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py:70 > + # FIXME: version, name, etc. should be passed separately and we should not have to parse port_name. I don't understand this comment. Why would a routine called _parse_port_name() not have to parse the port name? Obviously you're trying to get at something else ... > Tools/Scripts/webkitpy/layout_tests/port/config.py:121 > + config_module_path = self._filesystem.path_to_module(self.__module__) I suggest you change filesystem.path_to_module() to return an abspath and be clear about it. > Tools/Scripts/webkitpy/layout_tests/port/mac.py:54 > + # FIXME: There is no mac-future directory, I don't understand why this code is here. Remove this per the comments in the bug? There will never be a mac-future directory, but port names do not necessarily map directly to baseline dirs. > Tools/Scripts/webkitpy/layout_tests/port/mac.py:71 > 'wk2': ['mac-wk2', 'mac'], As discussed, "-wk2" isn't really a version, and probably should represent a different axis of the test configuration, just like -gpu- and -x86 do in chromium. I would update the FIXME accordingly. > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:69 > + # port which requires platform-specfic results. We should replace this with a smarter Typo: "specific", not "specfic". Also, do you mean os-version-specific results, or os-specific results? I'm not sure what "platform" refers to in this context. > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:296 > + def wk2_port_name(self): Is this supposed to be a public function? Seems like it should only be _wk2_port_name() instead? > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:330 > + def _skipped_list_as_expectations_file(self): Nit: Technically, you're returning a string here ... I'd call this "_skipped_list_as_expectations()" instead. > Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py:49 > + WebKitPort.__init__(self, port_name="test", executive=executive, filesystem=filesystem, user=MockUser(), **kwargs) Given that "test" refers to the "test" port in port/test.py, this might be confusing. "webkit-test" or "test-webkit" maybe? 429919 15 99159 eric 2011-06-29 15:10:52 -0700 Created attachment 99159 further reduced patch, still no functional changes 429930 16 eric 2011-06-29 15:28:24 -0700 (In reply to comment #14) > (From update of attachment 98992 [details]) > > Tools/Scripts/webkitpy/layout_tests/port/base.py:546 > > + # FIXME: This should be replaced by "return "%s-%s" (self.port_name(), self.version())" > > As noted in other comments, this FIXME is wrong and the doc string is still simplistic. I'd replace this by something along the lines of > > """Returns a name that uniquely identifies this particular type of port (e.g., "mac-snowleopard" or "chromium-gpu-linux-x86_x64" and can be passed back to factory.get() or the constructor"". I think we want to move to a model where we store all the component pieces on the Port object, and generate the names we need on demand. That's what the comment is trying (and failing) to express. The current model is that we store whatever we were passed in as self._name and parse it for any data we need. I believe that approach to be sub-optimal. I could imagine an approach where the factory does all the parsing by spliting the string on "-" and matching each part to known lists (which the Port objects themselves could contain). Or passing the split string to the port object, having looked it up based on the port_name string it found in the split. For now I think I should just hardcode the port_names on the various ports. To move away from the parsing bit. They don't change. It doesn't make sense for hte Mac port to ever have a port name other than "mac", likewise, for Chromium ports to have a name other than "chromium", or? These various name() accessors can later be custom tuned to return whatever we'd like them to. > > Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py:71 > > + self._parse_port_name(port_name) > > I'm always a little uncomfortable with calling other routines from inside constructors. Maybe we should add a comment to _parse_port_name() that this may be called from inside a constructor and the object may not be fully initialized? Alternatively, we could make this a static member function, and pass a tuple back or something like that ... That woudl be OK. I think long-term I'd like it better if the factory did all of the string parsing and called setters on the port object. Something like this: def get(self, port_string) port_components = port_string.split("-") port_name_array = port_components.intersection(port_objects.keys()) # Should only find one entry if not port_name_array: raise "Invalid port name: %s" % port_string port = port_objects.get(port_name_array[0]) # Now either the factory could parse out the remaining pieces of the port components by comparing them to known lists (which it could generate from the list of all ports, or just have hardcoded), or it could pass the port_components off to the Port() constructor and it could call the setters. But in either case it looks something like this: for component in port_components: if component in known_architectures: port.set_architecture(component) elif component in known_versions: port.set_version(component) elif component in known_graphics: port.set_graphics(graphics) else: raise "Invalid port name: %s" % port_string Then of course the various names look like this: def layout_results_name(self) return "%s-%s" % (self._port_name, self._version) or for Chromium maybe something like this: def layout_results_name(self) name = self._port_name if self._graphics != "cpu": name += "-" + self._graphics name += "-" + self._operating_system if self._version: name += "-" + self._version if self._architecture: name += "-" + self._architecture In any case, that would be one approach which would result in consistent storage and connonicalized naming and parsing. I'm not sure it's the best system, but I believe it to be better than today, where it's unclear what _name means. > > Tools/Scripts/webkitpy/layout_tests/port/mac.py:71 > > 'wk2': ['mac-wk2', 'mac'], > > As discussed, "-wk2" isn't really a version, and probably should represent a different axis of the test configuration, just like -gpu- and -x86 do in chromium. I would update the FIXME accordingly. -wk2 can't be correctly handled by that dictionary lookup since its fallback depends on what version of the OS its running on. I'm also still not quite comfortable with this multi-axis configuration. I can see how it's useful to have a single cannonical string to represent a port, but I think we're currently over-using that string and not using the component pieces enough. > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:296 > > + def wk2_port_name(self): > > Is this supposed to be a public function? Seems like it should only be _wk2_port_name() instead? I figured it might get re-used,b ut I can make it private until then. > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:330 > > + def _skipped_list_as_expectations_file(self): > > Nit: Technically, you're returning a string here ... I'd call this "_skipped_list_as_expectations()" instead. Done. > > Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py:49 > > + WebKitPort.__init__(self, port_name="test", executive=executive, filesystem=filesystem, user=MockUser(), **kwargs) > > Given that "test" refers to the "test" port in port/test.py, this might be confusing. "webkit-test" or "test-webkit" maybe? Changed to testwebkitport to match the class name. 429970 17 99179 eric 2011-06-29 16:33:31 -0700 Created attachment 99179 Patch 429972 18 eric 2011-06-29 16:34:47 -0700 The patch is now bigger again (due to more cleanup as I tweaking to remove the _parse_port_name stuff). But it's much simpler. We're now just adding a cls.port_name value which contains the static information of the generic name of the port. "mac", "chromium", "win", etc. This value is now used for wk2-name computation as well as Skipped list search paths. 429979 19 99179 abarth 2011-06-29 16:41:37 -0700 Comment on attachment 99179 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=99179&action=review I mean, ideally you'd separate out the cleanup from the real change, but ok. > Tools/Scripts/webkitpy/layout_tests/port/gtk.py:71 > def check_build(self, needs_http): > - if not self._check_driver(): > - return False > - return True > + return self._check_driver() Wow 430002 20 99179 webkit.review.bot 2011-06-29 17:02:30 -0700 Comment on attachment 99179 Patch Clearing flags on attachment: 99179 Committed r90070: <http://trac.webkit.org/changeset/90070> 430003 21 webkit.review.bot 2011-06-29 17:02:35 -0700 All reviewed patches have been landed. Closing bug. 430006 22 99179 dpranke 2011-06-29 17:04:48 -0700 Comment on attachment 99179 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=99179&action=review Looks okay to me as well; just a few more nits ... > Tools/Scripts/webkitpy/layout_tests/port/base.py:114 > + self._http_lock = None # FIXME: Why does this live on the port object? Where else would it live, given that locking and unlocking the servers are methods on the port object? Are you asking why isn't a lock just returned from the port object? > Tools/Scripts/webkitpy/layout_tests/port/base.py:136 > + self._test_configuration = None # FIXME: This does not belong on the real object. Yes it does. This is not something for testing, this is the TestConfig object returned from test_configuration() and used by the test_expectations classes. > Tools/Scripts/webkitpy/layout_tests/port/base.py:451 > + """Returns the list of top-level test directories.""" Hmm. I found that comment helpful; oh well. > Tools/Scripts/webkitpy/layout_tests/port/gtk.py:-119 > - Why did you delete this? Because None is implicitly returned? That may be true, but I think it's bad style to rely on that, and better to be explicit. > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:52 > + self._cached_apache_path = None # FIXME: This class should use @memoized instead. Meh :) > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:73 > + return self._wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name Seems like search_path() isn't a good name for this, since only one value is returned (not a list), and since it's a simple string (the port_name), not a path at all. Unless this routine is called from multiple places, I would've made this an explicit if and inlined it into path_to_test_expectations_file(). > Tools/Scripts/webkitpy/layout_tests/port/win.py:49 > + return map(self._webkit_baseline_path, search_paths) Nit ... I think the old name was better, given that it is in fact a list of port names, not search paths. 430030 23 eric 2011-06-29 17:36:04 -0700 This regressed 2 tests. Sadly teh cqs are not currently running the python tests. /me shakes his fist at abarth! 430031 24 eric 2011-06-29 17:36:28 -0700 Looking into a fix now. 430041 25 eric 2011-06-29 17:46:02 -0700 (In reply to comment #22) > (From update of attachment 99179 [details]) Since I'm making a regression fix now, I will add your comments as well. Thanks for the review! > > Tools/Scripts/webkitpy/layout_tests/port/base.py:114 > > + self._http_lock = None # FIXME: Why does this live on the port object? > > Where else would it live, given that locking and unlocking the servers are methods on the port object? Are you asking why isn't a lock just returned from the port object? It seems like the port object does too much. It's storage for information about the actual port. It's confused as to if it's a model or a controller. I don't see why it should store the locks during the actual running of the layout test. Maybe it's used for locking/unlocking, but someone else should do the storage, no? > > Tools/Scripts/webkitpy/layout_tests/port/base.py:136 > > + self._test_configuration = None # FIXME: This does not belong on the real object. > > Yes it does. This is not something for testing, this is the TestConfig object returned from test_configuration() and used by the test_expectations classes. OK... I'll have to read more about what those do, but I'll remove the fixme. > > Tools/Scripts/webkitpy/layout_tests/port/base.py:451 > > + """Returns the list of top-level test directories.""" > > Hmm. I found that comment helpful; oh well. It seemed that "Used by --clobber-old-results." would go quickly out of date, and wasn't any more helpful than just doing a grep, so I removed it. > > Tools/Scripts/webkitpy/layout_tests/port/gtk.py:-119 > > - > > Why did you delete this? Because None is implicitly returned? That may be true, but I think it's bad style to rely on that, and better to be explicit. Yes, I have mixed feelings about this -- silly to add 3 lines just to return None when it's implicit, but it's also nice to be explicit. I'm happy to add the None back. > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:52 > > + self._cached_apache_path = None # FIXME: This class should use @memoized instead. > > Meh :) It will actually simplify things greatly, you'll see. :) > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:73 > > + return self._wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name > > Seems like search_path() isn't a good name for this, since only one value is returned (not a list), and since it's a simple string (the port_name), not a path at all. Unless this routine is called from multiple places, I would've made this an explicit if and inlined it into path_to_test_expectations_file(). Happy to do so. > > Tools/Scripts/webkitpy/layout_tests/port/win.py:49 > > + return map(self._webkit_baseline_path, search_paths) > > Nit ... I think the old name was better, given that it is in fact a list of port names, not search paths. OK. 430049 26 dpranke 2011-06-29 18:04:57 -0700 (In reply to comment #25) > (In reply to comment #22) > > (From update of attachment 99179 [details] [details]) > > Since I'm making a regression fix now, I will add your comments as well. Thanks for the review! > > > > Tools/Scripts/webkitpy/layout_tests/port/base.py:114 > > > + self._http_lock = None # FIXME: Why does this live on the port object? > > > > Where else would it live, given that locking and unlocking the servers are methods on the port object? Are you asking why isn't a lock just returned from the port object? > > It seems like the port object does too much. It's storage for information about the actual port. It's confused as to if it's a model or a controller. I don't see why it should store the locks during the actual running of the layout test. Maybe it's used for locking/unlocking, but someone else should do the storage, no? Well, the implementation of how to do a system-/machine-wide lock is Port-specific. All Port-specific logic used by new-run-webkit-tests is funneled through the Port object. Given that, I'm not sure how differently things could be implemented. That said, I definitely agree that the Port object does too much. There are large chunks of functionality in base.Port that no one overrides and that isn't port-specific. That could probably be moved elsewhere. There are also probably chunks of functionality that could be profitably moved out of Port and into some other "platform-specific" object like we have done for filesystem and user. I think the design principle that "all port-specific logic used by NRWT is funneled through the Port object" is incredibly useful, because it allows for a great variety of implementations (like the Test port, which demonstrates that you can run the whole test suite without a real filesystem). In my current thinking, the Port object should probably be refactored into a composite object that simply forwards methods onto other objects that are mostly generic but could be overridden by the "weirder" ports. One of the other objects would be the set of methods that all of the "real" ports have actually needed to override, like baseline search path, paths to binaries, etc. . I'm still hoping to work on that refactoring as a "fun" project, but I don't want to collide with any of the stuff you're doing, so we should probably coordinate on this. > > > > Tools/Scripts/webkitpy/layout_tests/port/base.py:136 > > > + self._test_configuration = None # FIXME: This does not belong on the real object. > > > > Yes it does. This is not something for testing, this is the TestConfig object returned from test_configuration() and used by the test_expectations classes. > > OK... I'll have to read more about what those do, but I'll remove the fixme. > > > > Tools/Scripts/webkitpy/layout_tests/port/base.py:451 > > > + """Returns the list of top-level test directories.""" > > > > Hmm. I found that comment helpful; oh well. > > It seemed that "Used by --clobber-old-results." would go quickly out of date, and wasn't any more helpful than just doing a grep, so I removed it. > > > > Tools/Scripts/webkitpy/layout_tests/port/gtk.py:-119 > > > - > > > > Why did you delete this? Because None is implicitly returned? That may be true, but I think it's bad style to rely on that, and better to be explicit. > > Yes, I have mixed feelings about this -- silly to add 3 lines just to return None when it's implicit, but it's also nice to be explicit. I'm happy to add the None back. > > > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:52 > > > + self._cached_apache_path = None # FIXME: This class should use @memoized instead. > > > > Meh :) > > It will actually simplify things greatly, you'll see. :) > > > > Tools/Scripts/webkitpy/layout_tests/port/webkit.py:73 > > > + return self._wk2_port_name() if self.get_option('webkit_test_runner') else self.port_name > > > > Seems like search_path() isn't a good name for this, since only one value is returned (not a list), and since it's a simple string (the port_name), not a path at all. Unless this routine is called from multiple places, I would've made this an explicit if and inlined it into path_to_test_expectations_file(). > > Happy to do so. > > > > Tools/Scripts/webkitpy/layout_tests/port/win.py:49 > > > + return map(self._webkit_baseline_path, search_paths) > > > > Nit ... I think the old name was better, given that it is in fact a list of port names, not search paths. > > OK. 430080 27 eric 2011-06-29 18:36:14 -0700 Committed r90077: <http://trac.webkit.org/changeset/90077> 98842 2011-06-27 18:43:10 -0700 2011-06-27 20:39:20 -0700 Patch bug-63501-20110627184309.patch text/plain 38423 eric U3VidmVyc2lvbiBSZXZpc2lvbjogODk4NzAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCAwYWVkYjBmODg1YWE5OWJjZGVjN2ZhOGY4OGIyNmE4YWVj N2FmMzM3Li42ODUxZjA5NDlhZTgyMWFhODMyNTNmNzlmODNiOWNmYjlhZmJjNGUwIDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsODIg QEAKIDIwMTEtMDYtMjcgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNpbXBsaWZ5IHNraXBwZWQg ZmlsZSBmaW5kaW5nIGluIHByZXBhcmF0aW9uIGZvciBhZGRpbmcgd2syIHNraXBwZWQgbGlzdCBm YWxsYmFjaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjM1MDEKKworICAgICAgICBUaGlzIHBhdGNoIGVuZGVkIHVwIGRvaW5nIHRvbyBtdWNoIChJJ20g aGFwcHkgdG8gYnJlYWsgaXQgaW50byBwaWVjZXMgaWYgbmVjZXNzYXJ5KS4KKworICAgICAgICBU aGUgZ29hbCB3YXMgdG8gYWRkIHN1cHBvcnQgZm9yIHdrMiBza2lwcGVkIGxpc3RzLgorICAgICAg ICBIb3dldmVyLCBJIGZvdW5kIHRoYXQgb3VyIHNraXBwZWQgbGlzdCBjb21wdXRhdGlvbiB3YXMg YQorICAgICAgICBtYW51YWwgaGFjayAod2hpY2ggb25seSB3b3JrZWQgZm9yIHRoZSBtYWMgcG9y dCkuCisKKyAgICAgICAgU28gSSBmaXhlZCBhIEZJWE1FIHRvIG1vdmUgdGhlIHNraXBwZWQgbGlz dCBmaW5kaW5nCisgICAgICAgIGludG8gV2ViS2l0UG9ydCBpbnN0ZWFkIG9mIE1hY1BvcnQuCisg ICAgICAgIERvaW5nIHNvIHJlcXVpcmVkIGFkZGluZyBhIHBvcnRfbmFtZSgpIGFjY2Vzc29yIGFu ZAorICAgICAgICB1bnRhbmdsaW5nIHRoZSBtZXNzIHRoYXQgaXMgb3VyIHBvcnRfbmFtZSBhcmd1 bWVudCAicGFyc2luZyIuCisKKyAgICAgICAgKE91ciBjdXJyZW50IHN5c3RlbSBvZiBzb21ldGlt ZXMgcGFzc2luZyAiY2hyb21pdW0tbWFjIiBhbmQKKyAgICAgICAgc29tZXRpbWVzICJjaHJvbWl1 bS1tYWMtbGVvcGFyZCIgb3Igd29yc2UgImNocm9taXVtLWdwdS1tYWMtbGVvcGFyZCIKKyAgICAg ICAgYXMgdGhlIHBvcnRfbmFtZSBhcmd1bWVudCBhbmQgZXhwZWN0aW5nIFdlYktpdFBvcnQoKSB0 byBkbyB0aGUgcmlnaHQKKyAgICAgICAgdGhpbmcgaXMgYWJzdXJkLikKKworICAgICAgICBJIGFk ZGVkIGEgbmV3IF9wYXJzZV9wb3J0X25hbWUgbWV0aG9kIHRvIGhhbmRsZSB0aGUgdmFyaW91cwor ICAgICAgICBwb3NzaWJsZSBwb3J0X25hbWUgdmFsdWVzLiAgTm93IHRoYXQgd2UgaGF2ZSBhIHNo YXJlZCBtZXRob2QKKyAgICAgICAgd2UgY291bGQgcHJvYmFibHkganVzdCBjYWxsIF9wYXJzZV9w b3J0X25hbWUoKSBmcm9tIHRoZQorICAgICAgICBXZWJLaXRQb3J0IGNvbnN0cnVjdG9yIGFuZCBn ZXQgcmlkIG9mIG1hbnkgb2YgdGhlIHN1YmNsYXNzIGNvbnN0cnVjdG9ycy4KKworICAgICAgICBJ biBvcmRlciB0byB0ZXN0IG15IG5ldyBfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocyBtZXRob2Qs IEkKKyAgICAgICAgZml4ZWQgYW5vdGhlciBGSVhNRSBieSBtYWtpbmcgaXQgcmV0dXJuIHJlbGF0 aXZlIHBhdGhzLiAgSG93ZXZlcgorICAgICAgICBpbiBkb2luZyBzbyBJIGZvdW5kIHRoYXQgdGhl IFRlc3RXZWJLaXRQb3J0IHdlIHdlcmUgdXNpbmcgaW4KKyAgICAgICAgd2Via2l0X3VuaXR0ZXN0 LnB5IHdhcyBhY2Nlc3NpbmcgdGhlIHJlYWwgZmlsZXN5c3RlbSB0aHJvdWdoIHRoZSB1c2UKKyAg ICAgICAgb2YgdGhlIF9fZmlsZV9fIHZhcmlhYmxlLgorCisgICAgICAgIFNvIHRvIGZpeCB0aGF0 LCBJIGFkZGVkIGEgcGF0aF9mb3JfbW9kdWxlIGFic3RyYWN0aW9uIG9udG8gZmlsZXN5c3RlbS5w eS4KKworICAgICAgICBJIG9mIGNvdXJzZSByZW1vdmVkIHNvbWUgcmVkdW5kYW50IGRvY3N0cmlu Z3MgYW5kIG1vdmVkIGFic29sdXRlCisgICAgICAgIG1vZHVsZSBuYW1lcyB0byBfX2ZpbGVfXyBh bG9uZyB0aGUgd2F5LgorCisgICAgICAgIFdoaWxlIGZpeGluZyBteSBza2lwcGVkLWxpc3QgZmFs bGJhY2sgSSBhbHNvIGZvdW5kIHdlIHN0aWxsIGhhZCAoYnJva2VuKQorICAgICAgICB0aWdlciBz dXBwb3J0LCBzbyBJIHJlbW92ZWQgaXQgKGFsb25nIHdpdGggYWxsIG90aGVyIG1lbnRpb25zIG9m IHRpZ2VyIGluIHRoZSBzb3VyY2UgYmFzZSkuCisKKyAgICAgICAgRmluYWxseSBJIGZpeGVkIGFs bCBtaXNzcGVsbGluZ3Mgb2YgdGhyZWFkIGFzICJ0aGVhZCIgaW4gdGhlIGNvZGViYXNlCisgICAg ICAgICh3aGljaCB3YXMgbWVudGlvbmVkIGluIHRoZSByZXZpZXcgb2YgbXkgcHJldmlvdXMgcGF0 Y2gpLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dp dC5weTogInRoZWFkIiAtPiAidGhyZWFkIgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29t bW9uL3N5c3RlbS9maWxlc3lzdGVtLnB5OgorICAgICAgICAgLSBUaGlzIGNhbiBiZSB1c2VkIHRv IHdyYXAgYWxsIGNhbGxzIHRvIF9fZmlsZV9fIHRvIG1ha2UgdGhlbSB1bml0LXRlc3QgZnJpZW5k bHkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW1f bW9jay5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jh c2UucHk6CisgICAgICAgICAtIEFkZCBwb3J0X25hbWUoKSB0byBhY2Nlc3MgIm1hYyIsIHNpbmNl IG5hbWUoKSByZXR1cm5zICJtYWMtbGVvcGFyZCIgZXRjLgorICAgICAgICAgLSBEb2N1bWVudCB0 aGF0IHJlYWxfbmFtZSgpIHNlZW1zIHRvIGhhdmUgbm8gcHVycG9zZS4KKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2J1aWxkZXJzLnB5OgorICAgICAgICAgLSBS ZW1vdmUgdGlnZXIgc3VwcG9ydCwgd2Via2l0IG5vIGxvbmdlciBzdXBwb3J0cyB0aWdlci4KKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4 LnB5OgorICAgICAgICAgLSBBZGQgX3BhcnNlX3BvcnRfbmFtZSgpLCBldmVudHVhbGx5IHdlIG1p Z2h0IGNhbGwgdGhpcyBmcm9tIFdlYktpdFBvcnQgZGlyZWN0bHkuCisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHk6CisgICAgICAgICAt IEFkZCBfcGFyc2VfcG9ydF9uYW1lLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvY2hyb21pdW1fd2luLnB5OgorICAgICAgICAgLSBBZGQgX3BhcnNlX3BvcnRf bmFtZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2NvbmZp Zy5weToKKyAgICAgICAgIC0gVXNlIHRoZSBuZXcgcGF0aF90b19tb2R1bGUgYWJzdHJhY3Rpb24g aW5zdGVhZCBvZiBfX2ZpbGVfXyB0byBtYWtlIGl0CisgICAgICAgICAgIGVhc2llciB0byB1bml0 dGVzdCBjb25maWcucHkgY29kZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2d0ay5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L21hYy5weToKKyAgICAgICAgIC0gTW92ZSBTa2lwcGVkLWZpbGUgZmluZGluZyBjb2Rl IGRvd24gdG8gV2ViS2l0UG9ydAorICAgICAgICAgLSBSZW1vdmUgdGlnZXIgc3VwcG9ydC4KKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5w eToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5Ogor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5Ogor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0 ZXN0LnB5OgorICAgICAgICAgLSBUZXN0V2ViS2l0UG9ydCBpcyBtdWNoIGVhc2llciB0byB3cml0 ZSBub3cgdGhhdCBjb25maWcucHkgbmV2ZXIgYmxlZWRzCisgICAgICAgICAgIGFic29sdXRlIHBh dGhzLgorICAgICAgICAgLSBQYXNzIE1vY2tVc2VyIGFuZCBNb2NrRmlsZVN5c3RlbSBieSBkZWZh dWx0IHRvIHByZXZlbnQgVGVzdFdlYktpdFBvcnQgZnJvbSBsZWFraW5nIHN5c3RlbSBkYXRhIHRv IHVuaXR0ZXN0IHJlc3VsdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcnVuX3dlYmtpdF90ZXN0cy5weTogInRoZWFkIiAtPiAidGhyZWFkIgorICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5OiBUaWdlciBpcyBkZWFk LgorCisyMDExLTA2LTI3ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KKwogICAgICAg ICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgogCiAgICAgICAgIG5ldy1ydW4td2Via2l0LXRlc3Rz IG5lZWRzIGEgLS13ZWJraXQtdGVzdC1ydW5uZXIgb3B0aW9uCmRpZmYgLS1naXQgYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQppbmRleCA1MzdlYzY2ZDhiNmI1 YTZhMGQwODU5NTljNThmZTlkMThhZGIyMGI4Li5mZDliMTJlZmUyYTlhNTJlMWViMTEzMTI3MjJi ZDRhYmQzYzA5NmFkIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9j aGVja291dC9zY20vZ2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2No ZWNrb3V0L3NjbS9naXQucHkKQEAgLTgzLDggKzgzLDggQEAgY2xhc3MgR2l0KFNDTSwgU1ZOUmVw b3NpdG9yeSk6CiAgICAgICAgIGlmIHNlbGYuX2V4ZWN1dGFibGVfaXNfNjRiaXQoZ2l0X3BhdGgp OgogICAgICAgICAgICAgcmV0dXJuCiAKLSAgICAgICAgd2Via2l0X2Rldl90aGVhZF91cmwgPSAi aHR0cHM6Ly9saXN0cy53ZWJraXQub3JnL3BpcGVybWFpbC93ZWJraXQtZGV2LzIwMTAtRGVjZW1i ZXIvMDE1Mjg3Lmh0bWwiCi0gICAgICAgIGxvZygiV2FybmluZzogVGhpcyBtYWNoaW5lIGlzIDY0 LWJpdCwgYnV0IHRoZSBnaXQgYmluYXJ5ICglcykgZG9lcyBub3Qgc3VwcG9ydCA2NC1iaXQuXG5J bnN0YWxsIGEgNjQtYml0IGdpdCBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLCBzZWU6XG4lc1xuIiAl IChnaXRfcGF0aCwgd2Via2l0X2Rldl90aGVhZF91cmwpKQorICAgICAgICB3ZWJraXRfZGV2X3Ro cmVhZF91cmwgPSAiaHR0cHM6Ly9saXN0cy53ZWJraXQub3JnL3BpcGVybWFpbC93ZWJraXQtZGV2 LzIwMTAtRGVjZW1iZXIvMDE1Mjg3Lmh0bWwiCisgICAgICAgIGxvZygiV2FybmluZzogVGhpcyBt YWNoaW5lIGlzIDY0LWJpdCwgYnV0IHRoZSBnaXQgYmluYXJ5ICglcykgZG9lcyBub3Qgc3VwcG9y dCA2NC1iaXQuXG5JbnN0YWxsIGEgNjQtYml0IGdpdCBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLCBz ZWU6XG4lc1xuIiAlIChnaXRfcGF0aCwgd2Via2l0X2Rldl90aHJlYWRfdXJsKSkKIAogICAgIEBj bGFzc21ldGhvZAogICAgIGRlZiBpbl93b3JraW5nX2RpcmVjdG9yeShjbHMsIHBhdGgpOgpkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW0u cHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5weQpp bmRleCBlN2MwNjhhOWFkODQ2YjQ2YmNlNzU5NDg5OGJjZTdkOWQ5MjM5NGExLi4zNjUxMjYwNjMy ODg1YmUxZjliZTIyOGE0NDIxZTE5NTFkMzM0N2NlIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5weQorKysgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5weQpAQCAtNTcsNiArNTcsMTEgQEAg Y2xhc3MgRmlsZVN5c3RlbShvYmplY3QpOgogICAgIGRlZiBhYnNwYXRoKHNlbGYsIHBhdGgpOgog ICAgICAgICByZXR1cm4gb3MucGF0aC5hYnNwYXRoKHBhdGgpCiAKKyAgICBkZWYgcGF0aF90b19t b2R1bGUoc2VsZiwgbW9kdWxlX25hbWUpOgorICAgICAgICAiIiJBIHdyYXBwZXIgZm9yIGFsbCBj YWxscyB0byBfX2ZpbGVfXyB0byBhbGxvdyBlYXN5IHVuaXQgdGVzdGluZy4iIiIKKyAgICAgICAg aW1wb3J0IHN5cworICAgICAgICByZXR1cm4gc3lzLm1vZHVsZXNbbW9kdWxlX25hbWVdLl9fZmls ZV9fCisKICAgICBkZWYgZXhwYW5kdXNlcihzZWxmLCBwYXRoKToKICAgICAgICAgcmV0dXJuIG9z LnBhdGguZXhwYW5kdXNlcihwYXRoKQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbV9tb2NrLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW1fbW9jay5weQppbmRleCAyMDQ0NjhmNWQ3NWJm YTA3ZjI0NGE1MzJiNjJiZmRhNGExNGY5ODJlLi42ZWI5NThhMTVmNzhmMTQ3NjFkZGU4Y2IxY2Vk ZWRhZDFiNzg2MjQ3IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9z eXN0ZW0vZmlsZXN5c3RlbV9tb2NrLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29t bW9uL3N5c3RlbS9maWxlc3lzdGVtX21vY2sucHkKQEAgLTc5LDYgKzc5LDkgQEAgY2xhc3MgTW9j a0ZpbGVTeXN0ZW0ob2JqZWN0KToKICAgICAgICAgICAgIHJldHVybiBob21lX2RpcmVjdG9yeQog ICAgICAgICByZXR1cm4gaG9tZV9kaXJlY3RvcnkgKyBzZWxmLnNlcCArIHBhcnRzWzFdCiAKKyAg ICBkZWYgcGF0aF90b19tb2R1bGUoc2VsZiwgbW9kdWxlX25hbWUpOgorICAgICAgICByZXR1cm4g Ii9tb2NrL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvJXMiICUgbW9kdWxlX25hbWUKKwogICAgIGRl ZiBjaGRpcihzZWxmLCBwYXRoKToKICAgICAgICAgcGF0aCA9IHNlbGYubm9ybXBhdGgocGF0aCkK ICAgICAgICAgaWYgbm90IHNlbGYuaXNkaXIocGF0aCk6CmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggOGVmNDljYzVkMjM2Njc0NDMw ODM1MWJjYjY5OGY0ZDJiMGM4MGI3MS4uZDkwZTVkYTRmNDAyOWY2OGIyZWFiODM2ZTQ2NDc2Mzhj YTJiMmMwYiAxMDA3NTUKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9iYXNlLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvYmFzZS5weQpAQCAtOTEsMTAgKzkxLDExIEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAg ICAgICAgICAgICAgZmlsZXN5c3RlbT1Ob25lLAogICAgICAgICAgICAgICAgICBjb25maWc9Tm9u ZSwKICAgICAgICAgICAgICAgICAgKiprd2FyZ3MpOgotICAgICAgICBzZWxmLl9uYW1lID0gcG9y dF9uYW1lCisgICAgICAgIHNlbGYuX3BvcnRfbmFtZSA9IHBvcnRfbmFtZQogCiAgICAgICAgICMg VGhlc2UgYXJlIGRlZmF1bHQgdmFsdWVzIHRoYXQgc2hvdWxkIGJlIG92ZXJyaWRkZW4gaW4gYSBz dWJjbGFzc2VzLgogICAgICAgICAjIEZJWE1FOiBUaGVzZSBzaG91bGQgcmVhbGx5IGJlIHBhc3Nl ZCBpbi4KKyAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSAgIyBTdWJjbGFzc2VzIG1heSBh cHBlbmQgYSAtVkVSU0lPTiAobGlrZSBtYWMtbGVvcGFyZCkuCiAgICAgICAgIHNlbGYuX29wZXJh dGluZ19zeXN0ZW0gPSAnbWFjJwogICAgICAgICBzZWxmLl92ZXJzaW9uID0gJycKICAgICAgICAg c2VsZi5fYXJjaGl0ZWN0dXJlID0gJ3g4NicKQEAgLTUzNSwxMCArNTM2LDIwIEBAIGNsYXNzIFBv cnQob2JqZWN0KToKICAgICAgICAgIiIiQ3JlYXRlcyB0aGUgc3BlY2lmaWVkIGRpcmVjdG9yeSBp ZiBpdCBkb2Vzbid0IGFscmVhZHkgZXhpc3QuIiIiCiAgICAgICAgIHNlbGYuX2ZpbGVzeXN0ZW0u bWF5YmVfbWFrZV9kaXJlY3RvcnkoKnBhdGgpCiAKKyAgICBkZWYgcG9ydF9uYW1lKHNlbGYpOgor ICAgICAgICAiIiJUaGUgYmFzZSBuYW1lIG9mIHRoZSBwb3J0LCBub3QgaW5jbHVkaW5nIHZlcnNp b24gaW5mb3JtYXRpb24uIiIiCisgICAgICAgIHJldHVybiBzZWxmLl9wb3J0X25hbWUKKwogICAg IGRlZiBuYW1lKHNlbGYpOgotICAgICAgICAiIiJSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIHBvcnQg KGUuZy4sICdtYWMnLCAnY2hyb21pdW0td2luLXhwJykuIiIiCisgICAgICAgICIiIlJldHVybiB0 aGUgZnVsbCBuYW1lIG9mIHRoZSBwb3J0IChlLmcuLCAnbWFjJywgJ2Nocm9taXVtLXdpbi14cCcp LCBpbmNsdWRpbmcgdmVyc2lvbi4iIiIKKyAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYmUg cmVwbGFjZWQgYnkgInJldHVybiAiJXMtJXMiIChzZWxmLnBvcnRfbmFtZSgpLCBzZWxmLnZlcnNp b24oKSkiCiAgICAgICAgIHJldHVybiBzZWxmLl9uYW1lCiAKKyAgICBkZWYgcmVhbF9uYW1lKHNl bGYpOgorICAgICAgICAjIEZJWE1FOiBTZWVtcyB0aGlzIGlzIG9ubHkgdXNlZCBmb3IgTW9ja0RS VCBhbmQgc2hvdWxkIGJlIHJlbW92ZWQuCisgICAgICAgICIiIlJldHVybnMgdGhlIGFjdHVhbCBu YW1lIG9mIHRoZSBwb3J0LCBub3QgdGhlIGRlbGVnYXRlJ3MuIiIiCisgICAgICAgIHJldHVybiBz ZWxmLm5hbWUoKQorCiAgICAgZGVmIG9wZXJhdGluZ19zeXN0ZW0oc2VsZik6CiAgICAgICAgIHJl dHVybiBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtCiAKQEAgLTU1OSwxNyArNTcwLDEyIEBAIGNsYXNz IFBvcnQob2JqZWN0KToKICAgICAgICAgcmV0dXJuIEFnZ3JlZ2F0ZVRlc3RPdXRwdXRTZXQoW3Nl bGYuX3Jlc3VsdHNfZm9yX3BsYXRmb3JtKHBsYXRmb3JtKSBmb3IgcGxhdGZvcm0gaW4gcGxhdGZv cm1zXSkKIAogICAgIGRlZiBncmFwaGljc190eXBlKHNlbGYpOgotICAgICAgICAiIiJSZXR1cm5z IHdoZXRoZXIgdGhlIHBvcnQgdXNlcyBhY2NlbGVyYXRlZCBncmFwaGljcyAoJ2dwdScpIG9yIG5v dAotICAgICAgICAoJ2NwdScpLiIiIgorICAgICAgICAiIiJSZXR1cm5zIHdoZXRoZXIgdGhlIHBv cnQgdXNlcyBhY2NlbGVyYXRlZCBncmFwaGljcyAoJ2dwdScpIG9yIG5vdCAoJ2NwdScpLiIiIgog ICAgICAgICByZXR1cm4gc2VsZi5fZ3JhcGhpY3NfdHlwZQogCiAgICAgZGVmIGFyY2hpdGVjdHVy ZShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX2FyY2hpdGVjdHVyZQogCi0gICAgZGVmIHJl YWxfbmFtZShzZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyB0aGUgYWN0dWFsIG5hbWUgb2YgdGhl IHBvcnQsIG5vdCB0aGUgZGVsZWdhdGUncy4iIiIKLSAgICAgICAgcmV0dXJuIHNlbGYubmFtZSgp Ci0KICAgICBkZWYgZ2V0X29wdGlvbihzZWxmLCBuYW1lLCBkZWZhdWx0X3ZhbHVlPU5vbmUpOgog ICAgICAgICAjIEZJWE1FOiBFdmVudHVhbGx5IHdlIHNob3VsZCBub3QgaGF2ZSB0byBkbyBhIHRl c3QgZm9yCiAgICAgICAgICMgaGFzYXR0cigpLCBhbmQgd2Ugc2hvdWxkIGJlIGFibGUgdG8ganVz dCBkbwpAQCAtNjM5LDggKzY0NSw3IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgcmV0 dXJuIHNlbGYuX3VzZXIub3Blbl91cmwocmVzdWx0c19maWxlbmFtZSkKIAogICAgIGRlZiBjcmVh dGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgotICAgICAgICAiIiJSZXR1cm4gYSBuZXds eSBjcmVhdGVkIGJhc2UuRHJpdmVyIHN1YmNsYXNzIGZvciBzdGFydGluZy9zdG9wcGluZwotICAg ICAgICB0aGUgdGVzdCBkcml2ZXIuIiIiCisgICAgICAgICIiIlJldHVybiBhIG5ld2x5IGNyZWF0 ZWQgYmFzZS5Ecml2ZXIgc3ViY2xhc3MgZm9yIHN0YXJ0aW5nL3N0b3BwaW5nIHRoZSB0ZXN0IGRy aXZlci4iIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcignUG9ydC5jcmVhdGVf ZHJpdmVyJykKIAogICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZik6CkBAIC04NzQsOCArODc5LDcg QEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9y KCdQb3J0Ll9wYXRoX3RvX2hlbHBlcicpCiAKICAgICBkZWYgX3BhdGhfdG9faW1hZ2VfZGlmZihz ZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyB0aGUgZnVsbCBwYXRoIHRvIHRoZSBpbWFnZV9kaWZm IGJpbmFyeSwgb3IgTm9uZSBpZiBpdAotICAgICAgICBpcyBub3QgYXZhaWxhYmxlLgorICAgICAg ICAiIiJSZXR1cm5zIHRoZSBmdWxsIHBhdGggdG8gdGhlIGltYWdlX2RpZmYgYmluYXJ5LCBvciBO b25lIGlmIGl0IGlzIG5vdCBhdmFpbGFibGUuCiAKICAgICAgICAgVGhpcyBpcyBsaWtlbHkgdXNl ZCBvbmx5IGJ5IGRpZmZfaW1hZ2UoKSIiIgogICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVy cm9yKCdQb3J0LnBhdGhfdG9faW1hZ2VfZGlmZicpCkBAIC04OTksOCArOTAzLDcgQEAgY2xhc3Mg UG9ydChvYmplY3QpOgogICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0Ll9w YXRoX3RvX2xpZ2h0dHBkX3BocCcpCiAKICAgICBkZWYgX3BhdGhfdG9fd2RpZmYoc2VsZik6Ci0g ICAgICAgICIiIlJldHVybnMgdGhlIGZ1bGwgcGF0aCB0byB0aGUgd2RpZmYgYmluYXJ5LCBvciBO b25lIGlmIGl0IGlzCi0gICAgICAgIG5vdCBhdmFpbGFibGUuCisgICAgICAgICIiIlJldHVybnMg dGhlIGZ1bGwgcGF0aCB0byB0aGUgd2RpZmYgYmluYXJ5LCBvciBOb25lIGlmIGl0IGlzIG5vdCBh dmFpbGFibGUuCiAKICAgICAgICAgVGhpcyBpcyBsaWtlbHkgdXNlZCBvbmx5IGJ5IHdkaWZmX3Rl eHQoKSIiIgogICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0Ll9wYXRoX3Rv X3dkaWZmJykKQEAgLTkwOCw4ICs5MTEsNyBAQCBjbGFzcyBQb3J0KG9iamVjdCk6CiAgICAgZGVm IF93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxmLCBwbGF0Zm9ybSk6CiAgICAgICAgICIiIlJldHVy biB0aGUgIGZ1bGwgcGF0aCB0byB0aGUgdG9wIG9mIHRoZSBiYXNlbGluZSB0cmVlIGZvciBhCiAg ICAgICAgIGdpdmVuIHBsYXRmb3JtLiIiIgotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3Rl bS5qb2luKHNlbGYubGF5b3V0X3Rlc3RzX2RpcigpLCAncGxhdGZvcm0nLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHBsYXRmb3JtKQorICAgICAgICByZXR1cm4gc2VsZi5f ZmlsZXN5c3RlbS5qb2luKHNlbGYubGF5b3V0X3Rlc3RzX2RpcigpLCAncGxhdGZvcm0nLCBwbGF0 Zm9ybSkKIAogCiBjbGFzcyBEcml2ZXJJbnB1dChvYmplY3QpOgpkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9idWlsZGVycy5weSBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYnVpbGRlcnMucHkKaW5kZXggYzhlYTgx ZjA5ODNiMjdiZDRkMGFiMzkxZDI0OTE3NzI1MTU5MDQzZC4uZGQ1ZTQ2ODlmN2M3NzI4MWNjNGFj ODI3ZjAxMzliNGIxODQ3YzhlMyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcG9ydC9idWlsZGVycy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2J1aWxkZXJzLnB5CkBAIC02NSw3ICs2NSw2IEBAIENIUk9NSVVN X1BPUlRfVE9fQlVJTERFUl9OQU1FID0gewogV0VCS0lUX1BPUlRfVE9fQlVJTERFUl9OQU1FID0g ewogICAgICdndGsnOiAnR1RLIExpbnV4IDMyLWJpdCBEZWJ1ZycsCiAKLSAgICAnbWFjLXRpZ2Vy JzogTm9uZSwKICAgICAnbWFjLWxlb3BhcmQnOiAnTGVvcGFyZCBJbnRlbCBEZWJ1ZyAoVGVzdHMp JywKICAgICAnbWFjLXNub3dsZW9wYXJkJzogJ1Nub3dMZW9wYXJkIEludGVsIFJlbGVhc2UgKFRl c3RzKScsCiAgICAgJ21hYy13azInOiAnU25vd0xlb3BhcmQgSW50ZWwgUmVsZWFzZSAoV2ViS2l0 MiBUZXN0cyknLApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9jaHJvbWl1bV9saW51eC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvY2hyb21pdW1fbGludXgucHkKaW5kZXggZDk5YzA1YTNhMjBhZDk4MTQ4NTQ3 NWExZTQ3NzA2ZDk1ZmZiM2E3MS4uZWY5ODg3OGJkYmQyZTI0MWZiMjlmOTVkZmMyODM3NDQyYjk4 MGEzMSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9jaHJvbWl1bV9saW51eC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5CkBAIC00NSwxMiArNDUsNyBAQCBjbGFzcyBDaHJv bWl1bUxpbnV4UG9ydChjaHJvbWl1bS5DaHJvbWl1bVBvcnQpOgogICAgICAgICAneDg2JzogWydj aHJvbWl1bS1saW51eC14ODYnLCAnY2hyb21pdW0tbGludXgnLCAnY2hyb21pdW0td2luJywgJ2No cm9taXVtJywgJ3dpbicsICdtYWMnXSwKICAgICB9CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwg cG9ydF9uYW1lPU5vbmUsICoqa3dhcmdzKToKLSAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1l IG9yICdjaHJvbWl1bS1saW51eCcKLSAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5p dF9fKHNlbGYsIHBvcnRfbmFtZT1wb3J0X25hbWUsICoqa3dhcmdzKQotCi0gICAgICAgICMgV2Ug cmUtc2V0IHRoZSBwb3J0IG5hbWUgb25jZSB0aGUgYmFzZSBvYmplY3QgaXMgZnVsbHkgaW5pdGlh bGl6ZWQKLSAgICAgICAgIyBpbiBvcmRlciB0byBiZSBhYmxlIHRvIGZpbmQgdGhlIERSVCBiaW5h cnkgcHJvcGVybHkuCisgICAgZGVmIF9wYXJzZV9wb3J0X25hbWUoc2VsZiwgcG9ydF9uYW1lKToK ICAgICAgICAgaWYgcG9ydF9uYW1lLmVuZHN3aXRoKCctbGludXgnKToKICAgICAgICAgICAgIHNl bGYuX2FyY2hpdGVjdHVyZSA9IHNlbGYuX2RldGVybWluZV9hcmNoaXRlY3R1cmUoKQogICAgICAg ICAgICAgIyBGSVhNRTogdGhpcyBpcyBhbiB1Z2x5IGhhY2sgdG8gYXZvaWQgcmVuYW1pbmcgdGhl IEdQVSBwb3J0LgpAQCAtNjQsMTAgKzU5LDE4IEBAIGNsYXNzIENocm9taXVtTGludXhQb3J0KGNo cm9taXVtLkNocm9taXVtUG9ydCk6CiAgICAgICAgIGFzc2VydCBwb3J0X25hbWUgaW4gKCdjaHJv bWl1bS1saW51eCcsICdjaHJvbWl1bS1ncHUtbGludXgnLAogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAnY2hyb21pdW0tbGludXgteDg2JywgJ2Nocm9taXVtLWxpbnV4LXg4Nl82NCcsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICdjaHJvbWl1bS1ncHUtbGludXgteDg2XzY0JykK KyAgICAgICAgc2VsZi5fcG9ydF9uYW1lID0gJ2Nocm9taXVtLWxpbnV4JyAgIyBUaGlzIG1heSBi ZSB3cm9uZywgYnV0IHNlZW1zIHRvIG1hdGNoIHRoZSAidWdseSBoYWNrIHRvIGF2b2lkIHJlbmFt aW5nIHRoZSBHUFUgcG9ydCIgYWJvdmUuCiAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUK LSAgICAgICAgc2VsZi5fb3BlcmF0aW5nX3N5c3RlbSA9ICdsaW51eCcKICAgICAgICAgc2VsZi5f dmVyc2lvbiA9ICdsdWNpZCcgICMgV2Ugb25seSBzdXBwb3J0IGx1Y2lkIHJpZ2h0IG5vdy4KIAor ICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgKiprd2FyZ3MpOgorICAgICAg ICBwb3J0X25hbWUgPSBwb3J0X25hbWUgb3IgJ2Nocm9taXVtLWxpbnV4JworICAgICAgICBjaHJv bWl1bS5DaHJvbWl1bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKipr d2FyZ3MpCisgICAgICAgICMgV2UgcmUtc2V0IHRoZSBwb3J0IG5hbWUgb25jZSB0aGUgYmFzZSBv YmplY3QgaXMgZnVsbHkgaW5pdGlhbGl6ZWQKKyAgICAgICAgIyBpbiBvcmRlciB0byBiZSBhYmxl IHRvIGZpbmQgdGhlIERSVCBiaW5hcnkgcHJvcGVybHkuCisgICAgICAgIHNlbGYuX3BhcnNlX3Bv cnRfbmFtZShwb3J0X25hbWUpCisgICAgICAgIHNlbGYuX29wZXJhdGluZ19zeXN0ZW0gPSAnbGlu dXgnCisKICAgICBkZWYgX2RldGVybWluZV9hcmNoaXRlY3R1cmUoc2VsZik6CiAgICAgICAgIGRy aXZlcl9wYXRoID0gc2VsZi5fcGF0aF90b19kcml2ZXIoKQogICAgICAgICBmaWxlX291dHB1dCA9 ICcnCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2Nocm9taXVtX21hYy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvY2hyb21pdW1fbWFjLnB5CmluZGV4IDI2ZTQwZTU2NDY1NjNjNjJjNGFiOTE4NGU1YzRlZTg0 YjAxMDI4MDIuLmI3YTY4ZTA0MzRhN2EyMTZmY2U3NTdiM2FjMDhhOGZmYzU0YTlkMDcgMTAwNjQ0 Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1f bWFjLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hy b21pdW1fbWFjLnB5CkBAIC02NywxNyArNjcsMjIgQEAgY2xhc3MgQ2hyb21pdW1NYWNQb3J0KGNo cm9taXVtLkNocm9taXVtUG9ydCk6CiAgICAgICAgIF0sCiAgICAgfQogCi0gICAgZGVmIF9faW5p dF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvc192ZXJzaW9uX3N0cmluZz1Ob25lLCAqKmt3YXJn cyk6Ci0gICAgICAgICMgV2UncmUgYSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhpcyBj b2RlIGlzIHJldXNlZCBieSB0aGUKLSAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBhcyB3 ZWxsIGFzIHRoZSAnbW9jay0nIGFuZCAnZHJ5cnVuLScgcG9ydHMuCi0gICAgICAgIHBvcnRfbmFt ZSA9IHBvcnRfbmFtZSBvciAnY2hyb21pdW0tbWFjJwotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1 bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAg IyBGSVhNRTogdmVyc2lvbiwgbmFtZSwgZXRjLiBzaG91bGQgYmUgcGFzc2VkIHNlcGFyYXRlbHkg YW5kIHdlIHNob3VsZCBub3QgaGF2ZSB0byBwYXJzZSBwb3J0X25hbWUuCisgICAgZGVmIF9wYXJz ZV9wb3J0X25hbWUoc2VsZiwgcG9ydF9uYW1lLCBvc192ZXJzaW9uX3N0cmluZyk6CiAgICAgICAg IGlmIHBvcnRfbmFtZS5lbmRzd2l0aCgnLW1hYycpOgogICAgICAgICAgICAgc2VsZi5fdmVyc2lv biA9IG1hYy5vc192ZXJzaW9uKG9zX3ZlcnNpb25fc3RyaW5nLCBzZWxmLlNVUFBPUlRFRF9PU19W RVJTSU9OUykKICAgICAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBzZWxm Ll92ZXJzaW9uCiAgICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9y dF9uYW1lW3BvcnRfbmFtZS5pbmRleCgnLW1hYy0nKSArIDU6XQorICAgICAgICAgICAgc2VsZi5f cG9ydF9uYW1lID0gcG9ydF9uYW1lWzpwb3J0X25hbWUuaW5kZXgoJy1tYWMtJykgKyBsZW4oJy1t YWMnKV0KKyAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbcG9ydF9uYW1lLmlu ZGV4KCctbWFjLScpICsgbGVuKCctbWFjLScpOl0KICAgICAgICAgICAgIGFzc2VydCBzZWxmLl92 ZXJzaW9uIGluIHNlbGYuU1VQUE9SVEVEX09TX1ZFUlNJT05TCisKKyAgICBkZWYgX19pbml0X18o c2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9zX3ZlcnNpb25fc3RyaW5nPU5vbmUsICoqa3dhcmdzKToK KyAgICAgICAgIyBXZSdyZSBhIGxpdHRsZSBnZW5lcmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUg aXMgcmV1c2VkIGJ5IHRoZQorICAgICAgICAjICdnb29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwg YXMgdGhlICdtb2NrLScgYW5kICdkcnlydW4tJyBwb3J0cy4KKyAgICAgICAgcG9ydF9uYW1lID0g cG9ydF9uYW1lIG9yICdjaHJvbWl1bS1tYWMnCisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9y dC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAgICAg c2VsZi5fcGFyc2VfcG9ydF9uYW1lKHBvcnRfbmFtZSwgb3NfdmVyc2lvbl9zdHJpbmcpCiAgICAg ICAgIHNlbGYuX29wZXJhdGluZ19zeXN0ZW0gPSAnbWFjJwogCiAgICAgZGVmIGJhc2VsaW5lX3Nl YXJjaF9wYXRoKHNlbGYpOgpAQCAtODksOCArOTQsNyBAQCBjbGFzcyBDaHJvbWl1bU1hY1BvcnQo Y2hyb21pdW0uQ2hyb21pdW1Qb3J0KToKICAgICAgICAgaWYgbm90IHJlc3VsdDoKICAgICAgICAg ICAgIF9sb2cuZXJyb3IoJ0ZvciBjb21wbGV0ZSBNYWMgYnVpbGQgcmVxdWlyZW1lbnRzLCBwbGVh c2Ugc2VlOicpCiAgICAgICAgICAgICBfbG9nLmVycm9yKCcnKQotICAgICAgICAgICAgX2xvZy5l cnJvcignICAgIGh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9jaHJvbWl1bS93aWtpLycKLSAgICAg ICAgICAgICAgICAgICAgICAgJ01hY0J1aWxkSW5zdHJ1Y3Rpb25zJykKKyAgICAgICAgICAgIF9s b2cuZXJyb3IoJyAgICBodHRwOi8vY29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vd2lraS9NYWNC dWlsZEluc3RydWN0aW9ucycpCiAKICAgICAgICAgcmV0dXJuIHJlc3VsdAogCkBAIC0xNDcsOCAr MTUxLDcgQEAgY2xhc3MgQ2hyb21pdW1NYWNQb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6CiAg ICAgICAgIHJldHVybiBzZWxmLl9saWdodHRwZF9wYXRoKCdiaW4nLCAncGhwLWNnaScpCiAKICAg ICBkZWYgX3BhdGhfdG9fZHJpdmVyKHNlbGYsIGNvbmZpZ3VyYXRpb249Tm9uZSk6Ci0gICAgICAg ICMgRklYTUU6IG1ha2UgfGNvbmZpZ3VyYXRpb258IGhhcHB5IHdpdGggY2FzZS1zZW5zaXRpdmUg ZmlsZQotICAgICAgICAjIHN5c3RlbXMuCisgICAgICAgICMgRklYTUU6IG1ha2UgfGNvbmZpZ3Vy YXRpb258IGhhcHB5IHdpdGggY2FzZS1zZW5zaXRpdmUgZmlsZSBzeXN0ZW1zLgogICAgICAgICBp ZiBub3QgY29uZmlndXJhdGlvbjoKICAgICAgICAgICAgIGNvbmZpZ3VyYXRpb24gPSBzZWxmLmdl dF9vcHRpb24oJ2NvbmZpZ3VyYXRpb24nKQogICAgICAgICByZXR1cm4gc2VsZi5fYnVpbGRfcGF0 aChjb25maWd1cmF0aW9uLCBzZWxmLmRyaXZlcl9uYW1lKCkgKyAnLmFwcCcsCmRpZmYgLS1naXQg YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5w eSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fd2lu LnB5CmluZGV4IGI5MDNjM2ZlMmEyN2UwZjAzYTA4ZjdiZWNhZDJhNGExZmNkNWIyNGIuLjhlNThm YWIzNjk1YzE4ZTE1Nzg4NzZmM2FhYWY1ZTg1Y2MxZWE0YWQgMTAwNzU1Ci0tLSBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fd2luLnB5CisrKyBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fd2luLnB5CkBA IC02NSwxOCArNjUsMjIgQEAgY2xhc3MgQ2hyb21pdW1XaW5Qb3J0KGNocm9taXVtLkNocm9taXVt UG9ydCk6CiAgICAgICAgICd3aW43JzogWydjaHJvbWl1bS13aW4nLCAnY2hyb21pdW0nLCAnd2lu JywgJ21hYyddLAogICAgIH0KIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9u ZSwgd2luZG93c192ZXJzaW9uPU5vbmUsICoqa3dhcmdzKToKLSAgICAgICAgIyBXZSdyZSBhIGxp dHRsZSBnZW5lcmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUgaXMgcmV1c2VkIGJ5IHRoZQotICAg ICAgICAjICdnb29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwgYXMgdGhlICdtb2NrLScgYW5kICdk cnlydW4tJyBwb3J0cy4KLSAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdjaHJvbWl1 bS13aW4nCi0gICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0 X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAjIEZJWE1FOiB2ZXJzaW9uLCBuYW1lLCBl dGMuIHNob3VsZCBiZSBwYXNzZWQgc2VwYXJhdGVseSBhbmQgd2Ugc2hvdWxkIG5vdCBoYXZlIHRv IHBhcnNlIHBvcnRfbmFtZS4KKyAgICBkZWYgX3BhcnNlX3BvcnRfbmFtZShzZWxmLCBwb3J0X25h bWUsIHdpbmRvd3NfdmVyc2lvbik6CiAgICAgICAgIGlmIHBvcnRfbmFtZS5lbmRzd2l0aCgnLXdp bicpOgogICAgICAgICAgICAgc2VsZi5fdmVyc2lvbiA9IG9zX3ZlcnNpb24od2luZG93c192ZXJz aW9uKQogICAgICAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSArICctJyArIHNlbGYuX3Zl cnNpb24KICAgICAgICAgZWxzZToKLSAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25h bWVbcG9ydF9uYW1lLmluZGV4KCctd2luLScpICsgNTpdCi0gICAgICAgICAgICBhc3NlcnQgc2Vs Zi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUworICAgICAgICAgICAgc2VsZi5f cG9ydF9uYW1lID0gcG9ydF9uYW1lWzpwb3J0X25hbWUuaW5kZXgoJy13aW4tJykgKyBsZW4oJy13 aW4nKV0KKyAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbcG9ydF9uYW1lLmlu ZGV4KCctd2luLScpICsgbGVuKCctd2luLScpOl0KKyAgICAgICAgICAgIGFzc2VydCBzZWxmLl92 ZXJzaW9uIGluIHNlbGYuU1VQUE9SVEVEX1ZFUlNJT05TLCAiJXMgaXMgbm90IGluICVzIiAlIChz ZWxmLl92ZXJzaW9uLCBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUykKIAorICAgIGRlZiBfX2luaXRf XyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgd2luZG93c192ZXJzaW9uPU5vbmUsICoqa3dhcmdzKToK KyAgICAgICAgIyBXZSdyZSBhIGxpdHRsZSBnZW5lcmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUg aXMgcmV1c2VkIGJ5IHRoZQorICAgICAgICAjICdnb29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwg YXMgdGhlICdtb2NrLScgYW5kICdkcnlydW4tJyBwb3J0cy4KKyAgICAgICAgcG9ydF9uYW1lID0g cG9ydF9uYW1lIG9yICdjaHJvbWl1bS13aW4nCisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9y dC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAgICAg c2VsZi5fcGFyc2VfcG9ydF9uYW1lKHBvcnRfbmFtZSwgd2luZG93c192ZXJzaW9uKQogICAgICAg ICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0gJ3dpbicKIAogICAgIGRlZiBzZXR1cF9lbnZpcm9u X2Zvcl9zZXJ2ZXIoc2VsZik6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2NvbmZpZy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvY29uZmlnLnB5CmluZGV4IDY1NDQxNzBlY2U0N2ZkYjY5NDA3NDIxODhhYWZh NzBkMjE1MzIwNDcuLmRlYmJjYmE2MGY0YmZjZjFlZWRmMGQ2ZjUyNWY3ODFlZDFjNThjM2MgMTAw NjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY29uZmln LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY29uZmln LnB5CkBAIC0xMTgsNyArMTE4LDggQEAgY2xhc3MgQ29uZmlnKG9iamVjdCk6CiAgICAgICAgICMK ICAgICAgICAgIyBUaGlzIGNvZGUgd2lsbCBhbHNvIHdvcmsgaWYgdGhlcmUgaXMgbm8gU0NNIHN5 c3RlbSBhdCBhbGwuCiAgICAgICAgIGlmIG5vdCBzZWxmLl93ZWJraXRfYmFzZV9kaXI6Ci0gICAg ICAgICAgICBhYnNwYXRoID0gc2VsZi5fZmlsZXN5c3RlbS5hYnNwYXRoKF9fZmlsZV9fKQorICAg ICAgICAgICAgY29uZmlnX21vZHVsZV9wYXRoID0gc2VsZi5fZmlsZXN5c3RlbS5wYXRoX3RvX21v ZHVsZShzZWxmLl9fbW9kdWxlX18pCisgICAgICAgICAgICBhYnNwYXRoID0gc2VsZi5fZmlsZXN5 c3RlbS5hYnNwYXRoKGNvbmZpZ19tb2R1bGVfcGF0aCkgICMgRklYTUU6IEkgc3VzcGVjdCB0aGlz IGlzIGEgbm9vcC4KICAgICAgICAgICAgIHNlbGYuX3dlYmtpdF9iYXNlX2RpciA9IGFic3BhdGhb MDphYnNwYXRoLmZpbmQoJ1Rvb2xzJykgLSAxXQogICAgICAgICByZXR1cm4gc2VsZi5fd2Via2l0 X2Jhc2VfZGlyCiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvZ3RrLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9ndGsucHkKaW5kZXggMjU2YTVlZjAzOWRmOGQzZWQ0NjcyMDJjMTk4ZDY2NWM2NmEzZjY0Ny4u OTk1NWZkNmIwZWUwODk2Zjg4NGExMGRiNzhhMDhjYjkyZjY5YjFjZSAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKKysrIGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHkKQEAgLTQ4LDcgKzQ4LDcg QEAgY2xhc3MgR3RrUG9ydChXZWJLaXRQb3J0KToKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAnYXBhY2hlMi1kZWJpYW4taHR0cGQuY29uZicpCiAKICAgICBkZWYgX3BhdGhf dG9fZHJpdmVyKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5fYnVpbGRfcGF0aCgnUHJvZ3Jh bXMnLCAnRHVtcFJlbmRlclRyZWUnKQorICAgICAgICByZXR1cm4gc2VsZi5fYnVpbGRfcGF0aCgn UHJvZ3JhbXMnLCBzZWxmLmRyaXZlcl9uYW1lKCkpCiAKICAgICBkZWYgY2hlY2tfYnVpbGQoc2Vs ZiwgbmVlZHNfaHR0cCk6CiAgICAgICAgIGlmIG5vdCBzZWxmLl9jaGVja19kcml2ZXIoKToKZGlm ZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5 IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkKaW5kZXgg NmMxYzk2OWI0MzM0NzU1MTUyN2E3NzlkNmE1ZTQyYmFlNjM3ZGUxMy4uZWE5NjEyNWViYzBkODc5 YWM0OTQ5ODNlNmRmNTc2NTk4YzUyN2NmYyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkKQEAgLTMzLDcgKzMzLDcgQEAgaW1wb3J0IHBsYXRm b3JtCiAKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQud2Via2l0IGltcG9ydCBXZWJL aXRQb3J0CiAKLV9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3Rz LnBvcnQubWFjIikKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKIAogCiBkZWYg b3NfdmVyc2lvbihvc192ZXJzaW9uX3N0cmluZz1Ob25lLCBzdXBwb3J0ZWRfdmVyc2lvbnM9Tm9u ZSk6CkBAIC00NSwxMSArNDUsMTIgQEAgZGVmIG9zX3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmc9 Tm9uZSwgc3VwcG9ydGVkX3ZlcnNpb25zPU5vbmUpOgogICAgICAgICAgICAgb3NfdmVyc2lvbl9z dHJpbmcgPSAiMTAuNS42IgogICAgIHJlbGVhc2VfdmVyc2lvbiA9IGludChvc192ZXJzaW9uX3N0 cmluZy5zcGxpdCgnLicpWzFdKQogICAgIHZlcnNpb25fc3RyaW5ncyA9IHsKLSAgICAgICAgNDog J3RpZ2VyJywKICAgICAgICAgNTogJ2xlb3BhcmQnLAogICAgICAgICA2OiAnc25vd2xlb3BhcmQn LAorICAgICAgICAjIEFkZCA3OiAnbGlvbicgaGVyZT8KICAgICB9CiAgICAgYXNzZXJ0IHJlbGVh c2VfdmVyc2lvbiA+PSBtaW4odmVyc2lvbl9zdHJpbmdzLmtleXMoKSkKKyAgICAjIEZJWE1FOiBU aGVyZSBpcyBubyBtYWMtZnV0dXJlIGRpcmVjdG9yeSwgSSBkb24ndCB1bmRlcnN0YW5kIHdoeSB0 aGlzIGNvZGUgaXMgaGVyZS4KICAgICB2ZXJzaW9uX3N0cmluZyA9IHZlcnNpb25fc3RyaW5ncy5n ZXQocmVsZWFzZV92ZXJzaW9uLCAnZnV0dXJlJykKICAgICBpZiBzdXBwb3J0ZWRfdmVyc2lvbnM6 CiAgICAgICAgIGFzc2VydCB2ZXJzaW9uX3N0cmluZyBpbiBzdXBwb3J0ZWRfdmVyc2lvbnMKQEAg LTU3LDI4ICs1OCwzMyBAQCBkZWYgb3NfdmVyc2lvbihvc192ZXJzaW9uX3N0cmluZz1Ob25lLCBz dXBwb3J0ZWRfdmVyc2lvbnM9Tm9uZSk6CiAKIAogY2xhc3MgTWFjUG9ydChXZWJLaXRQb3J0KToK LSAgICAiIiJXZWJLaXQgTWFjIGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIiIgog ICAgICMgRklYTUU6ICd3azInIHByb2JhYmx5IHNob3VsZG4ndCBiZSBhIHZlcnNpb24sIGl0IHNo b3VsZCBwcm9iYWJseSBiZQogICAgICMgYSBtb2RpZmllciwgbGlrZSAnY2hyb21pdW0tZ3B1JyBp cyB0byAnY2hyb21pdW0nLgotICAgIFNVUFBPUlRFRF9WRVJTSU9OUyA9ICgndGlnZXInLCAnbGVv cGFyZCcsICdzbm93bGVvcGFyZCcsICdmdXR1cmUnLCAnd2syJykKKyAgICBTVVBQT1JURURfVkVS U0lPTlMgPSAoJ2xlb3BhcmQnLCAnc25vd2xlb3BhcmQnLCAnZnV0dXJlJywgJ3drMicpCiAKICAg ICBGQUxMQkFDS19QQVRIUyA9IHsKLSAgICAgICAgJ3RpZ2VyJzogWydtYWMtdGlnZXInLCAnbWFj LWxlb3BhcmQnLCAnbWFjLXNub3dsZW9wYXJkJywgJ21hYyddLAogICAgICAgICAnbGVvcGFyZCc6 IFsnbWFjLWxlb3BhcmQnLCAnbWFjLXNub3dsZW9wYXJkJywgJ21hYyddLAogICAgICAgICAnc25v d2xlb3BhcmQnOiBbJ21hYy1zbm93bGVvcGFyZCcsICdtYWMnXSwKICAgICAgICAgJ2Z1dHVyZSc6 IFsnbWFjJ10sCisgICAgICAgICMgRklYTUU6IFRoaXMgaXNuJ3QgcXVpdGUgcmlnaHQgZm9yIHdr MiwgaXQgc2hvdWxkIGluY2x1ZGUgbWFjLVZFUlNJT04gYXMgd2VsbC4KICAgICAgICAgJ3drMic6 IFsnbWFjLXdrMicsICdtYWMnXSwKICAgICB9CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9y dF9uYW1lPU5vbmUsIG9zX3ZlcnNpb25fc3RyaW5nPU5vbmUsICoqa3dhcmdzKToKLSAgICAgICAg cG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdtYWMnCi0gICAgICAgIFdlYktpdFBvcnQuX19pbml0 X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAgIyBGSVhNRTogdmVy c2lvbiwgbmFtZSwgZXRjLiBzaG91bGQgYmUgcGFzc2VkIHNlcGFyYXRlbHkgYW5kIHdlIHNob3Vs ZCBub3QgaGF2ZSB0byBwYXJzZSBwb3J0X25hbWUuCisgICAgZGVmIF9wYXJzZV9wb3J0X25hbWUo c2VsZiwgcG9ydF9uYW1lLCBvc192ZXJzaW9uX3N0cmluZyk6CiAgICAgICAgIGlmIHBvcnRfbmFt ZSA9PSAnbWFjJzoKICAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBvc192ZXJzaW9uKG9zX3Zl cnNpb25fc3RyaW5nKQogICAgICAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSArICctJyAr IHNlbGYuX3ZlcnNpb24KICAgICAgICAgZWxzZToKLSAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24g PSBwb3J0X25hbWVbNDpdCi0gICAgICAgICAgICBhc3NlcnQgc2VsZi5fdmVyc2lvbiBpbiBzZWxm LlNVUFBPUlRFRF9WRVJTSU9OUworICAgICAgICAgICAgYXNzZXJ0IHBvcnRfbmFtZS5zdGFydHN3 aXRoKCdtYWMnKQorICAgICAgICAgICAgc2VsZi5fcG9ydF9uYW1lID0gJ21hYycKKyAgICAgICAg ICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbbGVuKCdtYWMtJyk6XQorICAgICAgICAgICAg YXNzZXJ0IHNlbGYuX3ZlcnNpb24gaW4gc2VsZi5TVVBQT1JURURfVkVSU0lPTlMsICIlcyBpcyBu b3QgaW4gJXMiICUgKHNlbGYuX3ZlcnNpb24sIHNlbGYuU1VQUE9SVEVEX1ZFUlNJT05TKQorCisg ICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvc192ZXJzaW9uX3N0cmluZz1O b25lLCAqKmt3YXJncyk6CisgICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZSBvciAnbWFjJwor ICAgICAgICBXZWJLaXRQb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1wb3J0X25hbWUsICoq a3dhcmdzKQorICAgICAgICBzZWxmLl9wYXJzZV9wb3J0X25hbWUocG9ydF9uYW1lLCBvc192ZXJz aW9uX3N0cmluZykKICAgICAgICAgc2VsZi5fb3BlcmF0aW5nX3N5c3RlbSA9ICdtYWMnCiAgICAg ICAgIGlmIG5vdCBoYXNhdHRyKHNlbGYuX29wdGlvbnMsICd0aW1lLW91dC1tcycpIG9yIHNlbGYu X29wdGlvbnMudGltZV9vdXRfbXMgaXMgTm9uZToKICAgICAgICAgICAgIHNlbGYuX29wdGlvbnMu dGltZV9vdXRfbXMgPSAzNTAwMApAQCAtOTYsMTkgKzEwMiw3IEBAIGNsYXNzIE1hY1BvcnQoV2Vi S2l0UG9ydCk6CiAgICAgICAgIHJldHVybiBtYXAoc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgs IHNlbGYuRkFMTEJBQ0tfUEFUSFNbc2VsZi5fdmVyc2lvbl0pCiAKICAgICBkZWYgcGF0aF90b190 ZXN0X2V4cGVjdGF0aW9uc19maWxlKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5wYXRoX2Zy b21fd2Via2l0X2Jhc2UoJ0xheW91dFRlc3RzJywgJ3BsYXRmb3JtJywKLSAgICAgICAgICAgJ21h YycsICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQnKQotCi0gICAgZGVmIF9za2lwcGVkX2ZpbGVfcGF0 aHMoc2VsZik6Ci0gICAgICAgICMgRklYTUU6IFRoaXMgbWV0aG9kIHdpbGwgbmVlZCB0byBiZSBt YWRlIHdvcmsgZm9yIG5vbi1tYWMKLSAgICAgICAgIyBwbGF0Zm9ybXMgYW5kIG1vdmVkIGludG8g YmFzZS5Qb3J0LgotICAgICAgICBza2lwcGVkX2ZpbGVzID0gW10KLSAgICAgICAgaWYgc2VsZi5f bmFtZSBpbiAoJ21hYy1sZW9wYXJkJywgJ21hYy1zbm93bGVvcGFyZCcpOgotICAgICAgICAgICAg c2tpcHBlZF9maWxlcy5hcHBlbmQoc2VsZi5fZmlsZXN5c3RlbS5qb2luKAotICAgICAgICAgICAg ICAgIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpLCAnU2tpcHBlZCcpKQot ICAgICAgICBza2lwcGVkX2ZpbGVzLmFwcGVuZChzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5f d2Via2l0X2Jhc2VsaW5lX3BhdGgoJ21hYycpLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgJ1NraXBwZWQnKSkKLSAgICAgICAgcmV0dXJuIHNraXBwZWRfZmlsZXMK KyAgICAgICAgcmV0dXJuIHNlbGYucGF0aF9mcm9tX3dlYmtpdF9iYXNlKCdMYXlvdXRUZXN0cycs ICdwbGF0Zm9ybScsICdtYWMnLCAndGVzdF9leHBlY3RhdGlvbnMudHh0JykKIAogICAgIGRlZiBf YnVpbGRfamF2YV90ZXN0X3N1cHBvcnQoc2VsZik6CiAgICAgICAgIGphdmFfdGVzdHNfcGF0aCA9 IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgImphdmEiKQpA QCAtMTIyLDggKzExNiw3IEBAIGNsYXNzIE1hY1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgIHJl dHVybiBzZWxmLl9idWlsZF9qYXZhX3Rlc3Rfc3VwcG9ydCgpCiAKICAgICBkZWYgX3BhdGhfdG9f YXBhY2hlX2NvbmZpZ19maWxlKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3Rl bS5qb2luKHNlbGYubGF5b3V0X3Rlc3RzX2RpcigpLCAnaHR0cCcsICdjb25mJywKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnYXBhY2hlMi1odHRwZC5jb25mJykKKyAgICAg ICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwg J2h0dHAnLCAnY29uZicsICdhcGFjaGUyLWh0dHBkLmNvbmYnKQogCiAgICAgZGVmIF9wYXRoX3Rv X3dlYmNvcmVfbGlicmFyeShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgo J1dlYkNvcmUuZnJhbWV3b3JrL1ZlcnNpb25zL0EvV2ViQ29yZScpCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5Cmlu ZGV4IGFlNTQ3ZjJiOTZiODVmMTRhNmVmZDA2YWFjMWU5MTZiZWE2NzQ1Y2MuLjNjNWUyOTAxMWYz NDJiMDY0OTE1NDMwMzE2NmJhOWViMTNiY2VhZjUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CkBAIC00MCwy NCArNDAsMjAgQEAgY2xhc3MgTWFjVGVzdChwb3J0X3Rlc3RjYXNlLlBvcnRUZXN0Q2FzZSk6CiAg ICAgICAgICAgICByZXR1cm4gTm9uZQogICAgICAgICByZXR1cm4gbWFjLk1hY1BvcnQKIAotICAg IGRlZiBhc3NlcnRfc2tpcHBlZF9maWxlc19mb3JfdmVyc2lvbihzZWxmLCBwb3J0X25hbWUsIGV4 cGVjdGVkX3BhdGhzKToKKyAgICBkZWYgYXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMo c2VsZiwgcG9ydF9uYW1lLCBleHBlY3RlZF9wYXRocyk6CiAgICAgICAgIHBvcnQgPSBtYWMuTWFj UG9ydChwb3J0X25hbWU9cG9ydF9uYW1lKQotICAgICAgICBza2lwcGVkX3BhdGhzID0gcG9ydC5f c2tpcHBlZF9maWxlX3BhdGhzKCkKLSAgICAgICAgIyBGSVhNRTogX3NraXBwZWRfZmlsZV9wYXRo cyBzaG91bGQgcmV0dXJuIFdlYktpdC1yZWxhdGl2ZSBwYXRocy4KLSAgICAgICAgIyBTbyB0byBt YWtlIGl0IHVuaXQgdGVzdGFibGUsIHdlIHN0cmlwIHRoZSBXZWJLaXQgZGlyZWN0b3J5IGZyb20g dGhlIHBhdGguCi0gICAgICAgIHJlbGF0aXZlX3BhdGhzID0gW3BhdGhbbGVuKHBvcnQucGF0aF9m cm9tX3dlYmtpdF9iYXNlKCkpOl0gZm9yIHBhdGggaW4gc2tpcHBlZF9wYXRoc10KLSAgICAgICAg c2VsZi5hc3NlcnRFcXVhbChyZWxhdGl2ZV9wYXRocywgZXhwZWN0ZWRfcGF0aHMpCi0KLSAgICBk ZWYgdGVzdF9za2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgICMgV2Ugc2tpcCB0aGlz IG9uIHdpbjMyIGJlY2F1c2Ugd2UgdXNlICcvJyBhcyB0aGUgZGlyIHNlcGFyYXRvciBhbmQgaXQn cwotICAgICAgICAjIG5vdCB3b3J0aCBtYWtpbmcgcGxhdGZvcm0taW5kZXBlbmRlbnQuCisgICAg ICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9ydC5fc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygpLCBl eHBlY3RlZF9wYXRocykKKworICAgIGRlZiB0ZXN0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMo c2VsZik6CisgICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIG5vIGxvbmdlciBiZSBuZWNlc3Nh cnksIGJ1dCBJJ20gbm90IGJyYXZlIGVub3VnaCB0byByZW1vdmUgaXQuCiAgICAgICAgIGlmIHN5 cy5wbGF0Zm9ybSA9PSAnd2luMzInOgogICAgICAgICAgICAgcmV0dXJuIE5vbmUKIAotICAgICAg ICBzZWxmLmFzc2VydF9za2lwcGVkX2ZpbGVzX2Zvcl92ZXJzaW9uKCdtYWMtc25vd2xlb3BhcmQn LAotICAgICAgICAgICAgWycvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXNub3dsZW9wYXJkL1Nr aXBwZWQnLCAnL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9Ta2lwcGVkJ10pCi0gICAgICAgIHNl bGYuYXNzZXJ0X3NraXBwZWRfZmlsZXNfZm9yX3ZlcnNpb24oJ21hYy1sZW9wYXJkJywKLSAgICAg ICAgICAgIFsnL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy1sZW9wYXJkL1NraXBwZWQnLCAnL0xh eW91dFRlc3RzL3BsYXRmb3JtL21hYy9Ta2lwcGVkJ10pCisgICAgICAgIHNlbGYuYXNzZXJ0X3Nr aXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoJ21hYy1zbm93bGVvcGFyZCcsIFsnbWFjLXNub3dsZW9w YXJkJywgJ21hYyddKQorICAgICAgICBzZWxmLmFzc2VydF9za2lwcGVkX2ZpbGVfc2VhcmNoX3Bh dGhzKCdtYWMtbGVvcGFyZCcsIFsnbWFjLWxlb3BhcmQnLCAnbWFjJ10pCisgICAgICAgICMgV2Ug Y2Fubm90IHRlc3QganVzdCAibWFjIiBoZXJlIGFzIHRoZSBNYWNQb3J0IGNvbnN0cnVjdG9yIGF1 dG9tYXRpY2FsbHkgZmlsbHMgaW4gdGhlIHZlcnNpb24gZnJvbSB0aGUgcnVubmluZyBPUy4KKyAg ICAgICAgIyBzZWxmLmFzc2VydF9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCdtYWMnLCBbJ21h YyddKQorCiAKICAgICBleGFtcGxlX3NraXBwZWRfZmlsZSA9IHUiIiIKICMgPHJkYXI6Ly9wcm9i bGVtLzU2NDc5NTI+IGZhc3QvZXZlbnRzL21vdXNlb3V0LW9uLXdpbmRvdy5odG1sIG5lZWRzIG1h YyBEUlQgdG8gaXNzdWUgbW91c2Ugb3V0IGV2ZW50cwpAQCAtOTgsMTMgKzk0LDcgQEAgc3ZnL2Jh dGlrL3RleHQvc21hbGxGb250cy5zdmcKICAgICBkZWYgdGVzdF92ZXJzaW9ucyhzZWxmKToKICAg ICAgICAgcG9ydCA9IHNlbGYubWFrZV9wb3J0KCkKICAgICAgICAgaWYgcG9ydDoKLSAgICAgICAg ICAgIHNlbGYuYXNzZXJ0VHJ1ZShwb3J0Lm5hbWUoKSBpbiAoJ21hYy10aWdlcicsICdtYWMtbGVv cGFyZCcsICdtYWMtc25vd2xlb3BhcmQnLCAnbWFjLWZ1dHVyZScpKQotCi0gICAgICAgIHNlbGYu YXNzZXJ0X25hbWUoTm9uZSwgJzEwLjQuOCcsICdtYWMtdGlnZXInKQotICAgICAgICBzZWxmLmFz c2VydF9uYW1lKCdtYWMnLCAnMTAuNC44JywgJ21hYy10aWdlcicpCi0gICAgICAgIHNlbGYuYXNz ZXJ0X25hbWUoJ21hYy10aWdlcicsICcxMC40LjgnLCAnbWFjLXRpZ2VyJykKLSAgICAgICAgc2Vs Zi5hc3NlcnRfbmFtZSgnbWFjLXRpZ2VyJywgJzEwLjUuMycsICdtYWMtdGlnZXInKQotICAgICAg ICBzZWxmLmFzc2VydF9uYW1lKCdtYWMtdGlnZXInLCAnMTAuNi4zJywgJ21hYy10aWdlcicpCisg ICAgICAgICAgICBzZWxmLmFzc2VydFRydWUocG9ydC5uYW1lKCkgaW4gKCdtYWMtbGVvcGFyZCcs ICdtYWMtc25vd2xlb3BhcmQnLCAnbWFjLWZ1dHVyZScpKQogCiAgICAgICAgIHNlbGYuYXNzZXJ0 X25hbWUoTm9uZSwgJzEwLjUuMycsICdtYWMtbGVvcGFyZCcpCiAgICAgICAgIHNlbGYuYXNzZXJ0 X25hbWUoJ21hYycsICcxMC41LjMnLCAnbWFjLWxlb3BhcmQnKQpkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkKaW5kZXggNmZkNWRiYjlkMzYzODI4ZDdk MTUwOGU0Y2NiYzg2NWZlNGJkYzU3My4uY2MyYzU0NzY0MDA1YTg4YmUxOWYyMjBhNWNjOTY1YjQ5 NTNiM2Y5YSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC9xdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L3F0LnB5CkBAIC0zNSwxMiArMzUsMTAgQEAgaW1wb3J0IHdlYmtpdAogCiBmcm9tIHdlYmtpdHB5 LmxheW91dF90ZXN0cy5wb3J0LndlYmtpdCBpbXBvcnQgV2ViS2l0UG9ydAogCi1fbG9nID0gbG9n Z2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LnF0IikKK19sb2cgPSBs b2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKIAogCiBjbGFzcyBRdFBvcnQoV2ViS2l0UG9ydCk6 Ci0gICAgIiIiUXRXZWJLaXQgaW1wbGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xhc3MuIiIiCi0K ICAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3MpOgogICAgICAgICBrd2FyZ3Muc2V0ZGVm YXVsdCgncG9ydF9uYW1lJywgJ3F0JykKICAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxm LCAqKmt3YXJncykKQEAgLTY2LDcgKzY0LDcgQEAgY2xhc3MgUXRQb3J0KFdlYktpdFBvcnQpOgog ICAgICAgICByZXR1cm4gVHJ1ZQogCiAgICAgZGVmIF9wYXRoX3RvX2RyaXZlcihzZWxmKToKLSAg ICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgoJ2Jpbi9EdW1wUmVuZGVyVHJlZScpCisgICAg ICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKCdiaW4vJXMnICUgc2VsZi5kcml2ZXJfbmFtZSgp KQogCiAgICAgZGVmIF9wYXRoX3RvX2ltYWdlX2RpZmYoc2VsZik6CiAgICAgICAgIHJldHVybiBz ZWxmLl9idWlsZF9wYXRoKCdiaW4vSW1hZ2VEaWZmJykKZGlmZiAtLWdpdCBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXQucHkKaW5kZXggZTEzYzU3ZmRlOTNhNTNh MzEwNDcxZGEwNDYwY2MzYzY3ZDFjNGM4ZC4uOGM0N2FiMDVhMDZhOWRlNzEyZDkwNWVmYmRiZTkx Mzc4MjgwZTdmOSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC93ZWJraXQucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC93ZWJraXQucHkKQEAgLTY2LDExICs2NiwxMCBAQCBjbGFzcyBXZWJLaXRQb3J0KGJh c2UuUG9ydCk6CiAgICAgICAgIHJldHVybiAiRHVtcFJlbmRlclRyZWUiCiAKICAgICBkZWYgYmFz ZWxpbmVfc2VhcmNoX3BhdGgoc2VsZik6Ci0gICAgICAgIHJldHVybiBbc2VsZi5fd2Via2l0X2Jh c2VsaW5lX3BhdGgoc2VsZi5fbmFtZSldCisgICAgICAgIHJldHVybiBbc2VsZi5fd2Via2l0X2Jh c2VsaW5lX3BhdGgoc2VsZi5uYW1lKCkpXQogCiAgICAgZGVmIHBhdGhfdG9fdGVzdF9leHBlY3Rh dGlvbnNfZmlsZShzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihz ZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxmLl9uYW1lKSwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAndGVzdF9leHBlY3RhdGlvbnMudHh0JykKKyAgICAgICAgcmV0 dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxm Lm5hbWUoKSksICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQnKQogCiAgICAgZGVmIF9yZXN1bHRzX2Zv cl9wbGF0Zm9ybShzZWxmLCBwbGF0Zm9ybSk6CiAgICAgICAgIGJ1aWxkZXJfbmFtZSA9IGJ1aWxk ZXJzLmJ1aWxkZXJfbmFtZV9mb3JfcGxhdGZvcm0ocGxhdGZvcm0pCkBAIC0yODMsMTIgKzI4Miwx NiBAQCBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAgICAgICB0ZXN0c190b19z a2lwLmFwcGVuZChsaW5lKQogICAgICAgICByZXR1cm4gdGVzdHNfdG9fc2tpcAogCi0gICAgZGVm IF9za2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgIHJldHVybiBbc2VsZi5fZmlsZXN5 c3RlbS5qb2luKHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpLCAnU2tpcHBl ZCcpXQorICAgIGRlZiBfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocyhzZWxmKToKKyAgICAgICAg IyBVbmxpa2UgYmFzZWxpbmVfc2VhcmNoX3BhdGgsIHdlIG9ubHkgd2FudCB0byBzZWFyY2ggW1BP UlQtVkVSU0lPTiwgUE9SVF0gbm90IHRoZSBmdWxsIGNhc2FkZS4KKyAgICAgICAgaWYgc2VsZi5w b3J0X25hbWUoKSAhPSBzZWxmLm5hbWUoKToKKyAgICAgICAgICAgIHJldHVybiBbc2VsZi5uYW1l KCksIHNlbGYucG9ydF9uYW1lKCldCisgICAgICAgIHJldHVybiBbc2VsZi5uYW1lKCldCiAKICAg ICBkZWYgX2V4cGVjdGF0aW9uc19mcm9tX3NraXBwZWRfZmlsZXMoc2VsZik6CiAgICAgICAgIHRl c3RzX3RvX3NraXAgPSBbXQotICAgICAgICBmb3IgZmlsZW5hbWUgaW4gc2VsZi5fc2tpcHBlZF9m aWxlX3BhdGhzKCk6CisgICAgICAgIGZvciBzZWFyY2hfcGF0aCBpbiBzZWxmLl9za2lwcGVkX2Zp bGVfc2VhcmNoX3BhdGhzKCk6CisgICAgICAgICAgICBmaWxlbmFtZSA9IHNlbGYuX2ZpbGVzeXN0 ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWFyY2hfcGF0aCksICJTa2lwcGVk IikKICAgICAgICAgICAgIGlmIG5vdCBzZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhmaWxlbmFtZSk6 CiAgICAgICAgICAgICAgICAgX2xvZy53YXJuKCJGYWlsZWQgdG8gb3BlbiBTa2lwcGVkIGZpbGU6 ICVzIiAlIGZpbGVuYW1lKQogICAgICAgICAgICAgICAgIGNvbnRpbnVlCkBAIC0zMTIsOCArMzE1 LDcgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAgICAjIGZvcm1hdCBleHBl Y3RlZCBieSB0ZXN0X2V4cGVjdGF0aW9ucy4KIAogICAgICAgICB0ZXN0c190b19za2lwID0gc2Vs Zi5za2lwcGVkX2xheW91dF90ZXN0cygpCi0gICAgICAgIHNraXBfbGluZXMgPSBtYXAobGFtYmRh IHRlc3RfcGF0aDogIkJVR19TS0lQUEVEIFNLSVAgOiAlcyA9IEZBSUwiICUKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgdGVzdF9wYXRoLCB0ZXN0c190b19za2lwKQorICAgICAgICBz a2lwX2xpbmVzID0gbWFwKGxhbWJkYSB0ZXN0X3BhdGg6ICJCVUdfU0tJUFBFRCBTS0lQIDogJXMg PSBGQUlMIiAlIHRlc3RfcGF0aCwgdGVzdHNfdG9fc2tpcCkKICAgICAgICAgcmV0dXJuICJcbiIu am9pbihza2lwX2xpbmVzKQogCiAgICAgZGVmIHNraXBwZWRfbGF5b3V0X3Rlc3RzKHNlbGYpOgpA QCAtMzI4LDcgKzMzMCw3IEBAIGNsYXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAg ICAgIHNlbGYuZ2V0X29wdGlvbignY29uZmlndXJhdGlvbicpKSwgKmNvbXBzKQogCiAgICAgZGVm IF9wYXRoX3RvX2RyaXZlcihzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgo J0R1bXBSZW5kZXJUcmVlJykKKyAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgoc2VsZi5k cml2ZXJfbmFtZSgpKQogCiAgICAgZGVmIF9wYXRoX3RvX3dlYmNvcmVfbGlicmFyeShzZWxmKToK ICAgICAgICAgcmV0dXJuIE5vbmUKQEAgLTM1OSwxMiArMzYxLDEyIEBAIGNsYXNzIFdlYktpdFBv cnQoYmFzZS5Qb3J0KToKIAogCiBjbGFzcyBXZWJLaXREcml2ZXIoYmFzZS5Ecml2ZXIpOgotICAg ICIiIldlYktpdCBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgRHVtcFJlbmRlclRyZWUgaW50ZXJmYWNl LiIiIgorICAgICIiIkltcGxlbWVudGF0aW9uIG9mIHRoZSBEdW1wUmVuZGVyVHJlZS9XZWJLaXRU ZXN0UnVubmVyIGludGVyZmFjZS4iIiIKIAogICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3 b3JrZXJfbnVtYmVyKToKICAgICAgICAgc2VsZi5fd29ya2VyX251bWJlciA9IHdvcmtlcl9udW1i ZXIKICAgICAgICAgc2VsZi5fcG9ydCA9IHBvcnQKLSAgICAgICAgc2VsZi5fZHJpdmVyX3RlbXBk aXIgPSBwb3J0Ll9maWxlc3lzdGVtLm1rZHRlbXAocHJlZml4PSdEdW1wUmVuZGVyVHJlZS0nKQor ICAgICAgICBzZWxmLl9kcml2ZXJfdGVtcGRpciA9IHBvcnQuX2ZpbGVzeXN0ZW0ubWtkdGVtcChw cmVmaXg9JyVzLScgJSBzZWxmLl9wb3J0LmRyaXZlcl9uYW1lKCkpCiAKICAgICBkZWYgX19kZWxf XyhzZWxmKToKICAgICAgICAgc2VsZi5fcG9ydC5fZmlsZXN5c3RlbS5ybXRyZWUoc3RyKHNlbGYu X2RyaXZlcl90ZW1wZGlyKSkKQEAgLTM4OCw5ICszOTAsMTAgQEAgY2xhc3MgV2ViS2l0RHJpdmVy KGJhc2UuRHJpdmVyKToKICAgICBkZWYgc3RhcnQoc2VsZik6CiAgICAgICAgIGVudmlyb25tZW50 ID0gc2VsZi5fcG9ydC5zZXR1cF9lbnZpcm9uX2Zvcl9zZXJ2ZXIoKQogICAgICAgICBlbnZpcm9u bWVudFsnRFlMRF9GUkFNRVdPUktfUEFUSCddID0gc2VsZi5fcG9ydC5fYnVpbGRfcGF0aCgpCisg ICAgICAgICMgRklYTUU6IFdlJ3JlIGFzc3VtaW5nIHRoYXQgV2ViS2l0VGVzdFJ1bm5lciBjaGVj a3MgdGhpcyBEdW1wUmVuZGVyVHJlZS1uYW1lZCBlbnZpcm9ubWVudCB2YXJpYWJsZS4KICAgICAg ICAgZW52aXJvbm1lbnRbJ0RVTVBSRU5ERVJUUkVFX1RFTVAnXSA9IHN0cihzZWxmLl9kcml2ZXJf dGVtcGRpcikKICAgICAgICAgc2VsZi5fc2VydmVyX3Byb2Nlc3MgPSBzZXJ2ZXJfcHJvY2Vzcy5T ZXJ2ZXJQcm9jZXNzKHNlbGYuX3BvcnQsCi0gICAgICAgICAgICAiRHVtcFJlbmRlclRyZWUiLCBz ZWxmLmNtZF9saW5lKCksIGVudmlyb25tZW50KQorICAgICAgICAgICAgc2VsZi5fcG9ydC5kcml2 ZXJfbmFtZSgpLCBzZWxmLmNtZF9saW5lKCksIGVudmlyb25tZW50KQogCiAgICAgZGVmIHBvbGwo c2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9zZXJ2ZXJfcHJvY2Vzcy5wb2xsKCkKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3Vu aXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJr aXRfdW5pdHRlc3QucHkKaW5kZXggNmE4ZDdlMTEwZDYwNDg3MzM4MDc4OTYzMWM3ZjU1ZjA0OGU1 Nzg2NS4uOTgxYTQ4NTc3YTZkNWIyZWFkNjY3Mjk5ZDc1MTkxMzRmMzhlMGU2ZSAxMDA3NTUKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXRfdW5pdHRl c3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJr aXRfdW5pdHRlc3QucHkKQEAgLTMzLDIwICszMywxOCBAQCBmcm9tIHdlYmtpdHB5LmNvbW1vbi5z eXN0ZW0ub3V0cHV0Y2FwdHVyZSBpbXBvcnQgT3V0cHV0Q2FwdHVyZQogZnJvbSB3ZWJraXRweS5s YXlvdXRfdGVzdHMucG9ydC53ZWJraXQgaW1wb3J0IFdlYktpdFBvcnQKIGZyb20gd2Via2l0cHku bGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IHBvcnRfdGVzdGNhc2UKIAotZnJvbSB3ZWJraXRweS50 b29sLm1vY2t0b29sIGltcG9ydCBNb2NrRXhlY3V0aXZlCi1mcm9tIHdlYmtpdHB5LnRvb2wubW9j a3Rvb2wgaW1wb3J0IE1vY2tPcHRpb25zCitmcm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rvb2wgaW1w b3J0IE1vY2tFeGVjdXRpdmUsIE1vY2tPcHRpb25zLCBNb2NrVXNlcgorZnJvbSB3ZWJraXRweS5j b21tb24uc3lzdGVtLmZpbGVzeXN0ZW1fbW9jayBpbXBvcnQgTW9ja0ZpbGVTeXN0ZW0KIAogCiBj bGFzcyBUZXN0V2ViS2l0UG9ydChXZWJLaXRQb3J0KToKICAgICBkZWYgX19pbml0X18oc2VsZiwg c3ltYm9sX2xpc3Q9Tm9uZSwgZmVhdHVyZV9saXN0PU5vbmUsCi0gICAgICAgICAgICAgICAgIGV4 cGVjdGF0aW9uc19maWxlPU5vbmUsIHNraXBzX2ZpbGU9Tm9uZSwKLSAgICAgICAgICAgICAgICAg ZXhlY3V0aXZlPU5vbmUsICoqa3dhcmdzKToKKyAgICAgICAgICAgICAgICAgZXhlY3V0aXZlPU5v bmUsIGZpbGVzeXN0ZW09Tm9uZSwgKiprd2FyZ3MpOgogICAgICAgICBzZWxmLnN5bWJvbF9saXN0 ID0gc3ltYm9sX2xpc3QKICAgICAgICAgc2VsZi5mZWF0dXJlX2xpc3QgPSBmZWF0dXJlX2xpc3QK LSAgICAgICAgc2VsZi5leHBlY3RhdGlvbnNfZmlsZSA9IGV4cGVjdGF0aW9uc19maWxlCi0gICAg ICAgIHNlbGYuc2tpcHNfZmlsZSA9IHNraXBzX2ZpbGUKICAgICAgICAgZXhlY3V0aXZlID0gZXhl Y3V0aXZlIG9yIE1vY2tFeGVjdXRpdmUoc2hvdWxkX2xvZz1GYWxzZSkKLSAgICAgICAgV2ViS2l0 UG9ydC5fX2luaXRfXyhzZWxmLCBleGVjdXRpdmU9ZXhlY3V0aXZlLCAqKmt3YXJncykKKyAgICAg ICAgZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0gb3IgTW9ja0ZpbGVTeXN0ZW0oKQorICAgICAgICBX ZWJLaXRQb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT0idGVzdCIsIGV4ZWN1dGl2ZT1leGVj dXRpdmUsIHVzZXI9TW9ja1VzZXIoKSwgZmlsZXN5c3RlbT1maWxlc3lzdGVtLCAqKmt3YXJncykK IAogICAgIGRlZiBfcnVudGltZV9mZWF0dXJlX2xpc3Qoc2VsZik6CiAgICAgICAgIHJldHVybiBz ZWxmLmZlYXR1cmVfbGlzdApAQCAtNjAsMTYgKzU4LDYgQEAgY2xhc3MgVGVzdFdlYktpdFBvcnQo V2ViS2l0UG9ydCk6CiAgICAgZGVmIF90ZXN0c19mb3JfZGlzYWJsZWRfZmVhdHVyZXMoc2VsZik6 CiAgICAgICAgIHJldHVybiBbImFjY2Vzc2liaWxpdHkiLCBdCiAKLSAgICBkZWYgcGF0aF90b190 ZXN0X2V4cGVjdGF0aW9uc19maWxlKHNlbGYpOgotICAgICAgICBpZiBzZWxmLmV4cGVjdGF0aW9u c19maWxlOgotICAgICAgICAgICAgcmV0dXJuIHNlbGYuZXhwZWN0YXRpb25zX2ZpbGUKLSAgICAg ICAgcmV0dXJuIFdlYktpdFBvcnQucGF0aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKHNlbGYp Ci0KLSAgICBkZWYgX3NraXBwZWRfZmlsZV9wYXRocyhzZWxmKToKLSAgICAgICAgaWYgc2VsZi5z a2lwc19maWxlOgotICAgICAgICAgICAgcmV0dXJuIFtzZWxmLnNraXBzX2ZpbGVdCi0gICAgICAg IHJldHVybiBbXQotCiAKIGNsYXNzIFdlYktpdFBvcnRUZXN0KHBvcnRfdGVzdGNhc2UuUG9ydFRl c3RDYXNlKToKICAgICBkZWYgcG9ydF9tYWtlcihzZWxmLCBwbGF0Zm9ybSk6CkBAIC0xMDMsMTIg KzkxLDExIEBAIGNsYXNzIFdlYktpdFBvcnRUZXN0KHBvcnRfdGVzdGNhc2UuUG9ydFRlc3RDYXNl KToKICAgICAgICAgIyBDaGVjayB0aGF0IHdlIHJlYWQgYm90aCB0aGUgZXhwZWN0YXRpb25zIGZp bGUgYW5kIGFueXRoaW5nIGluIGEKICAgICAgICAgIyBTa2lwcGVkIGZpbGUsIGFuZCB0aGF0IHdl IGluY2x1ZGUgdGhlIGZlYXR1cmUgYW5kIHBsYXRmb3JtIGNoZWNrcy4KICAgICAgICAgZmlsZXMg PSB7Ci0gICAgICAgICAgICAnL3RtcC90ZXN0X2V4cGVjdGF0aW9ucy50eHQnOiAnQlVHX1RFU1RF WFBFQ1RBVElPTlMgU0tJUCA6IGZhc3QvaHRtbC9hcnRpY2xlLWVsZW1lbnQuaHRtbCA9IEZBSUxc bicsCi0gICAgICAgICAgICAnL3RtcC9Ta2lwcGVkJzogJ2Zhc3QvaHRtbC9rZXlnZW4uaHRtbCcs CisgICAgICAgICAgICAnL21vY2svTGF5b3V0VGVzdHMvcGxhdGZvcm0vdGVzdC90ZXN0X2V4cGVj dGF0aW9ucy50eHQnOiAnQlVHX1RFU1RFWFBFQ1RBVElPTlMgU0tJUCA6IGZhc3QvaHRtbC9hcnRp Y2xlLWVsZW1lbnQuaHRtbCA9IEZBSUxcbicsCisgICAgICAgICAgICAnL21vY2svTGF5b3V0VGVz dHMvcGxhdGZvcm0vdGVzdC9Ta2lwcGVkJzogJ2Zhc3QvaHRtbC9rZXlnZW4uaHRtbCcsCiAgICAg ICAgIH0KICAgICAgICAgbW9ja19mcyA9IGZpbGVzeXN0ZW1fbW9jay5Nb2NrRmlsZVN5c3RlbShm aWxlcykKLSAgICAgICAgcG9ydCA9IFRlc3RXZWJLaXRQb3J0KGV4cGVjdGF0aW9uc19maWxlPScv dG1wL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCcsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBza2lwc19maWxlPScvdG1wL1NraXBwZWQnLCBmaWxlc3lzdGVtPW1vY2tfZnMpCisgICAgICAg IHBvcnQgPSBUZXN0V2ViS2l0UG9ydChmaWxlc3lzdGVtPW1vY2tfZnMpCiAgICAgICAgIHNlbGYu YXNzZXJ0RXF1YWwocG9ydC50ZXN0X2V4cGVjdGF0aW9ucygpLAogICAgICAgICAiIiJCVUdfVEVT VEVYUEVDVEFUSU9OUyBTS0lQIDogZmFzdC9odG1sL2FydGljbGUtZWxlbWVudC5odG1sID0gRkFJ TAogQlVHX1NLSVBQRUQgU0tJUCA6IGZhc3QvaHRtbC9rZXlnZW4uaHRtbCA9IEZBSUwKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVz dHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzLnB5CmluZGV4IDJkZmJiOGVjOTkyYjc1MDE2YTkxZmZlZTRmZjc2MjhmYmFkMzM1ZTIuLmM0 MmIwZjIxOWUyYjI0MzJlZDU4ZjZmYjY2MDRhYzkwMDZhYjM5OTAgMTAwNzU1Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKKysrIGIv VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQpA QCAtMjY4LDcgKzI2OCw3IEBAIGRlZiBwYXJzZV9hcmdzKGFyZ3M9Tm9uZSk6CiAgICAgICAgIG9w dHBhcnNlLm1ha2Vfb3B0aW9uKCItLWNvbXBsZXgtdGV4dCIsIGFjdGlvbj0ic3RvcmVfdHJ1ZSIs IGRlZmF1bHQ9RmFsc2UsCiAgICAgICAgICAgICBoZWxwPSJVc2UgdGhlIGNvbXBsZXggdGV4dCBj b2RlIHBhdGggZm9yIGFsbCB0ZXh0IChNYWMgT1MgWCBhbmQgV2luZG93cyBvbmx5KSIpLAogICAg ICAgICBvcHRwYXJzZS5tYWtlX29wdGlvbigiLS10aHJlYWRlZCIsIGFjdGlvbj0ic3RvcmVfdHJ1 ZSIsIGRlZmF1bHQ9RmFsc2UsCi0gICAgICAgICAgICBoZWxwPSJSdW4gYSBjb25jdXJyZW50IEph dmFTY3JpcHQgdGhlYWQgd2l0aCBlYWNoIHRlc3QiKSwKKyAgICAgICAgICAgIGhlbHA9IlJ1biBh IGNvbmN1cnJlbnQgSmF2YVNjcmlwdCB0aHJlYWQgd2l0aCBlYWNoIHRlc3QiKSwKICAgICAgICAg b3B0cGFyc2UubWFrZV9vcHRpb24oIi0td2Via2l0LXRlc3QtcnVubmVyIiwgIi0yIiwgYWN0aW9u PSJzdG9yZV90cnVlIiwKICAgICAgICAgICAgIGhlbHA9IlVzZSBXZWJLaXRUZXN0UnVubmVyIHJh dGhlciB0aGFuIER1bXBSZW5kZXJUcmVlLiIpLAogICAgIF0KZGlmZiAtLWdpdCBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3JlYmFzZWxpbmUucHkKaW5kZXggMzRhMzk4YTg3NTg3 MDg1NzIxZGEwZDY1MWEwMzhlZmZiNzFjNTVhNi4uMDM2ZDgyYjAwOTFmNjBjNGI2MjgzMWQwODRm ZjVjNTA1Y2ZjYWIyYyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2Nv bW1hbmRzL3JlYmFzZWxpbmUucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2Nv bW1hbmRzL3JlYmFzZWxpbmUucHkKQEAgLTQ2LDcgKzQ2LDYgQEAgY2xhc3MgQnVpbGRlclRvUG9y dChvYmplY3QpOgogICAgIF9idWlsZGVyX25hbWVfdG9fcG9ydF9uYW1lID0gewogICAgICAgICBy IlNub3dMZW9wYXJkIjogIm1hYy1zbm93bGVvcGFyZCIsCiAgICAgICAgIHIiTGVvcGFyZCI6ICJt YWMtbGVvcGFyZCIsCi0gICAgICAgIHIiVGlnZXIiOiAibWFjLXRpZ2VyIiwKICAgICAgICAgciJX aW5kb3dzIjogIndpbiIsCiAgICAgICAgIHIiR1RLIjogImd0ayIsCiAgICAgICAgIHIiUXQiOiAi cXQiLAo= 98847 2011-06-27 20:39:24 -0700 2011-06-28 16:15:42 -0700 Patch bug-63501-20110627203923.patch text/plain 43907 eric U3VidmVyc2lvbiBSZXZpc2lvbjogODk4ODcKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCAwYTI2MTg0YWRkMDkwZGMwOTcwYWVjYzEzZDQwNjliODI5 ODM1MTgzLi5iYThhYjRmYWIzZGMyMDJjYTRjYTU0OGQwNTRlN2IwYmVlOWI0ZDYzIDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsODUg QEAKKzIwMTEtMDYtMjcgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNpbXBsaWZ5IHNraXBwZWQg ZmlsZSBmaW5kaW5nIGluIHByZXBhcmF0aW9uIGZvciBhZGRpbmcgd2syIHNraXBwZWQgbGlzdCBm YWxsYmFjaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjM1MDEKKworICAgICAgICBUaGlzIHBhdGNoIGVuZGVkIHVwIGRvaW5nIHRvbyBtdWNoIChJJ20g aGFwcHkgdG8gYnJlYWsgaXQgaW50byBwaWVjZXMgaWYgbmVjZXNzYXJ5KS4KKworICAgICAgICBU aGUgZ29hbCB3YXMgdG8gYWRkIHN1cHBvcnQgZm9yIHdrMiBza2lwcGVkIGxpc3RzLgorICAgICAg ICBIb3dldmVyLCBJIGZvdW5kIHRoYXQgb3VyIHNraXBwZWQgbGlzdCBjb21wdXRhdGlvbiB3YXMg YQorICAgICAgICBtYW51YWwgaGFjayAod2hpY2ggb25seSB3b3JrZWQgZm9yIHRoZSBtYWMgcG9y dCkuCisKKyAgICAgICAgU28gSSBmaXhlZCBhIEZJWE1FIHRvIG1vdmUgdGhlIHNraXBwZWQgbGlz dCBmaW5kaW5nCisgICAgICAgIGludG8gV2ViS2l0UG9ydCBpbnN0ZWFkIG9mIE1hY1BvcnQuCisg ICAgICAgIERvaW5nIHNvIHJlcXVpcmVkIGFkZGluZyBhIHBvcnRfbmFtZSgpIGFjY2Vzc29yIGFu ZAorICAgICAgICB1bnRhbmdsaW5nIHRoZSBtZXNzIHRoYXQgaXMgb3VyIHBvcnRfbmFtZSBhcmd1 bWVudCAicGFyc2luZyIuCisKKyAgICAgICAgKE91ciBjdXJyZW50IHN5c3RlbSBvZiBzb21ldGlt ZXMgcGFzc2luZyAiY2hyb21pdW0tbWFjIiBhbmQKKyAgICAgICAgc29tZXRpbWVzICJjaHJvbWl1 bS1tYWMtbGVvcGFyZCIgb3Igd29yc2UgImNocm9taXVtLWdwdS1tYWMtbGVvcGFyZCIKKyAgICAg ICAgYXMgdGhlIHBvcnRfbmFtZSBhcmd1bWVudCBhbmQgZXhwZWN0aW5nIFdlYktpdFBvcnQoKSB0 byBkbyB0aGUgcmlnaHQKKyAgICAgICAgdGhpbmcgaXMgYWJzdXJkLikKKworICAgICAgICBJIGFk ZGVkIGEgbmV3IF9wYXJzZV9wb3J0X25hbWUgbWV0aG9kIHRvIGhhbmRsZSB0aGUgdmFyaW91cwor ICAgICAgICBwb3NzaWJsZSBwb3J0X25hbWUgdmFsdWVzLiAgTm93IHRoYXQgd2UgaGF2ZSBhIHNo YXJlZCBtZXRob2QKKyAgICAgICAgd2UgY291bGQgcHJvYmFibHkganVzdCBjYWxsIF9wYXJzZV9w b3J0X25hbWUoKSBmcm9tIHRoZQorICAgICAgICBXZWJLaXRQb3J0IGNvbnN0cnVjdG9yIGFuZCBn ZXQgcmlkIG9mIG1hbnkgb2YgdGhlIHN1YmNsYXNzIGNvbnN0cnVjdG9ycy4KKworICAgICAgICBJ biBvcmRlciB0byB0ZXN0IG15IG5ldyBfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocyBtZXRob2Qs IEkKKyAgICAgICAgZml4ZWQgYW5vdGhlciBGSVhNRSBieSBtYWtpbmcgaXQgcmV0dXJuIHJlbGF0 aXZlIHBhdGhzLiAgSG93ZXZlcgorICAgICAgICBpbiBkb2luZyBzbyBJIGZvdW5kIHRoYXQgdGhl IFRlc3RXZWJLaXRQb3J0IHdlIHdlcmUgdXNpbmcgaW4KKyAgICAgICAgd2Via2l0X3VuaXR0ZXN0 LnB5IHdhcyBhY2Nlc3NpbmcgdGhlIHJlYWwgZmlsZXN5c3RlbSB0aHJvdWdoIHRoZSB1c2UKKyAg ICAgICAgb2YgdGhlIF9fZmlsZV9fIHZhcmlhYmxlLgorCisgICAgICAgIFNvIHRvIGZpeCB0aGF0 LCBJIGFkZGVkIGEgcGF0aF9mb3JfbW9kdWxlIGFic3RyYWN0aW9uIG9udG8gZmlsZXN5c3RlbS5w eS4KKworICAgICAgICBJIG9mIGNvdXJzZSByZW1vdmVkIHNvbWUgcmVkdW5kYW50IGRvY3N0cmlu Z3MgYW5kIG1vdmVkIGFic29sdXRlCisgICAgICAgIG1vZHVsZSBuYW1lcyB0byBfX2ZpbGVfXyBh bG9uZyB0aGUgd2F5LgorCisgICAgICAgIFdoaWxlIGZpeGluZyBteSBza2lwcGVkLWxpc3QgZmFs bGJhY2sgSSBhbHNvIGZvdW5kIHdlIHN0aWxsIGhhZCAoYnJva2VuKQorICAgICAgICB0aWdlciBz dXBwb3J0LCBzbyBJIHJlbW92ZWQgaXQgKGFsb25nIHdpdGggYWxsIG90aGVyIG1lbnRpb25zIG9m IHRpZ2VyIGluIHRoZSBzb3VyY2UgYmFzZSkuCisKKyAgICAgICAgSSBhbHNvIGZpeGVkIHRoZSB0 ZXN0X2V4cGVjdGF0aW9uc19wYXRoIGNvZGUgaW4gV2ViS2l0UG9ydCB0byB1c2UgcG9ydF9uYW1l KCkuCisgICAgICAgIEl0IHdhcyB1c2luZyBuYW1lKCkgd2hpY2ggd291bGQgcmV0dXJuIFBPUlQt VkVSU0lPTiBzbyBNYWNQb3J0IHdhcyBvdmVycmlkaW5nCisgICAgICAgIGl0IHRvIHVzZSBqdXN0 IFBPUlQuICBBZnRlciBmaXhpbmcgdGVzdF9leHBlY3RhdGlvbnNfcGF0aCB0byB1c2UgcG9ydF9u YW1lKCkKKyAgICAgICAgKGFuZCBtYWtpbmcgaXQgYXdhcmUgb2Ygd2Via2l0MikgSSB3YXMgYWJs ZSB0byByZW1vdmUgdGhlIE1hY1BvcnQgaW1wbGVtZW50YXRpb24uCisKKyAgICAgICAgRmluYWxs eSBJIGZpeGVkIGFsbCBtaXNzcGVsbGluZ3Mgb2YgdGhyZWFkIGFzICJ0aGVhZCIgaW4gdGhlIGNv ZGViYXNlCisgICAgICAgICh3aGljaCB3YXMgbWVudGlvbmVkIGluIHRoZSByZXZpZXcgb2YgbXkg cHJldmlvdXMgcGF0Y2gpLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hl Y2tvdXQvc2NtL2dpdC5weTogInRoZWFkIiAtPiAidGhyZWFkIgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvY29tbW9uL3N5c3RlbS9maWxlc3lzdGVtLnB5OgorICAgICAgICAgLSBUaGlzIGNh biBiZSB1c2VkIHRvIHdyYXAgYWxsIGNhbGxzIHRvIF9fZmlsZV9fIHRvIG1ha2UgdGhlbSB1bml0 LXRlc3QgZnJpZW5kbHkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVt L2ZpbGVzeXN0ZW1fbW9jay5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Jhc2UucHk6CisgICAgICAgICAtIEFkZCBwb3J0X25hbWUoKSB0byBhY2Nlc3Mg Im1hYyIsIHNpbmNlIG5hbWUoKSByZXR1cm5zICJtYWMtbGVvcGFyZCIgZXRjLgorICAgICAgICAg LSBEb2N1bWVudCB0aGF0IHJlYWxfbmFtZSgpIHNlZW1zIHRvIGhhdmUgbm8gcHVycG9zZS4KKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2J1aWxkZXJzLnB5Ogor ICAgICAgICAgLSBSZW1vdmUgdGlnZXIgc3VwcG9ydCwgd2Via2l0IG5vIGxvbmdlciBzdXBwb3J0 cyB0aWdlci4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2No cm9taXVtX2xpbnV4LnB5OgorICAgICAgICAgLSBBZGQgX3BhcnNlX3BvcnRfbmFtZSgpLCBldmVu dHVhbGx5IHdlIG1pZ2h0IGNhbGwgdGhpcyBmcm9tIFdlYktpdFBvcnQgZGlyZWN0bHkuCisgICAg ICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHk6 CisgICAgICAgICAtIEFkZCBfcGFyc2VfcG9ydF9uYW1lLgorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fd2luLnB5OgorICAgICAgICAgLSBBZGQg X3BhcnNlX3BvcnRfbmFtZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L2NvbmZpZy5weToKKyAgICAgICAgIC0gVXNlIHRoZSBuZXcgcGF0aF90b19tb2R1bGUg YWJzdHJhY3Rpb24gaW5zdGVhZCBvZiBfX2ZpbGVfXyB0byBtYWtlIGl0CisgICAgICAgICAgIGVh c2llciB0byB1bml0dGVzdCBjb25maWcucHkgY29kZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L21hYy5weToKKyAgICAgICAgIC0gTW92ZSBTa2lwcGVkLWZpbGUg ZmluZGluZyBjb2RlIGRvd24gdG8gV2ViS2l0UG9ydAorICAgICAgICAgLSBSZW1vdmUgdGlnZXIg c3VwcG9ydC4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21h Y191bml0dGVzdC5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L3F0LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2Via2l0LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2Via2l0X3VuaXR0ZXN0LnB5OgorICAgICAgICAgLSBUZXN0V2ViS2l0UG9ydCBpcyBtdWNoIGVh c2llciB0byB3cml0ZSBub3cgdGhhdCBjb25maWcucHkgbmV2ZXIgYmxlZWRzCisgICAgICAgICAg IGFic29sdXRlIHBhdGhzLgorICAgICAgICAgLSBQYXNzIE1vY2tVc2VyIGFuZCBNb2NrRmlsZVN5 c3RlbSBieSBkZWZhdWx0IHRvIHByZXZlbnQgVGVzdFdlYktpdFBvcnQgZnJvbSBsZWFraW5nIHN5 c3RlbSBkYXRhIHRvIHVuaXR0ZXN0IHJlc3VsdHMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weTogInRoZWFkIiAtPiAidGhyZWFkIgor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5OiBU aWdlciBpcyBkZWFkLgorCiAyMDExLTA2LTI3ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jaGVja291dC9zY20vZ2l0LnB5IGIvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weQppbmRleCA1MzdlYzY2ZDhi NmI1YTZhMGQwODU5NTljNThmZTlkMThhZGIyMGI4Li5mZDliMTJlZmUyYTlhNTJlMWViMTEzMTI3 MjJiZDRhYmQzYzA5NmFkIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9jaGVja291dC9zY20vZ2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9u L2NoZWNrb3V0L3NjbS9naXQucHkKQEAgLTgzLDggKzgzLDggQEAgY2xhc3MgR2l0KFNDTSwgU1ZO UmVwb3NpdG9yeSk6CiAgICAgICAgIGlmIHNlbGYuX2V4ZWN1dGFibGVfaXNfNjRiaXQoZ2l0X3Bh dGgpOgogICAgICAgICAgICAgcmV0dXJuCiAKLSAgICAgICAgd2Via2l0X2Rldl90aGVhZF91cmwg PSAiaHR0cHM6Ly9saXN0cy53ZWJraXQub3JnL3BpcGVybWFpbC93ZWJraXQtZGV2LzIwMTAtRGVj ZW1iZXIvMDE1Mjg3Lmh0bWwiCi0gICAgICAgIGxvZygiV2FybmluZzogVGhpcyBtYWNoaW5lIGlz IDY0LWJpdCwgYnV0IHRoZSBnaXQgYmluYXJ5ICglcykgZG9lcyBub3Qgc3VwcG9ydCA2NC1iaXQu XG5JbnN0YWxsIGEgNjQtYml0IGdpdCBmb3IgYmV0dGVyIHBlcmZvcm1hbmNlLCBzZWU6XG4lc1xu IiAlIChnaXRfcGF0aCwgd2Via2l0X2Rldl90aGVhZF91cmwpKQorICAgICAgICB3ZWJraXRfZGV2 X3RocmVhZF91cmwgPSAiaHR0cHM6Ly9saXN0cy53ZWJraXQub3JnL3BpcGVybWFpbC93ZWJraXQt ZGV2LzIwMTAtRGVjZW1iZXIvMDE1Mjg3Lmh0bWwiCisgICAgICAgIGxvZygiV2FybmluZzogVGhp cyBtYWNoaW5lIGlzIDY0LWJpdCwgYnV0IHRoZSBnaXQgYmluYXJ5ICglcykgZG9lcyBub3Qgc3Vw cG9ydCA2NC1iaXQuXG5JbnN0YWxsIGEgNjQtYml0IGdpdCBmb3IgYmV0dGVyIHBlcmZvcm1hbmNl LCBzZWU6XG4lc1xuIiAlIChnaXRfcGF0aCwgd2Via2l0X2Rldl90aHJlYWRfdXJsKSkKIAogICAg IEBjbGFzc21ldGhvZAogICAgIGRlZiBpbl93b3JraW5nX2RpcmVjdG9yeShjbHMsIHBhdGgpOgpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0 ZW0ucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5w eQppbmRleCBlN2MwNjhhOWFkODQ2YjQ2YmNlNzU5NDg5OGJjZTdkOWQ5MjM5NGExLi4zNjUxMjYw NjMyODg1YmUxZjliZTIyOGE0NDIxZTE5NTFkMzM0N2NlIDEwMDY0NAotLS0gYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5weQorKysgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5weQpAQCAtNTcsNiArNTcsMTEg QEAgY2xhc3MgRmlsZVN5c3RlbShvYmplY3QpOgogICAgIGRlZiBhYnNwYXRoKHNlbGYsIHBhdGgp OgogICAgICAgICByZXR1cm4gb3MucGF0aC5hYnNwYXRoKHBhdGgpCiAKKyAgICBkZWYgcGF0aF90 b19tb2R1bGUoc2VsZiwgbW9kdWxlX25hbWUpOgorICAgICAgICAiIiJBIHdyYXBwZXIgZm9yIGFs bCBjYWxscyB0byBfX2ZpbGVfXyB0byBhbGxvdyBlYXN5IHVuaXQgdGVzdGluZy4iIiIKKyAgICAg ICAgaW1wb3J0IHN5cworICAgICAgICByZXR1cm4gc3lzLm1vZHVsZXNbbW9kdWxlX25hbWVdLl9f ZmlsZV9fCisKICAgICBkZWYgZXhwYW5kdXNlcihzZWxmLCBwYXRoKToKICAgICAgICAgcmV0dXJu IG9zLnBhdGguZXhwYW5kdXNlcihwYXRoKQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbV9tb2NrLnB5IGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW1fbW9jay5weQppbmRleCAyMDQ0NjhmNWQ3 NWJmYTA3ZjI0NGE1MzJiNjJiZmRhNGExNGY5ODJlLi42ZWI5NThhMTVmNzhmMTQ3NjFkZGU4Y2Ix Y2VkZWRhZDFiNzg2MjQ3IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1v bi9zeXN0ZW0vZmlsZXN5c3RlbV9tb2NrLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv Y29tbW9uL3N5c3RlbS9maWxlc3lzdGVtX21vY2sucHkKQEAgLTc5LDYgKzc5LDkgQEAgY2xhc3Mg TW9ja0ZpbGVTeXN0ZW0ob2JqZWN0KToKICAgICAgICAgICAgIHJldHVybiBob21lX2RpcmVjdG9y eQogICAgICAgICByZXR1cm4gaG9tZV9kaXJlY3RvcnkgKyBzZWxmLnNlcCArIHBhcnRzWzFdCiAK KyAgICBkZWYgcGF0aF90b19tb2R1bGUoc2VsZiwgbW9kdWxlX25hbWUpOgorICAgICAgICByZXR1 cm4gIi9tb2NrL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvJXMiICUgbW9kdWxlX25hbWUKKwogICAg IGRlZiBjaGRpcihzZWxmLCBwYXRoKToKICAgICAgICAgcGF0aCA9IHNlbGYubm9ybXBhdGgocGF0 aCkKICAgICAgICAgaWYgbm90IHNlbGYuaXNkaXIocGF0aCk6CmRpZmYgLS1naXQgYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggZDJmMDlmMTM1N2IxNjIy NDNlZDJjOTVkZTU4MDAyYTQ5OGRjMmU4ZC4uZjFjODUxOGY4MmY1M2I2NWU3NDdjNGVhMzczNTMz ZjhkNTFhNzljNyAxMDA3NTUKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9iYXNlLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvYmFzZS5weQpAQCAtOTEsMTAgKzkxLDExIEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAg ICAgICAgICAgICAgICAgZmlsZXN5c3RlbT1Ob25lLAogICAgICAgICAgICAgICAgICBjb25maWc9 Tm9uZSwKICAgICAgICAgICAgICAgICAgKiprd2FyZ3MpOgotICAgICAgICBzZWxmLl9uYW1lID0g cG9ydF9uYW1lCisgICAgICAgIHNlbGYuX3BvcnRfbmFtZSA9IHBvcnRfbmFtZQogCiAgICAgICAg ICMgVGhlc2UgYXJlIGRlZmF1bHQgdmFsdWVzIHRoYXQgc2hvdWxkIGJlIG92ZXJyaWRkZW4gaW4g YSBzdWJjbGFzc2VzLgogICAgICAgICAjIEZJWE1FOiBUaGVzZSBzaG91bGQgcmVhbGx5IGJlIHBh c3NlZCBpbi4KKyAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSAgIyBTdWJjbGFzc2VzIG1h eSBhcHBlbmQgYSAtVkVSU0lPTiAobGlrZSBtYWMtbGVvcGFyZCkuCiAgICAgICAgIHNlbGYuX29w ZXJhdGluZ19zeXN0ZW0gPSAnbWFjJwogICAgICAgICBzZWxmLl92ZXJzaW9uID0gJycKICAgICAg ICAgc2VsZi5fYXJjaGl0ZWN0dXJlID0gJ3g4NicKQEAgLTE2MywxMCArMTY0LDggQEAgY2xhc3Mg UG9ydChvYmplY3QpOgogICAgICAgICByZXR1cm4gJ3RocmVhZHMnCiAKICAgICBkZWYgYmFzZWxp bmVfcGF0aChzZWxmKToKLSAgICAgICAgIiIiUmV0dXJuIHRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRo ZSBkaXJlY3RvcnkgdG8gc3RvcmUgbmV3IGJhc2VsaW5lcwotICAgICAgICBpbiBmb3IgdGhpcyBw b3J0LiIiIgotICAgICAgICBiYXNlbGluZV9zZWFyY2hfcGF0aHMgPSBcCi0gICAgICAgICAgICBz ZWxmLmdldF9vcHRpb24oJ2FkZGl0aW9uYWxfcGxhdGZvcm1fZGlyZWN0b3J5JywgW10pICsgc2Vs Zi5iYXNlbGluZV9zZWFyY2hfcGF0aCgpCisgICAgICAgICIiIlJldHVybiB0aGUgYWJzb2x1dGUg cGF0aCB0byB0aGUgZGlyZWN0b3J5IHRvIHN0b3JlIG5ldyBiYXNlbGluZXMgaW4gZm9yIHRoaXMg cG9ydC4iIiIKKyAgICAgICAgYmFzZWxpbmVfc2VhcmNoX3BhdGhzID0gc2VsZi5nZXRfb3B0aW9u KCdhZGRpdGlvbmFsX3BsYXRmb3JtX2RpcmVjdG9yeScsIFtdKSArIHNlbGYuYmFzZWxpbmVfc2Vh cmNoX3BhdGgoKQogICAgICAgICByZXR1cm4gYmFzZWxpbmVfc2VhcmNoX3BhdGhzWzBdCiAKICAg ICBkZWYgYmFzZWxpbmVfc2VhcmNoX3BhdGgoc2VsZik6CkBAIC01MzgsMTAgKzUzNywyMCBAQCBj bGFzcyBQb3J0KG9iamVjdCk6CiAgICAgICAgICIiIkNyZWF0ZXMgdGhlIHNwZWNpZmllZCBkaXJl Y3RvcnkgaWYgaXQgZG9lc24ndCBhbHJlYWR5IGV4aXN0LiIiIgogICAgICAgICBzZWxmLl9maWxl c3lzdGVtLm1heWJlX21ha2VfZGlyZWN0b3J5KCpwYXRoKQogCisgICAgZGVmIHBvcnRfbmFtZShz ZWxmKToKKyAgICAgICAgIiIiVGhlIGJhc2UgbmFtZSBvZiB0aGUgcG9ydCwgbm90IGluY2x1ZGlu ZyB2ZXJzaW9uIGluZm9ybWF0aW9uLiIiIgorICAgICAgICByZXR1cm4gc2VsZi5fcG9ydF9uYW1l CisKICAgICBkZWYgbmFtZShzZWxmKToKLSAgICAgICAgIiIiUmV0dXJuIHRoZSBuYW1lIG9mIHRo ZSBwb3J0IChlLmcuLCAnbWFjJywgJ2Nocm9taXVtLXdpbi14cCcpLiIiIgorICAgICAgICAiIiJS ZXR1cm4gdGhlIGZ1bGwgbmFtZSBvZiB0aGUgcG9ydCAoZS5nLiwgJ21hYycsICdjaHJvbWl1bS13 aW4teHAnKSwgaW5jbHVkaW5nIHZlcnNpb24uIiIiCisgICAgICAgICMgRklYTUU6IFRoaXMgc2hv dWxkIGJlIHJlcGxhY2VkIGJ5ICJyZXR1cm4gIiVzLSVzIiAoc2VsZi5wb3J0X25hbWUoKSwgc2Vs Zi52ZXJzaW9uKCkpIgogICAgICAgICByZXR1cm4gc2VsZi5fbmFtZQogCisgICAgZGVmIHJlYWxf bmFtZShzZWxmKToKKyAgICAgICAgIyBGSVhNRTogU2VlbXMgdGhpcyBpcyBvbmx5IHVzZWQgZm9y IE1vY2tEUlQgYW5kIHNob3VsZCBiZSByZW1vdmVkLgorICAgICAgICAiIiJSZXR1cm5zIHRoZSBh Y3R1YWwgbmFtZSBvZiB0aGUgcG9ydCwgbm90IHRoZSBkZWxlZ2F0ZSdzLiIiIgorICAgICAgICBy ZXR1cm4gc2VsZi5uYW1lKCkKKwogICAgIGRlZiBvcGVyYXRpbmdfc3lzdGVtKHNlbGYpOgogICAg ICAgICByZXR1cm4gc2VsZi5fb3BlcmF0aW5nX3N5c3RlbQogCkBAIC01NjIsMTcgKzU3MSwxMiBA QCBjbGFzcyBQb3J0KG9iamVjdCk6CiAgICAgICAgIHJldHVybiBBZ2dyZWdhdGVUZXN0T3V0cHV0 U2V0KFtzZWxmLl9yZXN1bHRzX2Zvcl9wbGF0Zm9ybShwbGF0Zm9ybSkgZm9yIHBsYXRmb3JtIGlu IHBsYXRmb3Jtc10pCiAKICAgICBkZWYgZ3JhcGhpY3NfdHlwZShzZWxmKToKLSAgICAgICAgIiIi UmV0dXJucyB3aGV0aGVyIHRoZSBwb3J0IHVzZXMgYWNjZWxlcmF0ZWQgZ3JhcGhpY3MgKCdncHUn KSBvciBub3QKLSAgICAgICAgKCdjcHUnKS4iIiIKKyAgICAgICAgIiIiUmV0dXJucyB3aGV0aGVy IHRoZSBwb3J0IHVzZXMgYWNjZWxlcmF0ZWQgZ3JhcGhpY3MgKCdncHUnKSBvciBub3QgKCdjcHUn KS4iIiIKICAgICAgICAgcmV0dXJuIHNlbGYuX2dyYXBoaWNzX3R5cGUKIAogICAgIGRlZiBhcmNo aXRlY3R1cmUoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9hcmNoaXRlY3R1cmUKIAotICAg IGRlZiByZWFsX25hbWUoc2VsZik6Ci0gICAgICAgICIiIlJldHVybnMgdGhlIGFjdHVhbCBuYW1l IG9mIHRoZSBwb3J0LCBub3QgdGhlIGRlbGVnYXRlJ3MuIiIiCi0gICAgICAgIHJldHVybiBzZWxm Lm5hbWUoKQotCiAgICAgZGVmIGdldF9vcHRpb24oc2VsZiwgbmFtZSwgZGVmYXVsdF92YWx1ZT1O b25lKToKICAgICAgICAgIyBGSVhNRTogRXZlbnR1YWxseSB3ZSBzaG91bGQgbm90IGhhdmUgdG8g ZG8gYSB0ZXN0IGZvcgogICAgICAgICAjIGhhc2F0dHIoKSwgYW5kIHdlIHNob3VsZCBiZSBhYmxl IHRvIGp1c3QgZG8KQEAgLTY0Miw4ICs2NDYsNyBAQCBjbGFzcyBQb3J0KG9iamVjdCk6CiAgICAg ICAgIHJldHVybiBzZWxmLl91c2VyLm9wZW5fdXJsKHJlc3VsdHNfZmlsZW5hbWUpCiAKICAgICBk ZWYgY3JlYXRlX2RyaXZlcihzZWxmLCB3b3JrZXJfbnVtYmVyKToKLSAgICAgICAgIiIiUmV0dXJu IGEgbmV3bHkgY3JlYXRlZCBiYXNlLkRyaXZlciBzdWJjbGFzcyBmb3Igc3RhcnRpbmcvc3RvcHBp bmcKLSAgICAgICAgdGhlIHRlc3QgZHJpdmVyLiIiIgorICAgICAgICAiIiJSZXR1cm4gYSBuZXds eSBjcmVhdGVkIGJhc2UuRHJpdmVyIHN1YmNsYXNzIGZvciBzdGFydGluZy9zdG9wcGluZyB0aGUg dGVzdCBkcml2ZXIuIiIiCiAgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IoJ1BvcnQu Y3JlYXRlX2RyaXZlcicpCiAKICAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYpOgpAQCAtODc3LDgg Kzg4MCw3IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50 ZWRFcnJvcignUG9ydC5fcGF0aF90b19oZWxwZXInKQogCiAgICAgZGVmIF9wYXRoX3RvX2ltYWdl X2RpZmYoc2VsZik6Ci0gICAgICAgICIiIlJldHVybnMgdGhlIGZ1bGwgcGF0aCB0byB0aGUgaW1h Z2VfZGlmZiBiaW5hcnksIG9yIE5vbmUgaWYgaXQKLSAgICAgICAgaXMgbm90IGF2YWlsYWJsZS4K KyAgICAgICAgIiIiUmV0dXJucyB0aGUgZnVsbCBwYXRoIHRvIHRoZSBpbWFnZV9kaWZmIGJpbmFy eSwgb3IgTm9uZSBpZiBpdCBpcyBub3QgYXZhaWxhYmxlLgogCiAgICAgICAgIFRoaXMgaXMgbGlr ZWx5IHVzZWQgb25seSBieSBkaWZmX2ltYWdlKCkiIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVt ZW50ZWRFcnJvcignUG9ydC5wYXRoX3RvX2ltYWdlX2RpZmYnKQpAQCAtOTAyLDggKzkwNCw3IEBA IGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcign UG9ydC5fcGF0aF90b19saWdodHRwZF9waHAnKQogCiAgICAgZGVmIF9wYXRoX3RvX3dkaWZmKHNl bGYpOgotICAgICAgICAiIiJSZXR1cm5zIHRoZSBmdWxsIHBhdGggdG8gdGhlIHdkaWZmIGJpbmFy eSwgb3IgTm9uZSBpZiBpdCBpcwotICAgICAgICBub3QgYXZhaWxhYmxlLgorICAgICAgICAiIiJS ZXR1cm5zIHRoZSBmdWxsIHBhdGggdG8gdGhlIHdkaWZmIGJpbmFyeSwgb3IgTm9uZSBpZiBpdCBp cyBub3QgYXZhaWxhYmxlLgogCiAgICAgICAgIFRoaXMgaXMgbGlrZWx5IHVzZWQgb25seSBieSB3 ZGlmZl90ZXh0KCkiIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcignUG9ydC5f cGF0aF90b193ZGlmZicpCkBAIC05MTEsOCArOTEyLDcgQEAgY2xhc3MgUG9ydChvYmplY3QpOgog ICAgIGRlZiBfd2Via2l0X2Jhc2VsaW5lX3BhdGgoc2VsZiwgcGxhdGZvcm0pOgogICAgICAgICAi IiJSZXR1cm4gdGhlICBmdWxsIHBhdGggdG8gdGhlIHRvcCBvZiB0aGUgYmFzZWxpbmUgdHJlZSBm b3IgYQogICAgICAgICBnaXZlbiBwbGF0Zm9ybS4iIiIKLSAgICAgICAgcmV0dXJuIHNlbGYuX2Zp bGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ3BsYXRmb3JtJywKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwbGF0Zm9ybSkKKyAgICAgICAgcmV0dXJu IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ3BsYXRmb3Jt JywgcGxhdGZvcm0pCiAKIAogY2xhc3MgRHJpdmVySW5wdXQob2JqZWN0KToKZGlmZiAtLWdpdCBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYnVpbGRlcnMucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2J1aWxkZXJzLnB5CmluZGV4 IGM4ZWE4MWYwOTgzYjI3YmQ0ZDBhYjM5MWQyNDkxNzcyNTE1OTA0M2QuLmRkNWU0Njg5ZjdjNzcy ODFjYzRhYzgyN2YwMTM5YjRiMTg0N2M4ZTMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYnVpbGRlcnMucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9idWlsZGVycy5weQpAQCAtNjUsNyArNjUsNiBAQCBD SFJPTUlVTV9QT1JUX1RPX0JVSUxERVJfTkFNRSA9IHsKIFdFQktJVF9QT1JUX1RPX0JVSUxERVJf TkFNRSA9IHsKICAgICAnZ3RrJzogJ0dUSyBMaW51eCAzMi1iaXQgRGVidWcnLAogCi0gICAgJ21h Yy10aWdlcic6IE5vbmUsCiAgICAgJ21hYy1sZW9wYXJkJzogJ0xlb3BhcmQgSW50ZWwgRGVidWcg KFRlc3RzKScsCiAgICAgJ21hYy1zbm93bGVvcGFyZCc6ICdTbm93TGVvcGFyZCBJbnRlbCBSZWxl YXNlIChUZXN0cyknLAogICAgICdtYWMtd2syJzogJ1Nub3dMZW9wYXJkIEludGVsIFJlbGVhc2Ug KFdlYktpdDIgVGVzdHMpJywKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbGludXgucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5CmluZGV4IGQ5OWMwNWEzYTIwYWQ5 ODE0ODU0NzVhMWU0NzcwNmQ5NWZmYjNhNzEuLmVmOTg4NzhiZGJkMmUyNDFmYjI5Zjk1ZGZjMjgz NzQ0MmI5ODBhMzEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvY2hyb21pdW1fbGludXgucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9saW51eC5weQpAQCAtNDUsMTIgKzQ1LDcgQEAgY2xh c3MgQ2hyb21pdW1MaW51eFBvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0KToKICAgICAgICAgJ3g4 Nic6IFsnY2hyb21pdW0tbGludXgteDg2JywgJ2Nocm9taXVtLWxpbnV4JywgJ2Nocm9taXVtLXdp bicsICdjaHJvbWl1bScsICd3aW4nLCAnbWFjJ10sCiAgICAgfQogCi0gICAgZGVmIF9faW5pdF9f KHNlbGYsIHBvcnRfbmFtZT1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgIHBvcnRfbmFtZSA9IHBv cnRfbmFtZSBvciAnY2hyb21pdW0tbGludXgnCi0gICAgICAgIGNocm9taXVtLkNocm9taXVtUG9y dC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKLQotICAgICAg ICAjIFdlIHJlLXNldCB0aGUgcG9ydCBuYW1lIG9uY2UgdGhlIGJhc2Ugb2JqZWN0IGlzIGZ1bGx5 IGluaXRpYWxpemVkCi0gICAgICAgICMgaW4gb3JkZXIgdG8gYmUgYWJsZSB0byBmaW5kIHRoZSBE UlQgYmluYXJ5IHByb3Blcmx5LgorICAgIGRlZiBfcGFyc2VfcG9ydF9uYW1lKHNlbGYsIHBvcnRf bmFtZSk6CiAgICAgICAgIGlmIHBvcnRfbmFtZS5lbmRzd2l0aCgnLWxpbnV4Jyk6CiAgICAgICAg ICAgICBzZWxmLl9hcmNoaXRlY3R1cmUgPSBzZWxmLl9kZXRlcm1pbmVfYXJjaGl0ZWN0dXJlKCkK ICAgICAgICAgICAgICMgRklYTUU6IHRoaXMgaXMgYW4gdWdseSBoYWNrIHRvIGF2b2lkIHJlbmFt aW5nIHRoZSBHUFUgcG9ydC4KQEAgLTY0LDEwICs1OSwxOCBAQCBjbGFzcyBDaHJvbWl1bUxpbnV4 UG9ydChjaHJvbWl1bS5DaHJvbWl1bVBvcnQpOgogICAgICAgICBhc3NlcnQgcG9ydF9uYW1lIGlu ICgnY2hyb21pdW0tbGludXgnLCAnY2hyb21pdW0tZ3B1LWxpbnV4JywKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgJ2Nocm9taXVtLWxpbnV4LXg4NicsICdjaHJvbWl1bS1saW51eC14ODZf NjQnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnY2hyb21pdW0tZ3B1LWxpbnV4LXg4 Nl82NCcpCisgICAgICAgIHNlbGYuX3BvcnRfbmFtZSA9ICdjaHJvbWl1bS1saW51eCcgICMgVGhp cyBtYXkgYmUgd3JvbmcsIGJ1dCBzZWVtcyB0byBtYXRjaCB0aGUgInVnbHkgaGFjayB0byBhdm9p ZCByZW5hbWluZyB0aGUgR1BVIHBvcnQiIGFib3ZlLgogICAgICAgICBzZWxmLl9uYW1lID0gcG9y dF9uYW1lCi0gICAgICAgIHNlbGYuX29wZXJhdGluZ19zeXN0ZW0gPSAnbGludXgnCiAgICAgICAg IHNlbGYuX3ZlcnNpb24gPSAnbHVjaWQnICAjIFdlIG9ubHkgc3VwcG9ydCBsdWNpZCByaWdodCBu b3cuCiAKKyAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsICoqa3dhcmdzKToK KyAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdjaHJvbWl1bS1saW51eCcKKyAgICAg ICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1wb3J0X25h bWUsICoqa3dhcmdzKQorICAgICAgICAjIFdlIHJlLXNldCB0aGUgcG9ydCBuYW1lIG9uY2UgdGhl IGJhc2Ugb2JqZWN0IGlzIGZ1bGx5IGluaXRpYWxpemVkCisgICAgICAgICMgaW4gb3JkZXIgdG8g YmUgYWJsZSB0byBmaW5kIHRoZSBEUlQgYmluYXJ5IHByb3Blcmx5LgorICAgICAgICBzZWxmLl9w YXJzZV9wb3J0X25hbWUocG9ydF9uYW1lKQorICAgICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVt ID0gJ2xpbnV4JworCiAgICAgZGVmIF9kZXRlcm1pbmVfYXJjaGl0ZWN0dXJlKHNlbGYpOgogICAg ICAgICBkcml2ZXJfcGF0aCA9IHNlbGYuX3BhdGhfdG9fZHJpdmVyKCkKICAgICAgICAgZmlsZV9v dXRwdXQgPSAnJwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9jaHJvbWl1bV9tYWMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weQppbmRleCAyNmU0MGU1NjQ2NTYzYzYyYzRhYjkxODRl NWM0ZWU4NGIwMTAyODAyLi5iN2E2OGUwNDM0YTdhMjE2ZmNlNzU3YjNhYzA4YThmZmM1NGE5ZDA3 IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2No cm9taXVtX21hYy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Nocm9taXVtX21hYy5weQpAQCAtNjcsMTcgKzY3LDIyIEBAIGNsYXNzIENocm9taXVtTWFj UG9ydChjaHJvbWl1bS5DaHJvbWl1bVBvcnQpOgogICAgICAgICBdLAogICAgIH0KIAotICAgIGRl ZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgb3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwg Kiprd2FyZ3MpOgotICAgICAgICAjIFdlJ3JlIGEgbGl0dGxlIGdlbmVyaWMgaGVyZSBiZWNhdXNl IHRoaXMgY29kZSBpcyByZXVzZWQgYnkgdGhlCi0gICAgICAgICMgJ2dvb2dsZS1jaHJvbWUnIHBv cnQgYXMgd2VsbCBhcyB0aGUgJ21vY2stJyBhbmQgJ2RyeXJ1bi0nIHBvcnRzLgotICAgICAgICBw b3J0X25hbWUgPSBwb3J0X25hbWUgb3IgJ2Nocm9taXVtLW1hYycKLSAgICAgICAgY2hyb21pdW0u Q2hyb21pdW1Qb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1wb3J0X25hbWUsICoqa3dhcmdz KQorICAgICMgRklYTUU6IHZlcnNpb24sIG5hbWUsIGV0Yy4gc2hvdWxkIGJlIHBhc3NlZCBzZXBh cmF0ZWx5IGFuZCB3ZSBzaG91bGQgbm90IGhhdmUgdG8gcGFyc2UgcG9ydF9uYW1lLgorICAgIGRl ZiBfcGFyc2VfcG9ydF9uYW1lKHNlbGYsIHBvcnRfbmFtZSwgb3NfdmVyc2lvbl9zdHJpbmcpOgog ICAgICAgICBpZiBwb3J0X25hbWUuZW5kc3dpdGgoJy1tYWMnKToKICAgICAgICAgICAgIHNlbGYu X3ZlcnNpb24gPSBtYWMub3NfdmVyc2lvbihvc192ZXJzaW9uX3N0cmluZywgc2VsZi5TVVBQT1JU RURfT1NfVkVSU0lPTlMpCiAgICAgICAgICAgICBzZWxmLl9uYW1lID0gcG9ydF9uYW1lICsgJy0n ICsgc2VsZi5fdmVyc2lvbgogICAgICAgICBlbHNlOgotICAgICAgICAgICAgc2VsZi5fdmVyc2lv biA9IHBvcnRfbmFtZVtwb3J0X25hbWUuaW5kZXgoJy1tYWMtJykgKyA1Ol0KKyAgICAgICAgICAg IHNlbGYuX3BvcnRfbmFtZSA9IHBvcnRfbmFtZVs6cG9ydF9uYW1lLmluZGV4KCctbWFjLScpICsg bGVuKCctbWFjJyldCisgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lW3BvcnRf bmFtZS5pbmRleCgnLW1hYy0nKSArIGxlbignLW1hYy0nKTpdCiAgICAgICAgICAgICBhc3NlcnQg c2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9PU19WRVJTSU9OUworCisgICAgZGVmIF9f aW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBvc192ZXJzaW9uX3N0cmluZz1Ob25lLCAqKmt3 YXJncyk6CisgICAgICAgICMgV2UncmUgYSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhp cyBjb2RlIGlzIHJldXNlZCBieSB0aGUKKyAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBh cyB3ZWxsIGFzIHRoZSAnbW9jay0nIGFuZCAnZHJ5cnVuLScgcG9ydHMuCisgICAgICAgIHBvcnRf bmFtZSA9IHBvcnRfbmFtZSBvciAnY2hyb21pdW0tbWFjJworICAgICAgICBjaHJvbWl1bS5DaHJv bWl1bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisg ICAgICAgIHNlbGYuX3BhcnNlX3BvcnRfbmFtZShwb3J0X25hbWUsIG9zX3ZlcnNpb25fc3RyaW5n KQogICAgICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0gJ21hYycKIAogICAgIGRlZiBiYXNl bGluZV9zZWFyY2hfcGF0aChzZWxmKToKQEAgLTg5LDggKzk0LDcgQEAgY2xhc3MgQ2hyb21pdW1N YWNQb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6CiAgICAgICAgIGlmIG5vdCByZXN1bHQ6CiAg ICAgICAgICAgICBfbG9nLmVycm9yKCdGb3IgY29tcGxldGUgTWFjIGJ1aWxkIHJlcXVpcmVtZW50 cywgcGxlYXNlIHNlZTonKQogICAgICAgICAgICAgX2xvZy5lcnJvcignJykKLSAgICAgICAgICAg IF9sb2cuZXJyb3IoJyAgICBodHRwOi8vY29kZS5nb29nbGUuY29tL3AvY2hyb21pdW0vd2lraS8n Ci0gICAgICAgICAgICAgICAgICAgICAgICdNYWNCdWlsZEluc3RydWN0aW9ucycpCisgICAgICAg ICAgICBfbG9nLmVycm9yKCcgICAgaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9wL2Nocm9taXVtL3dp a2kvTWFjQnVpbGRJbnN0cnVjdGlvbnMnKQogCiAgICAgICAgIHJldHVybiByZXN1bHQKIApAQCAt MTQ3LDggKzE1MSw3IEBAIGNsYXNzIENocm9taXVtTWFjUG9ydChjaHJvbWl1bS5DaHJvbWl1bVBv cnQpOgogICAgICAgICByZXR1cm4gc2VsZi5fbGlnaHR0cGRfcGF0aCgnYmluJywgJ3BocC1jZ2kn KQogCiAgICAgZGVmIF9wYXRoX3RvX2RyaXZlcihzZWxmLCBjb25maWd1cmF0aW9uPU5vbmUpOgot ICAgICAgICAjIEZJWE1FOiBtYWtlIHxjb25maWd1cmF0aW9ufCBoYXBweSB3aXRoIGNhc2Utc2Vu c2l0aXZlIGZpbGUKLSAgICAgICAgIyBzeXN0ZW1zLgorICAgICAgICAjIEZJWE1FOiBtYWtlIHxj b25maWd1cmF0aW9ufCBoYXBweSB3aXRoIGNhc2Utc2Vuc2l0aXZlIGZpbGUgc3lzdGVtcy4KICAg ICAgICAgaWYgbm90IGNvbmZpZ3VyYXRpb246CiAgICAgICAgICAgICBjb25maWd1cmF0aW9uID0g c2VsZi5nZXRfb3B0aW9uKCdjb25maWd1cmF0aW9uJykKICAgICAgICAgcmV0dXJuIHNlbGYuX2J1 aWxkX3BhdGgoY29uZmlndXJhdGlvbiwgc2VsZi5kcml2ZXJfbmFtZSgpICsgJy5hcHAnLApkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bV93aW4ucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9t aXVtX3dpbi5weQppbmRleCBiOTAzYzNmZTJhMjdlMGYwM2EwOGY3YmVjYWQyYTRhMWZjZDViMjRi Li44ZTU4ZmFiMzY5NWMxOGUxNTc4ODc2ZjNhYWFmNWU4NWNjMWVhNGFkIDEwMDc1NQotLS0gYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dp bi5weQpAQCAtNjUsMTggKzY1LDIyIEBAIGNsYXNzIENocm9taXVtV2luUG9ydChjaHJvbWl1bS5D aHJvbWl1bVBvcnQpOgogICAgICAgICAnd2luNyc6IFsnY2hyb21pdW0td2luJywgJ2Nocm9taXVt JywgJ3dpbicsICdtYWMnXSwKICAgICB9CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9u YW1lPU5vbmUsIHdpbmRvd3NfdmVyc2lvbj1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgICMgV2Un cmUgYSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhpcyBjb2RlIGlzIHJldXNlZCBieSB0 aGUKLSAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBhcyB3ZWxsIGFzIHRoZSAnbW9jay0n IGFuZCAnZHJ5cnVuLScgcG9ydHMuCi0gICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZSBvciAn Y2hyb21pdW0td2luJwotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBvcnQuX19pbml0X18oc2Vs ZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAgIyBGSVhNRTogdmVyc2lvbiwg bmFtZSwgZXRjLiBzaG91bGQgYmUgcGFzc2VkIHNlcGFyYXRlbHkgYW5kIHdlIHNob3VsZCBub3Qg aGF2ZSB0byBwYXJzZSBwb3J0X25hbWUuCisgICAgZGVmIF9wYXJzZV9wb3J0X25hbWUoc2VsZiwg cG9ydF9uYW1lLCB3aW5kb3dzX3ZlcnNpb24pOgogICAgICAgICBpZiBwb3J0X25hbWUuZW5kc3dp dGgoJy13aW4nKToKICAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBvc192ZXJzaW9uKHdpbmRv d3NfdmVyc2lvbikKICAgICAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBz ZWxmLl92ZXJzaW9uCiAgICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0g cG9ydF9uYW1lW3BvcnRfbmFtZS5pbmRleCgnLXdpbi0nKSArIDU6XQotICAgICAgICAgICAgYXNz ZXJ0IHNlbGYuX3ZlcnNpb24gaW4gc2VsZi5TVVBQT1JURURfVkVSU0lPTlMKKyAgICAgICAgICAg IHNlbGYuX3BvcnRfbmFtZSA9IHBvcnRfbmFtZVs6cG9ydF9uYW1lLmluZGV4KCctd2luLScpICsg bGVuKCctd2luJyldCisgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lW3BvcnRf bmFtZS5pbmRleCgnLXdpbi0nKSArIGxlbignLXdpbi0nKTpdCisgICAgICAgICAgICBhc3NlcnQg c2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUywgIiVzIGlzIG5vdCBpbiAl cyIgJSAoc2VsZi5fdmVyc2lvbiwgc2VsZi5TVVBQT1JURURfVkVSU0lPTlMpCiAKKyAgICBkZWYg X19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIHdpbmRvd3NfdmVyc2lvbj1Ob25lLCAqKmt3 YXJncyk6CisgICAgICAgICMgV2UncmUgYSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhp cyBjb2RlIGlzIHJldXNlZCBieSB0aGUKKyAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBh cyB3ZWxsIGFzIHRoZSAnbW9jay0nIGFuZCAnZHJ5cnVuLScgcG9ydHMuCisgICAgICAgIHBvcnRf bmFtZSA9IHBvcnRfbmFtZSBvciAnY2hyb21pdW0td2luJworICAgICAgICBjaHJvbWl1bS5DaHJv bWl1bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisg ICAgICAgIHNlbGYuX3BhcnNlX3BvcnRfbmFtZShwb3J0X25hbWUsIHdpbmRvd3NfdmVyc2lvbikK ICAgICAgICAgc2VsZi5fb3BlcmF0aW5nX3N5c3RlbSA9ICd3aW4nCiAKICAgICBkZWYgc2V0dXBf ZW52aXJvbl9mb3Jfc2VydmVyKHNlbGYpOgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jb25maWcucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2NvbmZpZy5weQppbmRleCA2NTQ0MTcwZWNlNDdmZGI2OTQwNzQy MTg4YWFmYTcwZDIxNTMyMDQ3Li5kZWJiY2JhNjBmNGJmY2YxZWVkZjBkNmY1MjVmNzgxZWQxYzU4 YzNjIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2NvbmZpZy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2NvbmZpZy5weQpAQCAtMTE4LDcgKzExOCw4IEBAIGNsYXNzIENvbmZpZyhvYmplY3QpOgogICAg ICAgICAjCiAgICAgICAgICMgVGhpcyBjb2RlIHdpbGwgYWxzbyB3b3JrIGlmIHRoZXJlIGlzIG5v IFNDTSBzeXN0ZW0gYXQgYWxsLgogICAgICAgICBpZiBub3Qgc2VsZi5fd2Via2l0X2Jhc2VfZGly OgotICAgICAgICAgICAgYWJzcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0uYWJzcGF0aChfX2ZpbGVf XykKKyAgICAgICAgICAgIGNvbmZpZ19tb2R1bGVfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0ucGF0 aF90b19tb2R1bGUoc2VsZi5fX21vZHVsZV9fKQorICAgICAgICAgICAgYWJzcGF0aCA9IHNlbGYu X2ZpbGVzeXN0ZW0uYWJzcGF0aChjb25maWdfbW9kdWxlX3BhdGgpICAjIEZJWE1FOiBJIHN1c3Bl Y3QgdGhpcyBpcyBhIG5vb3AuCiAgICAgICAgICAgICBzZWxmLl93ZWJraXRfYmFzZV9kaXIgPSBh YnNwYXRoWzA6YWJzcGF0aC5maW5kKCdUb29scycpIC0gMV0KICAgICAgICAgcmV0dXJuIHNlbGYu X3dlYmtpdF9iYXNlX2RpcgogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L2d0ay5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvZ3RrLnB5CmluZGV4IDI1NmE1ZWYwMzlkZjhkM2VkNDY3MjAyYzE5OGQ2NjVjNjZh M2Y2NDcuLjk5NTVmZDZiMGVlMDg5NmY4ODRhMTBkYjc4YTA4Y2I5MmY2OWIxY2UgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ3RrLnB5CisrKyBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ3RrLnB5CkBAIC00OCw3 ICs0OCw3IEBAIGNsYXNzIEd0a1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgJ2FwYWNoZTItZGViaWFuLWh0dHBkLmNvbmYnKQogCiAgICAgZGVm IF9wYXRoX3RvX2RyaXZlcihzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgo J1Byb2dyYW1zJywgJ0R1bXBSZW5kZXJUcmVlJykKKyAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxk X3BhdGgoJ1Byb2dyYW1zJywgc2VsZi5kcml2ZXJfbmFtZSgpKQogCiAgICAgZGVmIGNoZWNrX2J1 aWxkKHNlbGYsIG5lZWRzX2h0dHApOgogICAgICAgICBpZiBub3Qgc2VsZi5fY2hlY2tfZHJpdmVy KCk6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L21hYy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5 CmluZGV4IDMwMjFmYzNjZDhjNGVlY2M0YWZmMDMxOGRkYjBmMTJhYTc4OWFhZmEuLmRiYTRjMjg4 OWI2NzAzNGZiODFlOTdmMTM0NTFhMjQ2OTcyNjUwYzAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CkBAIC0zNCw3ICszNCw3IEBAIGltcG9y dCByZQogCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LndlYmtpdCBpbXBvcnQgV2Vi S2l0UG9ydAogCi1fbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0 cy5wb3J0Lm1hYyIpCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCiAKIAogZGVm IG9zX3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwgc3VwcG9ydGVkX3ZlcnNpb25zPU5v bmUpOgpAQCAtNDYsMTEgKzQ2LDEyIEBAIGRlZiBvc192ZXJzaW9uKG9zX3ZlcnNpb25fc3RyaW5n PU5vbmUsIHN1cHBvcnRlZF92ZXJzaW9ucz1Ob25lKToKICAgICAgICAgICAgIG9zX3ZlcnNpb25f c3RyaW5nID0gIjEwLjUuNiIKICAgICByZWxlYXNlX3ZlcnNpb24gPSBpbnQob3NfdmVyc2lvbl9z dHJpbmcuc3BsaXQoJy4nKVsxXSkKICAgICB2ZXJzaW9uX3N0cmluZ3MgPSB7Ci0gICAgICAgIDQ6 ICd0aWdlcicsCiAgICAgICAgIDU6ICdsZW9wYXJkJywKICAgICAgICAgNjogJ3Nub3dsZW9wYXJk JywKKyAgICAgICAgIyBBZGQgNzogJ2xpb24nIGhlcmU/CiAgICAgfQogICAgIGFzc2VydCByZWxl YXNlX3ZlcnNpb24gPj0gbWluKHZlcnNpb25fc3RyaW5ncy5rZXlzKCkpCisgICAgIyBGSVhNRTog VGhlcmUgaXMgbm8gbWFjLWZ1dHVyZSBkaXJlY3RvcnksIEkgZG9uJ3QgdW5kZXJzdGFuZCB3aHkg dGhpcyBjb2RlIGlzIGhlcmUuCiAgICAgdmVyc2lvbl9zdHJpbmcgPSB2ZXJzaW9uX3N0cmluZ3Mu Z2V0KHJlbGVhc2VfdmVyc2lvbiwgJ2Z1dHVyZScpCiAgICAgaWYgc3VwcG9ydGVkX3ZlcnNpb25z OgogICAgICAgICBhc3NlcnQgdmVyc2lvbl9zdHJpbmcgaW4gc3VwcG9ydGVkX3ZlcnNpb25zCkBA IC01OCwyOCArNTksMzMgQEAgZGVmIG9zX3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwg c3VwcG9ydGVkX3ZlcnNpb25zPU5vbmUpOgogCiAKIGNsYXNzIE1hY1BvcnQoV2ViS2l0UG9ydCk6 Ci0gICAgIiIiV2ViS2l0IE1hYyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBjbGFzcy4iIiIK ICAgICAjIEZJWE1FOiAnd2syJyBwcm9iYWJseSBzaG91bGRuJ3QgYmUgYSB2ZXJzaW9uLCBpdCBz aG91bGQgcHJvYmFibHkgYmUKICAgICAjIGEgbW9kaWZpZXIsIGxpa2UgJ2Nocm9taXVtLWdwdScg aXMgdG8gJ2Nocm9taXVtJy4KLSAgICBTVVBQT1JURURfVkVSU0lPTlMgPSAoJ3RpZ2VyJywgJ2xl b3BhcmQnLCAnc25vd2xlb3BhcmQnLCAnZnV0dXJlJywgJ3drMicpCisgICAgU1VQUE9SVEVEX1ZF UlNJT05TID0gKCdsZW9wYXJkJywgJ3Nub3dsZW9wYXJkJywgJ2Z1dHVyZScsICd3azInKQogCiAg ICAgRkFMTEJBQ0tfUEFUSFMgPSB7Ci0gICAgICAgICd0aWdlcic6IFsnbWFjLXRpZ2VyJywgJ21h Yy1sZW9wYXJkJywgJ21hYy1zbm93bGVvcGFyZCcsICdtYWMnXSwKICAgICAgICAgJ2xlb3BhcmQn OiBbJ21hYy1sZW9wYXJkJywgJ21hYy1zbm93bGVvcGFyZCcsICdtYWMnXSwKICAgICAgICAgJ3Nu b3dsZW9wYXJkJzogWydtYWMtc25vd2xlb3BhcmQnLCAnbWFjJ10sCiAgICAgICAgICdmdXR1cmUn OiBbJ21hYyddLAorICAgICAgICAjIEZJWE1FOiBUaGlzIGlzbid0IHF1aXRlIHJpZ2h0IGZvciB3 azIsIGl0IHNob3VsZCBpbmNsdWRlIG1hYy1WRVJTSU9OIGFzIHdlbGwuCiAgICAgICAgICd3azIn OiBbJ21hYy13azInLCAnbWFjJ10sCiAgICAgfQogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBv cnRfbmFtZT1Ob25lLCBvc192ZXJzaW9uX3N0cmluZz1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAg IHBvcnRfbmFtZSA9IHBvcnRfbmFtZSBvciAnbWFjJwotICAgICAgICBXZWJLaXRQb3J0Ll9faW5p dF9fKHNlbGYsIHBvcnRfbmFtZT1wb3J0X25hbWUsICoqa3dhcmdzKQorICAgICMgRklYTUU6IHZl cnNpb24sIG5hbWUsIGV0Yy4gc2hvdWxkIGJlIHBhc3NlZCBzZXBhcmF0ZWx5IGFuZCB3ZSBzaG91 bGQgbm90IGhhdmUgdG8gcGFyc2UgcG9ydF9uYW1lLgorICAgIGRlZiBfcGFyc2VfcG9ydF9uYW1l KHNlbGYsIHBvcnRfbmFtZSwgb3NfdmVyc2lvbl9zdHJpbmcpOgogICAgICAgICBpZiBwb3J0X25h bWUgPT0gJ21hYyc6CiAgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gb3NfdmVyc2lvbihvc192 ZXJzaW9uX3N0cmluZykKICAgICAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScg KyBzZWxmLl92ZXJzaW9uCiAgICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9u ID0gcG9ydF9uYW1lWzQ6XQotICAgICAgICAgICAgYXNzZXJ0IHNlbGYuX3ZlcnNpb24gaW4gc2Vs Zi5TVVBQT1JURURfVkVSU0lPTlMKKyAgICAgICAgICAgIGFzc2VydCBwb3J0X25hbWUuc3RhcnRz d2l0aCgnbWFjJykKKyAgICAgICAgICAgIHNlbGYuX3BvcnRfbmFtZSA9ICdtYWMnCisgICAgICAg ICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lW2xlbignbWFjLScpOl0KKyAgICAgICAgICAg IGFzc2VydCBzZWxmLl92ZXJzaW9uIGluIHNlbGYuU1VQUE9SVEVEX1ZFUlNJT05TLCAiJXMgaXMg bm90IGluICVzIiAlIChzZWxmLl92ZXJzaW9uLCBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUykKKwor ICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgb3NfdmVyc2lvbl9zdHJpbmc9 Tm9uZSwgKiprd2FyZ3MpOgorICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25hbWUgb3IgJ21hYycK KyAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAq Kmt3YXJncykKKyAgICAgICAgc2VsZi5fcGFyc2VfcG9ydF9uYW1lKHBvcnRfbmFtZSwgb3NfdmVy c2lvbl9zdHJpbmcpCiAgICAgICAgIHNlbGYuX29wZXJhdGluZ19zeXN0ZW0gPSAnbWFjJwogICAg ICAgICBpZiBub3QgaGFzYXR0cihzZWxmLl9vcHRpb25zLCAndGltZS1vdXQtbXMnKSBvciBzZWxm Ll9vcHRpb25zLnRpbWVfb3V0X21zIGlzIE5vbmU6CiAgICAgICAgICAgICBzZWxmLl9vcHRpb25z LnRpbWVfb3V0X21zID0gMzUwMDAKQEAgLTk2LDI0ICsxMDIsOSBAQCBjbGFzcyBNYWNQb3J0KFdl YktpdFBvcnQpOgogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAg cmV0dXJuIG1hcChzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aCwgc2VsZi5GQUxMQkFDS19QQVRI U1tzZWxmLl92ZXJzaW9uXSkKIAotICAgIGRlZiBwYXRoX3RvX3Rlc3RfZXhwZWN0YXRpb25zX2Zp bGUoc2VsZik6Ci0gICAgICAgIHJldHVybiBzZWxmLnBhdGhfZnJvbV93ZWJraXRfYmFzZSgnTGF5 b3V0VGVzdHMnLCAncGxhdGZvcm0nLAotICAgICAgICAgICAnbWFjJywgJ3Rlc3RfZXhwZWN0YXRp b25zLnR4dCcpCi0KICAgICBkZWYgaXNfY3Jhc2hfcmVwb3J0ZXIoc2VsZiwgcHJvY2Vzc19uYW1l KToKICAgICAgICAgcmV0dXJuIHJlLnNlYXJjaChyJ1JlcG9ydENyYXNoJywgcHJvY2Vzc19uYW1l KQogCi0gICAgZGVmIF9za2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgICMgRklYTUU6 IFRoaXMgbWV0aG9kIHdpbGwgbmVlZCB0byBiZSBtYWRlIHdvcmsgZm9yIG5vbi1tYWMKLSAgICAg ICAgIyBwbGF0Zm9ybXMgYW5kIG1vdmVkIGludG8gYmFzZS5Qb3J0LgotICAgICAgICBza2lwcGVk X2ZpbGVzID0gW10KLSAgICAgICAgaWYgc2VsZi5fbmFtZSBpbiAoJ21hYy1sZW9wYXJkJywgJ21h Yy1zbm93bGVvcGFyZCcpOgotICAgICAgICAgICAgc2tpcHBlZF9maWxlcy5hcHBlbmQoc2VsZi5f ZmlsZXN5c3RlbS5qb2luKAotICAgICAgICAgICAgICAgIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9w YXRoKHNlbGYuX25hbWUpLCAnU2tpcHBlZCcpKQotICAgICAgICBza2lwcGVkX2ZpbGVzLmFwcGVu ZChzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoJ21hYycp LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ1NraXBwZWQnKSkK LSAgICAgICAgcmV0dXJuIHNraXBwZWRfZmlsZXMKLQogICAgIGRlZiBfYnVpbGRfamF2YV90ZXN0 X3N1cHBvcnQoc2VsZik6CiAgICAgICAgIGphdmFfdGVzdHNfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0 ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgImphdmEiKQogICAgICAgICBidWlsZF9q YXZhID0gWyIvdXNyL2Jpbi9tYWtlIiwgIi1DIiwgamF2YV90ZXN0c19wYXRoXQpAQCAtMTI2LDgg KzExNyw3IEBAIGNsYXNzIE1hY1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgIHJldHVybiBzZWxm Ll9idWlsZF9qYXZhX3Rlc3Rfc3VwcG9ydCgpCiAKICAgICBkZWYgX3BhdGhfdG9fYXBhY2hlX2Nv bmZpZ19maWxlKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNl bGYubGF5b3V0X3Rlc3RzX2RpcigpLCAnaHR0cCcsICdjb25mJywKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAnYXBhY2hlMi1odHRwZC5jb25mJykKKyAgICAgICAgcmV0dXJu IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ2h0dHAnLCAn Y29uZicsICdhcGFjaGUyLWh0dHBkLmNvbmYnKQogCiAgICAgZGVmIF9wYXRoX3RvX3dlYmNvcmVf bGlicmFyeShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgoJ1dlYkNvcmUu ZnJhbWV3b3JrL1ZlcnNpb25zL0EvV2ViQ29yZScpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weSBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CmluZGV4IGFlNTQ3 ZjJiOTZiODVmMTRhNmVmZDA2YWFjMWU5MTZiZWE2NzQ1Y2MuLjU2YTFjN2Q2NDY5ZjAzOTE2ODNm YWVjMjllY2YwMDgzYzhhMGViYjYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CkBAIC00MCwyNCArNDAsMjAg QEAgY2xhc3MgTWFjVGVzdChwb3J0X3Rlc3RjYXNlLlBvcnRUZXN0Q2FzZSk6CiAgICAgICAgICAg ICByZXR1cm4gTm9uZQogICAgICAgICByZXR1cm4gbWFjLk1hY1BvcnQKIAotICAgIGRlZiBhc3Nl cnRfc2tpcHBlZF9maWxlc19mb3JfdmVyc2lvbihzZWxmLCBwb3J0X25hbWUsIGV4cGVjdGVkX3Bh dGhzKToKKyAgICBkZWYgYXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZiwgcG9y dF9uYW1lLCBleHBlY3RlZF9wYXRocyk6CiAgICAgICAgIHBvcnQgPSBtYWMuTWFjUG9ydChwb3J0 X25hbWU9cG9ydF9uYW1lKQotICAgICAgICBza2lwcGVkX3BhdGhzID0gcG9ydC5fc2tpcHBlZF9m aWxlX3BhdGhzKCkKLSAgICAgICAgIyBGSVhNRTogX3NraXBwZWRfZmlsZV9wYXRocyBzaG91bGQg cmV0dXJuIFdlYktpdC1yZWxhdGl2ZSBwYXRocy4KLSAgICAgICAgIyBTbyB0byBtYWtlIGl0IHVu aXQgdGVzdGFibGUsIHdlIHN0cmlwIHRoZSBXZWJLaXQgZGlyZWN0b3J5IGZyb20gdGhlIHBhdGgu Ci0gICAgICAgIHJlbGF0aXZlX3BhdGhzID0gW3BhdGhbbGVuKHBvcnQucGF0aF9mcm9tX3dlYmtp dF9iYXNlKCkpOl0gZm9yIHBhdGggaW4gc2tpcHBlZF9wYXRoc10KLSAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbChyZWxhdGl2ZV9wYXRocywgZXhwZWN0ZWRfcGF0aHMpCi0KLSAgICBkZWYgdGVzdF9z a2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgICMgV2Ugc2tpcCB0aGlzIG9uIHdpbjMy IGJlY2F1c2Ugd2UgdXNlICcvJyBhcyB0aGUgZGlyIHNlcGFyYXRvciBhbmQgaXQncwotICAgICAg ICAjIG5vdCB3b3J0aCBtYWtpbmcgcGxhdGZvcm0taW5kZXBlbmRlbnQuCisgICAgICAgIHNlbGYu YXNzZXJ0RXF1YWwocG9ydC5fc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygpLCBleHBlY3RlZF9w YXRocykKKworICAgIGRlZiB0ZXN0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZik6Cisg ICAgICAgICMgRklYTUU6IFRoaXMgc2hvdWxkIG5vIGxvbmdlciBiZSBuZWNlc3NhcnksIGJ1dCBJ J20gbm90IGJyYXZlIGVub3VnaCB0byByZW1vdmUgaXQuCiAgICAgICAgIGlmIHN5cy5wbGF0Zm9y bSA9PSAnd2luMzInOgogICAgICAgICAgICAgcmV0dXJuIE5vbmUKIAotICAgICAgICBzZWxmLmFz c2VydF9za2lwcGVkX2ZpbGVzX2Zvcl92ZXJzaW9uKCdtYWMtc25vd2xlb3BhcmQnLAotICAgICAg ICAgICAgWycvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXNub3dsZW9wYXJkL1NraXBwZWQnLCAn L0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9Ta2lwcGVkJ10pCi0gICAgICAgIHNlbGYuYXNzZXJ0 X3NraXBwZWRfZmlsZXNfZm9yX3ZlcnNpb24oJ21hYy1sZW9wYXJkJywKLSAgICAgICAgICAgIFsn L0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy1sZW9wYXJkL1NraXBwZWQnLCAnL0xheW91dFRlc3Rz L3BsYXRmb3JtL21hYy9Ta2lwcGVkJ10pCisgICAgICAgIHNlbGYuYXNzZXJ0X3NraXBwZWRfZmls ZV9zZWFyY2hfcGF0aHMoJ21hYy1zbm93bGVvcGFyZCcsIHNldChbJ21hYy1zbm93bGVvcGFyZCcs ICdtYWMnXSkpCisgICAgICAgIHNlbGYuYXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMo J21hYy1sZW9wYXJkJywgc2V0KFsnbWFjLWxlb3BhcmQnLCAnbWFjJ10pKQorICAgICAgICAjIFdl IGNhbm5vdCB0ZXN0IGp1c3QgIm1hYyIgaGVyZSBhcyB0aGUgTWFjUG9ydCBjb25zdHJ1Y3RvciBh dXRvbWF0aWNhbGx5IGZpbGxzIGluIHRoZSB2ZXJzaW9uIGZyb20gdGhlIHJ1bm5pbmcgT1MuCisg ICAgICAgICMgc2VsZi5hc3NlcnRfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygnbWFjJywgWydt YWMnXSkKKwogCiAgICAgZXhhbXBsZV9za2lwcGVkX2ZpbGUgPSB1IiIiCiAjIDxyZGFyOi8vcHJv YmxlbS81NjQ3OTUyPiBmYXN0L2V2ZW50cy9tb3VzZW91dC1vbi13aW5kb3cuaHRtbCBuZWVkcyBt YWMgRFJUIHRvIGlzc3VlIG1vdXNlIG91dCBldmVudHMKQEAgLTk4LDEzICs5NCw3IEBAIHN2Zy9i YXRpay90ZXh0L3NtYWxsRm9udHMuc3ZnCiAgICAgZGVmIHRlc3RfdmVyc2lvbnMoc2VsZik6CiAg ICAgICAgIHBvcnQgPSBzZWxmLm1ha2VfcG9ydCgpCiAgICAgICAgIGlmIHBvcnQ6Ci0gICAgICAg ICAgICBzZWxmLmFzc2VydFRydWUocG9ydC5uYW1lKCkgaW4gKCdtYWMtdGlnZXInLCAnbWFjLWxl b3BhcmQnLCAnbWFjLXNub3dsZW9wYXJkJywgJ21hYy1mdXR1cmUnKSkKLQotICAgICAgICBzZWxm LmFzc2VydF9uYW1lKE5vbmUsICcxMC40LjgnLCAnbWFjLXRpZ2VyJykKLSAgICAgICAgc2VsZi5h c3NlcnRfbmFtZSgnbWFjJywgJzEwLjQuOCcsICdtYWMtdGlnZXInKQotICAgICAgICBzZWxmLmFz c2VydF9uYW1lKCdtYWMtdGlnZXInLCAnMTAuNC44JywgJ21hYy10aWdlcicpCi0gICAgICAgIHNl bGYuYXNzZXJ0X25hbWUoJ21hYy10aWdlcicsICcxMC41LjMnLCAnbWFjLXRpZ2VyJykKLSAgICAg ICAgc2VsZi5hc3NlcnRfbmFtZSgnbWFjLXRpZ2VyJywgJzEwLjYuMycsICdtYWMtdGlnZXInKQor ICAgICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBvcnQubmFtZSgpIGluICgnbWFjLWxlb3BhcmQn LCAnbWFjLXNub3dsZW9wYXJkJywgJ21hYy1mdXR1cmUnKSkKIAogICAgICAgICBzZWxmLmFzc2Vy dF9uYW1lKE5vbmUsICcxMC41LjMnLCAnbWFjLWxlb3BhcmQnKQogICAgICAgICBzZWxmLmFzc2Vy dF9uYW1lKCdtYWMnLCAnMTAuNS4zJywgJ21hYy1sZW9wYXJkJykKZGlmZiAtLWdpdCBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5CmluZGV4IDZmZDVkYmI5ZDM2MzgyOGQ3 ZDE1MDhlNGNjYmM4NjVmZTRiZGM1NzMuLmNjMmM1NDc2NDAwNWE4OGJlMTlmMjIwYTVjYzk2NWI0 OTUzYjNmOWEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvcXQucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9xdC5weQpAQCAtMzUsMTIgKzM1LDEwIEBAIGltcG9ydCB3ZWJraXQKIAogZnJvbSB3ZWJraXRw eS5sYXlvdXRfdGVzdHMucG9ydC53ZWJraXQgaW1wb3J0IFdlYktpdFBvcnQKIAotX2xvZyA9IGxv Z2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC5xdCIpCitfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCiAKIAogY2xhc3MgUXRQb3J0KFdlYktpdFBvcnQp OgotICAgICIiIlF0V2ViS2l0IGltcGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIiIgot CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsICoqa3dhcmdzKToKICAgICAgICAga3dhcmdzLnNldGRl ZmF1bHQoJ3BvcnRfbmFtZScsICdxdCcpCiAgICAgICAgIFdlYktpdFBvcnQuX19pbml0X18oc2Vs ZiwgKiprd2FyZ3MpCkBAIC02Niw3ICs2NCw3IEBAIGNsYXNzIFF0UG9ydChXZWJLaXRQb3J0KToK ICAgICAgICAgcmV0dXJuIFRydWUKIAogICAgIGRlZiBfcGF0aF90b19kcml2ZXIoc2VsZik6Ci0g ICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKCdiaW4vRHVtcFJlbmRlclRyZWUnKQorICAg ICAgICByZXR1cm4gc2VsZi5fYnVpbGRfcGF0aCgnYmluLyVzJyAlIHNlbGYuZHJpdmVyX25hbWUo KSkKIAogICAgIGRlZiBfcGF0aF90b19pbWFnZV9kaWZmKHNlbGYpOgogICAgICAgICByZXR1cm4g c2VsZi5fYnVpbGRfcGF0aCgnYmluL0ltYWdlRGlmZicpCmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CmluZGV4IGUxM2M1N2ZkZTkzYTUz YTMxMDQ3MWRhMDQ2MGNjM2M2N2QxYzRjOGQuLjU1NDVmYTQ1MzEzMzVhZGM3MWM0MDAzYzAzNTU3 MmM5NDYwYTVjZmIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0LnB5CkBAIC02NSwxMiArNjUsMjEgQEAgY2xhc3MgV2ViS2l0UG9ydChi YXNlLlBvcnQpOgogICAgICAgICAgICAgcmV0dXJuICJXZWJLaXRUZXN0UnVubmVyIgogICAgICAg ICByZXR1cm4gIkR1bXBSZW5kZXJUcmVlIgogCisgICAgIyBGSVhNRTogVGhpcyBpcyBub3QgYSB2 ZXJ5IHVzZWZ1bCBkZWZhdWx0IGltcGxlbWVudGF0aW9uLCBhcyBpdHMgd3JvbmcgZm9yIGFueQor ICAgICMgcG9ydCB3aGljaCByZXF1aXJlcyBwbGF0Zm9ybS1zcGVjZmljIHJlc3VsdHMuIFdlIHNo b3VsZCByZXBsYWNlIHRoaXMgd2l0aCBhIHNtYXJ0ZXIKKyAgICAjIGltcGxlbWVudGF0aW9uIHNo YXJlZCBieSBhbGwgcG9ydHMuCiAgICAgZGVmIGJhc2VsaW5lX3NlYXJjaF9wYXRoKHNlbGYpOgot ICAgICAgICByZXR1cm4gW3NlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpXQor ICAgICAgICBzZWFyY2hfcGF0aHMgPSBbc2VsZi5uYW1lKCldCisgICAgICAgIGlmIHNlbGYuZ2V0 X29wdGlvbignd2Via2l0X3Rlc3RfcnVubmVyJyk6CisgICAgICAgICAgICBzZWFyY2hfcGF0aHMu aW5zZXJ0KDAsIHNlbGYud2syX3BvcnRfbmFtZSgpKQorICAgICAgICByZXR1cm4gc2VhcmNoX3Bh dGhzCisKKyAgICBkZWYgX2V4cGVjdGF0aW9uc19zZWFyY2hfcGF0aChzZWxmKToKKyAgICAgICAg IyB0ZXN0X2V4cGVjdGF0aW9ucyBhcmUgYWx3YXlzIGluIG1hYy8gbm90IG1hYy1sZW9wYXJkLyBi eSBjb252ZW50aW9uLCBoZW5jZSB3ZSB1c2UgcG9ydF9uYW1lKCkgaW5zdGVhZCBvZiBuYW1lKCku CisgICAgICAgIHJldHVybiBzZWxmLndrMl9wb3J0X25hbWUoKSBpZiBzZWxmLmdldF9vcHRpb24o J3dlYmtpdF90ZXN0X3J1bm5lcicpIGVsc2Ugc2VsZi5wb3J0X25hbWUoKQogCiAgICAgZGVmIHBh dGhfdG9fdGVzdF9leHBlY3RhdGlvbnNfZmlsZShzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYu X2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxmLl9uYW1lKSwK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAndGVzdF9leHBlY3RhdGlvbnMu dHh0JykKKyAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRf YmFzZWxpbmVfcGF0aChzZWxmLl9leHBlY3RhdGlvbnNfc2VhcmNoX3BhdGgoKSksICd0ZXN0X2V4 cGVjdGF0aW9ucy50eHQnKQogCiAgICAgZGVmIF9yZXN1bHRzX2Zvcl9wbGF0Zm9ybShzZWxmLCBw bGF0Zm9ybSk6CiAgICAgICAgIGJ1aWxkZXJfbmFtZSA9IGJ1aWxkZXJzLmJ1aWxkZXJfbmFtZV9m b3JfcGxhdGZvcm0ocGxhdGZvcm0pCkBAIC0yODMsMTIgKzI5MiwyNSBAQCBjbGFzcyBXZWJLaXRQ b3J0KGJhc2UuUG9ydCk6CiAgICAgICAgICAgICB0ZXN0c190b19za2lwLmFwcGVuZChsaW5lKQog ICAgICAgICByZXR1cm4gdGVzdHNfdG9fc2tpcAogCi0gICAgZGVmIF9za2lwcGVkX2ZpbGVfcGF0 aHMoc2VsZik6Ci0gICAgICAgIHJldHVybiBbc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYuX3dl YmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpLCAnU2tpcHBlZCcpXQorICAgIGRlZiB3azJf cG9ydF9uYW1lKHNlbGYpOgorICAgICAgICByZXR1cm4gIiVzLXdrMiIgJSBzZWxmLnBvcnRfbmFt ZSgpCisKKyAgICBkZWYgX3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZik6CisgICAgICAg ICMgVW5saWtlIGJhc2VsaW5lX3NlYXJjaF9wYXRoLCB3ZSBvbmx5IHdhbnQgdG8gc2VhcmNoIFtX SzItUE9SVCwgUE9SVC1WRVJTSU9OLCBQT1JUXSBub3QgdGhlIGZ1bGwgY2FzYWRlLgorICAgICAg ICAjIE5vdGUgb3JkZXIgZG9lc24ndCBtYXR0ZXIgc2luY2UgdGhlIFNraXBwZWQgZmlsZSBjb250 ZW50cyBhcmUgYWxsIGNvbWJpbmVkLgorICAgICAgICBzZWFyY2hfcGF0aHMgPSBzZXQoW3NlbGYu cG9ydF9uYW1lKCksIHNlbGYubmFtZSgpXSkKKyAgICAgICAgaWYgc2VsZi5nZXRfb3B0aW9uKCd3 ZWJraXRfdGVzdF9ydW5uZXInKToKKyAgICAgICAgICAgICMgUXVvdGluZyBvbGQtcnVuLXdlYmtp dC10ZXN0czoKKyAgICAgICAgICAgICMgQmVjYXVzZSBuZWFybHkgYWxsIG9mIHRoZSBza2lwcGVk IHRlc3RzIGZvciBXZWJLaXQgMiBvbiBNYWMgYXJlIGR1ZSB0bworICAgICAgICAgICAgIyBjcm9z cy1wbGF0Zm9ybSBpc3N1ZXMsIHRoZSBXaW5kb3dzIGFuZCBRdCBwb3J0cyB1c2UgdGhlIE1hYyBz a2lwcGVkIGxpc3QKKyAgICAgICAgICAgICMgYWRkaXRpb25hbGx5IHRvIHRoZWlyIG93biB0byBh dm9pZCBtYWludGFpbmluZyBzZXBhcmF0ZSBsaXN0cy4KKyAgICAgICAgICAgIHNlYXJjaF9wYXRo cy51cGRhdGUoW3NlbGYud2syX3BvcnRfbmFtZSgpLCAibWFjLXdrMiJdKQorICAgICAgICByZXR1 cm4gc2VhcmNoX3BhdGhzCiAKICAgICBkZWYgX2V4cGVjdGF0aW9uc19mcm9tX3NraXBwZWRfZmls ZXMoc2VsZik6CiAgICAgICAgIHRlc3RzX3RvX3NraXAgPSBbXQotICAgICAgICBmb3IgZmlsZW5h bWUgaW4gc2VsZi5fc2tpcHBlZF9maWxlX3BhdGhzKCk6CisgICAgICAgIGZvciBzZWFyY2hfcGF0 aCBpbiBzZWxmLl9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCk6CisgICAgICAgICAgICBmaWxl bmFtZSA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChz ZWFyY2hfcGF0aCksICJTa2lwcGVkIikKICAgICAgICAgICAgIGlmIG5vdCBzZWxmLl9maWxlc3lz dGVtLmV4aXN0cyhmaWxlbmFtZSk6CiAgICAgICAgICAgICAgICAgX2xvZy53YXJuKCJGYWlsZWQg dG8gb3BlbiBTa2lwcGVkIGZpbGU6ICVzIiAlIGZpbGVuYW1lKQogICAgICAgICAgICAgICAgIGNv bnRpbnVlCkBAIC0yOTcsMTIgKzMxOSwxNCBAQCBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6 CiAgICAgICAgIHJldHVybiB0ZXN0c190b19za2lwCiAKICAgICBkZWYgdGVzdF9leHBlY3RhdGlv bnMoc2VsZik6Ci0gICAgICAgICMgVGhlIFdlYktpdCBtYWMgcG9ydCB1c2VzIGEgY29tYmluYXRp b24gb2YgYSB0ZXN0X2V4cGVjdGF0aW9ucyBmaWxlCi0gICAgICAgICMgYW5kICdTa2lwcGVkJyBm aWxlcy4KKyAgICAgICAgIyBUaGlzIGFsbG93cyBwb3J0cyB0byB1c2UgYSBjb21iaW5hdGlvbiBv ZiB0ZXN0X2V4cGVjdGF0aW9ucy50eHQgZmlsZXMgYW5kIFNraXBwZWQgbGlzdHMuCisgICAgICAg IGV4cGVjdGF0aW9ucyA9IHNlbGYuX3NraXBwZWRfbGlzdF9hc19leHBlY3RhdGlvbnNfZmlsZSgp CiAgICAgICAgIGV4cGVjdGF0aW9uc19wYXRoID0gc2VsZi5wYXRoX3RvX3Rlc3RfZXhwZWN0YXRp b25zX2ZpbGUoKQotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3RlbS5yZWFkX3RleHRfZmls ZShleHBlY3RhdGlvbnNfcGF0aCkgKyBzZWxmLl9za2lwcygpCisgICAgICAgIGlmIHNlbGYuX2Zp bGVzeXN0ZW0uZXhpc3RzKGV4cGVjdGF0aW9uc19wYXRoKToKKyAgICAgICAgICAgIGV4cGVjdGF0 aW9ucyArPSBzZWxmLl9maWxlc3lzdGVtLnJlYWRfdGV4dF9maWxlKGV4cGVjdGF0aW9uc19wYXRo KQorICAgICAgICByZXR1cm4gZXhwZWN0YXRpb25zCiAKLSAgICBkZWYgX3NraXBzKHNlbGYpOgor ICAgIGRlZiBfc2tpcHBlZF9saXN0X2FzX2V4cGVjdGF0aW9uc19maWxlKHNlbGYpOgogICAgICAg ICAjIEVhY2ggU2tpcHBlZCBmaWxlIGNvbnRhaW5zIGEgbGlzdCBvZiBmaWxlcwogICAgICAgICAj IG9yIGRpcmVjdG9yaWVzIHRvIGJlIHNraXBwZWQgZHVyaW5nIHRoZSB0ZXN0IHJ1bi4gVGhlIHRv dGFsIGxpc3QKICAgICAgICAgIyBvZiB0ZXN0cyB0byBza2lwcGVkIGlzIGdpdmVuIGJ5IHRoZSBj b250ZW50cyBvZiB0aGUgZ2VuZXJpYwpAQCAtMzEyLDggKzMzNiw3IEBAIGNsYXNzIFdlYktpdFBv cnQoYmFzZS5Qb3J0KToKICAgICAgICAgIyBmb3JtYXQgZXhwZWN0ZWQgYnkgdGVzdF9leHBlY3Rh dGlvbnMuCiAKICAgICAgICAgdGVzdHNfdG9fc2tpcCA9IHNlbGYuc2tpcHBlZF9sYXlvdXRfdGVz dHMoKQotICAgICAgICBza2lwX2xpbmVzID0gbWFwKGxhbWJkYSB0ZXN0X3BhdGg6ICJCVUdfU0tJ UFBFRCBTS0lQIDogJXMgPSBGQUlMIiAlCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHRlc3RfcGF0aCwgdGVzdHNfdG9fc2tpcCkKKyAgICAgICAgc2tpcF9saW5lcyA9IG1hcChsYW1i ZGEgdGVzdF9wYXRoOiAiQlVHX1NLSVBQRUQgU0tJUCA6ICVzID0gRkFJTCIgJSB0ZXN0X3BhdGgs IHRlc3RzX3RvX3NraXApCiAgICAgICAgIHJldHVybiAiXG4iLmpvaW4oc2tpcF9saW5lcykKIAog ICAgIGRlZiBza2lwcGVkX2xheW91dF90ZXN0cyhzZWxmKToKQEAgLTMyOCw3ICszNTEsNyBAQCBj bGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAgICAgICBzZWxmLmdldF9vcHRpb24o J2NvbmZpZ3VyYXRpb24nKSksICpjb21wcykKIAogICAgIGRlZiBfcGF0aF90b19kcml2ZXIoc2Vs Zik6Ci0gICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKCdEdW1wUmVuZGVyVHJlZScpCisg ICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKHNlbGYuZHJpdmVyX25hbWUoKSkKIAogICAg IGRlZiBfcGF0aF90b193ZWJjb3JlX2xpYnJhcnkoc2VsZik6CiAgICAgICAgIHJldHVybiBOb25l CkBAIC0zNTksMTIgKzM4MiwxMiBAQCBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAKIAog Y2xhc3MgV2ViS2l0RHJpdmVyKGJhc2UuRHJpdmVyKToKLSAgICAiIiJXZWJLaXQgaW1wbGVtZW50 YXRpb24gb2YgdGhlIER1bXBSZW5kZXJUcmVlIGludGVyZmFjZS4iIiIKKyAgICAiIiJJbXBsZW1l bnRhdGlvbiBvZiB0aGUgRHVtcFJlbmRlclRyZWUvV2ViS2l0VGVzdFJ1bm5lciBpbnRlcmZhY2Uu IiIiCiAKICAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgd29ya2VyX251bWJlcik6CiAgICAg ICAgIHNlbGYuX3dvcmtlcl9udW1iZXIgPSB3b3JrZXJfbnVtYmVyCiAgICAgICAgIHNlbGYuX3Bv cnQgPSBwb3J0Ci0gICAgICAgIHNlbGYuX2RyaXZlcl90ZW1wZGlyID0gcG9ydC5fZmlsZXN5c3Rl bS5ta2R0ZW1wKHByZWZpeD0nRHVtcFJlbmRlclRyZWUtJykKKyAgICAgICAgc2VsZi5fZHJpdmVy X3RlbXBkaXIgPSBwb3J0Ll9maWxlc3lzdGVtLm1rZHRlbXAocHJlZml4PSclcy0nICUgc2VsZi5f cG9ydC5kcml2ZXJfbmFtZSgpKQogCiAgICAgZGVmIF9fZGVsX18oc2VsZik6CiAgICAgICAgIHNl bGYuX3BvcnQuX2ZpbGVzeXN0ZW0ucm10cmVlKHN0cihzZWxmLl9kcml2ZXJfdGVtcGRpcikpCkBA IC0zODgsOSArNDExLDEwIEBAIGNsYXNzIFdlYktpdERyaXZlcihiYXNlLkRyaXZlcik6CiAgICAg ZGVmIHN0YXJ0KHNlbGYpOgogICAgICAgICBlbnZpcm9ubWVudCA9IHNlbGYuX3BvcnQuc2V0dXBf ZW52aXJvbl9mb3Jfc2VydmVyKCkKICAgICAgICAgZW52aXJvbm1lbnRbJ0RZTERfRlJBTUVXT1JL X1BBVEgnXSA9IHNlbGYuX3BvcnQuX2J1aWxkX3BhdGgoKQorICAgICAgICAjIEZJWE1FOiBXZSdy ZSBhc3N1bWluZyB0aGF0IFdlYktpdFRlc3RSdW5uZXIgY2hlY2tzIHRoaXMgRHVtcFJlbmRlclRy ZWUtbmFtZWQgZW52aXJvbm1lbnQgdmFyaWFibGUuCiAgICAgICAgIGVudmlyb25tZW50WydEVU1Q UkVOREVSVFJFRV9URU1QJ10gPSBzdHIoc2VsZi5fZHJpdmVyX3RlbXBkaXIpCiAgICAgICAgIHNl bGYuX3NlcnZlcl9wcm9jZXNzID0gc2VydmVyX3Byb2Nlc3MuU2VydmVyUHJvY2VzcyhzZWxmLl9w b3J0LAotICAgICAgICAgICAgIkR1bXBSZW5kZXJUcmVlIiwgc2VsZi5jbWRfbGluZSgpLCBlbnZp cm9ubWVudCkKKyAgICAgICAgICAgIHNlbGYuX3BvcnQuZHJpdmVyX25hbWUoKSwgc2VsZi5jbWRf bGluZSgpLCBlbnZpcm9ubWVudCkKIAogICAgIGRlZiBwb2xsKHNlbGYpOgogICAgICAgICByZXR1 cm4gc2VsZi5fc2VydmVyX3Byb2Nlc3MucG9sbCgpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdF91bml0dGVzdC5weSBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5CmluZGV4 IDZhOGQ3ZTExMGQ2MDQ4NzMzODA3ODk2MzFjN2Y1NWYwNDhlNTc4NjUuLmNjNjQ0NTEzYjhmMWRh MThhMDNjZDZjNzI5YWI1YjExN2QzMDMzNmMgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5CkBAIC0z MywyMCArMzMsMTggQEAgZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLm91dHB1dGNhcHR1cmUg aW1wb3J0IE91dHB1dENhcHR1cmUKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQud2Vi a2l0IGltcG9ydCBXZWJLaXRQb3J0CiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0IGlt cG9ydCBwb3J0X3Rlc3RjYXNlCiAKLWZyb20gd2Via2l0cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQg TW9ja0V4ZWN1dGl2ZQotZnJvbSB3ZWJraXRweS50b29sLm1vY2t0b29sIGltcG9ydCBNb2NrT3B0 aW9ucworZnJvbSB3ZWJraXRweS50b29sLm1vY2t0b29sIGltcG9ydCBNb2NrRXhlY3V0aXZlLCBN b2NrT3B0aW9ucywgTW9ja1VzZXIKK2Zyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5maWxlc3lz dGVtX21vY2sgaW1wb3J0IE1vY2tGaWxlU3lzdGVtCiAKIAogY2xhc3MgVGVzdFdlYktpdFBvcnQo V2ViS2l0UG9ydCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIHN5bWJvbF9saXN0PU5vbmUsIGZl YXR1cmVfbGlzdD1Ob25lLAotICAgICAgICAgICAgICAgICBleHBlY3RhdGlvbnNfZmlsZT1Ob25l LCBza2lwc19maWxlPU5vbmUsCi0gICAgICAgICAgICAgICAgIGV4ZWN1dGl2ZT1Ob25lLCAqKmt3 YXJncyk6CisgICAgICAgICAgICAgICAgIGV4ZWN1dGl2ZT1Ob25lLCBmaWxlc3lzdGVtPU5vbmUs ICoqa3dhcmdzKToKICAgICAgICAgc2VsZi5zeW1ib2xfbGlzdCA9IHN5bWJvbF9saXN0CiAgICAg ICAgIHNlbGYuZmVhdHVyZV9saXN0ID0gZmVhdHVyZV9saXN0Ci0gICAgICAgIHNlbGYuZXhwZWN0 YXRpb25zX2ZpbGUgPSBleHBlY3RhdGlvbnNfZmlsZQotICAgICAgICBzZWxmLnNraXBzX2ZpbGUg PSBza2lwc19maWxlCiAgICAgICAgIGV4ZWN1dGl2ZSA9IGV4ZWN1dGl2ZSBvciBNb2NrRXhlY3V0 aXZlKHNob3VsZF9sb2c9RmFsc2UpCi0gICAgICAgIFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwg ZXhlY3V0aXZlPWV4ZWN1dGl2ZSwgKiprd2FyZ3MpCisgICAgICAgIGZpbGVzeXN0ZW0gPSBmaWxl c3lzdGVtIG9yIE1vY2tGaWxlU3lzdGVtKCkKKyAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhz ZWxmLCBwb3J0X25hbWU9InRlc3QiLCBleGVjdXRpdmU9ZXhlY3V0aXZlLCB1c2VyPU1vY2tVc2Vy KCksIGZpbGVzeXN0ZW09ZmlsZXN5c3RlbSwgKiprd2FyZ3MpCiAKICAgICBkZWYgX3J1bnRpbWVf ZmVhdHVyZV9saXN0KHNlbGYpOgogICAgICAgICByZXR1cm4gc2VsZi5mZWF0dXJlX2xpc3QKQEAg LTYwLDE2ICs1OCw2IEBAIGNsYXNzIFRlc3RXZWJLaXRQb3J0KFdlYktpdFBvcnQpOgogICAgIGRl ZiBfdGVzdHNfZm9yX2Rpc2FibGVkX2ZlYXR1cmVzKHNlbGYpOgogICAgICAgICByZXR1cm4gWyJh Y2Nlc3NpYmlsaXR5IiwgXQogCi0gICAgZGVmIHBhdGhfdG9fdGVzdF9leHBlY3RhdGlvbnNfZmls ZShzZWxmKToKLSAgICAgICAgaWYgc2VsZi5leHBlY3RhdGlvbnNfZmlsZToKLSAgICAgICAgICAg IHJldHVybiBzZWxmLmV4cGVjdGF0aW9uc19maWxlCi0gICAgICAgIHJldHVybiBXZWJLaXRQb3J0 LnBhdGhfdG9fdGVzdF9leHBlY3RhdGlvbnNfZmlsZShzZWxmKQotCi0gICAgZGVmIF9za2lwcGVk X2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgIGlmIHNlbGYuc2tpcHNfZmlsZToKLSAgICAgICAg ICAgIHJldHVybiBbc2VsZi5za2lwc19maWxlXQotICAgICAgICByZXR1cm4gW10KLQogCiBjbGFz cyBXZWJLaXRQb3J0VGVzdChwb3J0X3Rlc3RjYXNlLlBvcnRUZXN0Q2FzZSk6CiAgICAgZGVmIHBv cnRfbWFrZXIoc2VsZiwgcGxhdGZvcm0pOgpAQCAtOTksMTYgKzg3LDIzIEBAIGNsYXNzIFdlYktp dFBvcnRUZXN0KHBvcnRfdGVzdGNhc2UuUG9ydFRlc3RDYXNlKToKICAgICBkZWYgdGVzdF9za2lw cGVkX2xheW91dF90ZXN0cyhzZWxmKToKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChUZXN0V2Vi S2l0UG9ydChOb25lLCBOb25lKS5za2lwcGVkX2xheW91dF90ZXN0cygpLCBzZXQoWyJtZWRpYSJd KSkKIAorICAgIGRlZiB0ZXN0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZik6CisgICAg ICAgIHBvcnQgPSBUZXN0V2ViS2l0UG9ydCgpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9y dC5fc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygpLCBzZXQoWyd0ZXN0J10pKQorICAgICAgICBw b3J0Ll9uYW1lID0gInRlc3QtdmVyc2lvbiIKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChwb3J0 Ll9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCksIHNldChbJ3Rlc3QnLCAndGVzdC12ZXJzaW9u J10pKQorICAgICAgICBwb3J0Ll9vcHRpb25zID0gTW9ja09wdGlvbnMod2Via2l0X3Rlc3RfcnVu bmVyPVRydWUpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9ydC5fc2tpcHBlZF9maWxlX3Nl YXJjaF9wYXRocygpLCBzZXQoWyd0ZXN0JywgJ3Rlc3QtdmVyc2lvbicsICd0ZXN0LXdrMicsICdt YWMtd2syJ10pKQorCiAgICAgZGVmIHRlc3RfdGVzdF9leHBlY3RhdGlvbnMoc2VsZik6CiAgICAg ICAgICMgQ2hlY2sgdGhhdCB3ZSByZWFkIGJvdGggdGhlIGV4cGVjdGF0aW9ucyBmaWxlIGFuZCBh bnl0aGluZyBpbiBhCiAgICAgICAgICMgU2tpcHBlZCBmaWxlLCBhbmQgdGhhdCB3ZSBpbmNsdWRl IHRoZSBmZWF0dXJlIGFuZCBwbGF0Zm9ybSBjaGVja3MuCiAgICAgICAgIGZpbGVzID0gewotICAg ICAgICAgICAgJy90bXAvdGVzdF9leHBlY3RhdGlvbnMudHh0JzogJ0JVR19URVNURVhQRUNUQVRJ T05TIFNLSVAgOiBmYXN0L2h0bWwvYXJ0aWNsZS1lbGVtZW50Lmh0bWwgPSBGQUlMXG4nLAotICAg ICAgICAgICAgJy90bXAvU2tpcHBlZCc6ICdmYXN0L2h0bWwva2V5Z2VuLmh0bWwnLAorICAgICAg ICAgICAgJy9tb2NrL0xheW91dFRlc3RzL3BsYXRmb3JtL3Rlc3QvdGVzdF9leHBlY3RhdGlvbnMu dHh0JzogJ0JVR19URVNURVhQRUNUQVRJT05TIFNLSVAgOiBmYXN0L2h0bWwvYXJ0aWNsZS1lbGVt ZW50Lmh0bWwgPSBGQUlMXG4nLAorICAgICAgICAgICAgJy9tb2NrL0xheW91dFRlc3RzL3BsYXRm b3JtL3Rlc3QvU2tpcHBlZCc6ICdmYXN0L2h0bWwva2V5Z2VuLmh0bWwnLAogICAgICAgICB9CiAg ICAgICAgIG1vY2tfZnMgPSBmaWxlc3lzdGVtX21vY2suTW9ja0ZpbGVTeXN0ZW0oZmlsZXMpCi0g ICAgICAgIHBvcnQgPSBUZXN0V2ViS2l0UG9ydChleHBlY3RhdGlvbnNfZmlsZT0nL3RtcC90ZXN0 X2V4cGVjdGF0aW9ucy50eHQnLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2tpcHNf ZmlsZT0nL3RtcC9Ta2lwcGVkJywgZmlsZXN5c3RlbT1tb2NrX2ZzKQorICAgICAgICBwb3J0ID0g VGVzdFdlYktpdFBvcnQoZmlsZXN5c3RlbT1tb2NrX2ZzKQogICAgICAgICBzZWxmLmFzc2VydEVx dWFsKHBvcnQudGVzdF9leHBlY3RhdGlvbnMoKSwKICAgICAgICAgIiIiQlVHX1RFU1RFWFBFQ1RB VElPTlMgU0tJUCA6IGZhc3QvaHRtbC9hcnRpY2xlLWVsZW1lbnQuaHRtbCA9IEZBSUwKIEJVR19T S0lQUEVEIFNLSVAgOiBmYXN0L2h0bWwva2V5Z2VuLmh0bWwgPSBGQUlMCmRpZmYgLS1naXQgYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIv VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQpp bmRleCAyZGZiYjhlYzk5MmI3NTAxNmE5MWZmZWU0ZmY3NjI4ZmJhZDMzNWUyLi5jNDJiMGYyMTll MmIyNDMyZWQ1OGY2ZmI2NjA0YWM5MDA2YWIzOTkwIDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTI2OCw3 ICsyNjgsNyBAQCBkZWYgcGFyc2VfYXJncyhhcmdzPU5vbmUpOgogICAgICAgICBvcHRwYXJzZS5t YWtlX29wdGlvbigiLS1jb21wbGV4LXRleHQiLCBhY3Rpb249InN0b3JlX3RydWUiLCBkZWZhdWx0 PUZhbHNlLAogICAgICAgICAgICAgaGVscD0iVXNlIHRoZSBjb21wbGV4IHRleHQgY29kZSBwYXRo IGZvciBhbGwgdGV4dCAoTWFjIE9TIFggYW5kIFdpbmRvd3Mgb25seSkiKSwKICAgICAgICAgb3B0 cGFyc2UubWFrZV9vcHRpb24oIi0tdGhyZWFkZWQiLCBhY3Rpb249InN0b3JlX3RydWUiLCBkZWZh dWx0PUZhbHNlLAotICAgICAgICAgICAgaGVscD0iUnVuIGEgY29uY3VycmVudCBKYXZhU2NyaXB0 IHRoZWFkIHdpdGggZWFjaCB0ZXN0IiksCisgICAgICAgICAgICBoZWxwPSJSdW4gYSBjb25jdXJy ZW50IEphdmFTY3JpcHQgdGhyZWFkIHdpdGggZWFjaCB0ZXN0IiksCiAgICAgICAgIG9wdHBhcnNl Lm1ha2Vfb3B0aW9uKCItLXdlYmtpdC10ZXN0LXJ1bm5lciIsICItMiIsIGFjdGlvbj0ic3RvcmVf dHJ1ZSIsCiAgICAgICAgICAgICBoZWxwPSJVc2UgV2ViS2l0VGVzdFJ1bm5lciByYXRoZXIgdGhh biBEdW1wUmVuZGVyVHJlZS4iKSwKICAgICBdCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L3Rvb2wvY29tbWFuZHMvcmViYXNlbGluZS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5CmluZGV4IDM0YTM5OGE4NzU4NzA4NTcyMWRh MGQ2NTFhMDM4ZWZmYjcxYzU1YTYuLjAzNmQ4MmIwMDkxZjYwYzRiNjI4MzFkMDg0ZmY1YzUwNWNm Y2FiMmMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9y ZWJhc2VsaW5lLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9y ZWJhc2VsaW5lLnB5CkBAIC00Niw3ICs0Niw2IEBAIGNsYXNzIEJ1aWxkZXJUb1BvcnQob2JqZWN0 KToKICAgICBfYnVpbGRlcl9uYW1lX3RvX3BvcnRfbmFtZSA9IHsKICAgICAgICAgciJTbm93TGVv cGFyZCI6ICJtYWMtc25vd2xlb3BhcmQiLAogICAgICAgICByIkxlb3BhcmQiOiAibWFjLWxlb3Bh cmQiLAotICAgICAgICByIlRpZ2VyIjogIm1hYy10aWdlciIsCiAgICAgICAgIHIiV2luZG93cyI6 ICJ3aW4iLAogICAgICAgICByIkdUSyI6ICJndGsiLAogICAgICAgICByIlF0IjogInF0IiwKZGlm ZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5l c2VydmVyX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRz L3JlYmFzZWxpbmVzZXJ2ZXJfdW5pdHRlc3QucHkKaW5kZXggZjQzNzFmNGMxY2IxNzRmYThlNzc1 ZWQyNmNiYzBlYTc0OTI3MzMwNy4uNTdkYTBmODc2MzRiZjM4NGNlMzAzNzcyNTI0YjkxMDc5OTRl MjgzYSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3Jl YmFzZWxpbmVzZXJ2ZXJfdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL2NvbW1hbmRzL3JlYmFzZWxpbmVzZXJ2ZXJfdW5pdHRlc3QucHkKQEAgLTI3NCwxMyArMjc0 LDEzIEBAIGNsYXNzIEdldEJhc2VsaW5lc1Rlc3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAg ICAgICAgZXhwZWN0ZWRfYmFzZWxpbmVzPXsnYmFzZSc6IHsnLnR4dCc6IFRydWV9fSkKIAogICAg IGRlZiBfYXNzZXJ0QmFzZWxpbmVzKHNlbGYsIHRlc3RfZmlsZXMsIHRlc3RfbmFtZSwgZXhwZWN0 ZWRfYmFzZWxpbmVzKToKLSAgICAgICAgYWN0dWFsX2Jhc2VsaW5lcyA9IHJlYmFzZWxpbmVzZXJ2 ZXIuX2dldF90ZXN0X2Jhc2VsaW5lcygKLSAgICAgICAgICAgIHRlc3RfbmFtZSwgZ2V0X3Rlc3Rf Y29uZmlnKHRlc3RfZmlsZXMpKQorICAgICAgICBhY3R1YWxfYmFzZWxpbmVzID0gcmViYXNlbGlu ZXNlcnZlci5fZ2V0X3Rlc3RfYmFzZWxpbmVzKHRlc3RfbmFtZSwgZ2V0X3Rlc3RfY29uZmlnKHRl c3RfZmlsZXMpKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX2Jhc2VsaW5lcywg YWN0dWFsX2Jhc2VsaW5lcykKIAogCiBkZWYgZ2V0X3Rlc3RfY29uZmlnKHRlc3RfZmlsZXM9W10s IHJlc3VsdF9maWxlcz1bXSk6Ci0gICAgbGF5b3V0X3Rlc3RzX2RpcmVjdG9yeSA9IGJhc2UuUG9y dCgpLmxheW91dF90ZXN0c19kaXIoKQorICAgICMgV2UgY291bGQgZ3JhYiB0aGlzIGZyb20gcG9y dC5sYXlvdXRfdGVzdHNfZGlyKCksIGJ1dCBpbnN0YW50aWF0aW5nIGEgZnVsbHkgbW9ja2VkIHBv cnQgaXMgYSBwYWluLgorICAgIGxheW91dF90ZXN0c19kaXJlY3RvcnkgPSAiL21vY2svTGF5b3V0 VGVzdHMiCiAgICAgcmVzdWx0c19kaXJlY3RvcnkgPSAnL1dlYktpdEJ1aWxkL0RlYnVnL2xheW91 dC10ZXN0LXJlc3VsdHMnCiAgICAgbW9ja19maWxlc3lzdGVtID0gZmlsZXN5c3RlbV9tb2NrLk1v Y2tGaWxlU3lzdGVtKCkKICAgICBmb3IgZmlsZSBpbiB0ZXN0X2ZpbGVzOgpAQCAtMjkyLDYgKzI5 Miw3IEBAIGRlZiBnZXRfdGVzdF9jb25maWcodGVzdF9maWxlcz1bXSwgcmVzdWx0X2ZpbGVzPVtd KToKIAogICAgIGNsYXNzIFRlc3RNYWNQb3J0KFdlYktpdFBvcnQpOgogICAgICAgICBkZWYgX19p bml0X18oc2VsZik6CisgICAgICAgICAgICAjIEZJWE1FOiBUaGlzIHNob3VsZCB1c2UgTW9ja0V4 ZWN1dGl2ZSBhbmQgTW9ja1VzZXIgYXMgd2VsbC4KICAgICAgICAgICAgIFdlYktpdFBvcnQuX19p bml0X18oc2VsZiwgZmlsZXN5c3RlbT1tb2NrX2ZpbGVzeXN0ZW0pCiAgICAgICAgICAgICBzZWxm Ll9uYW1lID0gJ21hYycKIAo= 98992 2011-06-28 16:15:46 -0700 2011-06-29 15:10:48 -0700 Slightly smaller patch bug-63501-20110628161545.patch text/plain 33989 eric U3VidmVyc2lvbiBSZXZpc2lvbjogODk5NzIKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCBlZTI5MjU4N2Q2ZTgwZjAwYzE5MWEyZDI2MjMzMWNiMmMx MzVkYTQyLi42YmFmMGI1MTAzNmMwMGExYzdlMzkxNjg4YjI0Y2ZjMjM5MTgyNmY5IDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzcg QEAKKzIwMTEtMDYtMjcgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNpbXBsaWZ5IHNraXBwZWQg ZmlsZSBmaW5kaW5nIGluIHByZXBhcmF0aW9uIGZvciBhZGRpbmcgd2syIHNraXBwZWQgbGlzdCBm YWxsYmFjaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjM1MDEKKworICAgICAgICBUaGUgZ29hbCB3YXMgdG8gYWRkIHN1cHBvcnQgZm9yIHdrMiBza2lw cGVkIGxpc3RzLgorICAgICAgICBIb3dldmVyLCBJIGZvdW5kIHRoYXQgb3VyIHNraXBwZWQgbGlz dCBjb21wdXRhdGlvbiB3YXMgYQorICAgICAgICBtYW51YWwgaGFjayAod2hpY2ggb25seSB3b3Jr ZWQgZm9yIHRoZSBtYWMgcG9ydCkuCisKKyAgICAgICAgU28gSSBmaXhlZCBhIEZJWE1FIHRvIG1v dmUgdGhlIHNraXBwZWQgbGlzdCBmaW5kaW5nCisgICAgICAgIGludG8gV2ViS2l0UG9ydCBpbnN0 ZWFkIG9mIE1hY1BvcnQuCisgICAgICAgIERvaW5nIHNvIHJlcXVpcmVkIGFkZGluZyBhIHBvcnRf bmFtZSgpIGFjY2Vzc29yIGFuZAorICAgICAgICB1bnRhbmdsaW5nIHRoZSBtZXNzIHRoYXQgaXMg b3VyIHBvcnRfbmFtZSBhcmd1bWVudCAicGFyc2luZyIuCisKKyAgICAgICAgKE91ciBjdXJyZW50 IHN5c3RlbSBvZiBzb21ldGltZXMgcGFzc2luZyAiY2hyb21pdW0tbWFjIiBhbmQKKyAgICAgICAg c29tZXRpbWVzICJjaHJvbWl1bS1tYWMtbGVvcGFyZCIgb3Igd29yc2UgImNocm9taXVtLWdwdS1t YWMtbGVvcGFyZCIKKyAgICAgICAgYXMgdGhlIHBvcnRfbmFtZSBhcmd1bWVudCBhbmQgZXhwZWN0 aW5nIFdlYktpdFBvcnQoKSB0byBkbyB0aGUgcmlnaHQKKyAgICAgICAgdGhpbmcgaXMgYWJzdXJk LikKKworICAgICAgICBJIGFkZGVkIGEgbmV3IF9wYXJzZV9wb3J0X25hbWUgbWV0aG9kIHRvIGhh bmRsZSB0aGUgdmFyaW91cworICAgICAgICBwb3NzaWJsZSBwb3J0X25hbWUgdmFsdWVzLiAgTm93 IHRoYXQgd2UgaGF2ZSBhIHNoYXJlZCBtZXRob2QKKyAgICAgICAgd2UgY291bGQgcHJvYmFibHkg anVzdCBjYWxsIF9wYXJzZV9wb3J0X25hbWUoKSBmcm9tIHRoZQorICAgICAgICBXZWJLaXRQb3J0 IGNvbnN0cnVjdG9yIGFuZCBnZXQgcmlkIG9mIG1hbnkgb2YgdGhlIHN1YmNsYXNzIGNvbnN0cnVj dG9ycy4KKworICAgICAgICBJbiBvcmRlciB0byB0ZXN0IG15IG5ldyBfc2tpcHBlZF9maWxlX3Nl YXJjaF9wYXRocyBtZXRob2QsIEkKKyAgICAgICAgZml4ZWQgYW5vdGhlciBGSVhNRSBieSBtYWtp bmcgaXQgcmV0dXJuIHJlbGF0aXZlIHBhdGhzLiAgSG93ZXZlcgorICAgICAgICBpbiBkb2luZyBz byBJIGZvdW5kIHRoYXQgdGhlIFRlc3RXZWJLaXRQb3J0IHdlIHdlcmUgdXNpbmcgaW4KKyAgICAg ICAgd2Via2l0X3VuaXR0ZXN0LnB5IHdhcyBhY2Nlc3NpbmcgdGhlIHJlYWwgZmlsZXN5c3RlbSB0 aHJvdWdoIHRoZSB1c2UKKyAgICAgICAgb2YgdGhlIF9fZmlsZV9fIHZhcmlhYmxlLgorCisgICAg ICAgIFNvIHRvIGZpeCB0aGF0LCBJIGFkZGVkIGEgcGF0aF9mb3JfbW9kdWxlIGFic3RyYWN0aW9u IG9udG8gZmlsZXN5c3RlbS5weS4KKworICAgICAgICBJIG9mIGNvdXJzZSByZW1vdmVkIHNvbWUg cmVkdW5kYW50IGRvY3N0cmluZ3MgYW5kIG1vdmVkIGFic29sdXRlCisgICAgICAgIG1vZHVsZSBu YW1lcyB0byBfX2ZpbGVfXyBhbG9uZyB0aGUgd2F5LgorCisgICAgICAgIEkgYWxzbyBmaXhlZCB0 aGUgdGVzdF9leHBlY3RhdGlvbnNfcGF0aCBjb2RlIGluIFdlYktpdFBvcnQgdG8gdXNlIHBvcnRf bmFtZSgpLgorICAgICAgICBJdCB3YXMgdXNpbmcgbmFtZSgpIHdoaWNoIHdvdWxkIHJldHVybiBQ T1JULVZFUlNJT04gc28gTWFjUG9ydCB3YXMgb3ZlcnJpZGluZworICAgICAgICBpdCB0byB1c2Ug anVzdCBQT1JULiAgQWZ0ZXIgZml4aW5nIHRlc3RfZXhwZWN0YXRpb25zX3BhdGggdG8gdXNlIHBv cnRfbmFtZSgpCisgICAgICAgIChhbmQgbWFraW5nIGl0IGF3YXJlIG9mIHdlYmtpdDIpIEkgd2Fz IGFibGUgdG8gcmVtb3ZlIHRoZSBNYWNQb3J0IGltcGxlbWVudGF0aW9uLgorCisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weTogInRoZWFkIiAtPiAi dGhyZWFkIgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9maWxlc3lz dGVtLnB5OgorICAgICAgICAgLSBUaGlzIGNhbiBiZSB1c2VkIHRvIHdyYXAgYWxsIGNhbGxzIHRv IF9fZmlsZV9fIHRvIG1ha2UgdGhlbSB1bml0LXRlc3QgZnJpZW5kbHkuCisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW1fbW9jay5weToKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHk6CisgICAgICAgICAt IEFkZCBwb3J0X25hbWUoKSB0byBhY2Nlc3MgIm1hYyIsIHNpbmNlIG5hbWUoKSByZXR1cm5zICJt YWMtbGVvcGFyZCIgZXRjLgorICAgICAgICAgLSBEb2N1bWVudCB0aGF0IHJlYWxfbmFtZSgpIHNl ZW1zIHRvIGhhdmUgbm8gcHVycG9zZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2J1aWxkZXJzLnB5OgorICAgICAgICAgLSBSZW1vdmUgdGlnZXIgc3VwcG9y dCwgd2Via2l0IG5vIGxvbmdlciBzdXBwb3J0cyB0aWdlci4KKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5OgorICAgICAgICAgLSBB ZGQgX3BhcnNlX3BvcnRfbmFtZSgpLCBldmVudHVhbGx5IHdlIG1pZ2h0IGNhbGwgdGhpcyBmcm9t IFdlYktpdFBvcnQgZGlyZWN0bHkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHk6CisgICAgICAgICAtIEFkZCBfcGFyc2VfcG9ydF9u YW1lLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21p dW1fd2luLnB5OgorICAgICAgICAgLSBBZGQgX3BhcnNlX3BvcnRfbmFtZS4KKyAgICAgICAgKiBT Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2NvbmZpZy5weToKKyAgICAgICAgIC0g VXNlIHRoZSBuZXcgcGF0aF90b19tb2R1bGUgYWJzdHJhY3Rpb24gaW5zdGVhZCBvZiBfX2ZpbGVf XyB0byBtYWtlIGl0CisgICAgICAgICAgIGVhc2llciB0byB1bml0dGVzdCBjb25maWcucHkgY29k ZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weToK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hYy5weToKKyAg ICAgICAgIC0gTW92ZSBTa2lwcGVkLWZpbGUgZmluZGluZyBjb2RlIGRvd24gdG8gV2ViS2l0UG9y dAorICAgICAgICAgLSBSZW1vdmUgdGlnZXIgc3VwcG9ydC4KKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weToKKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5OgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5OgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5OgorICAgICAgICAg LSBUZXN0V2ViS2l0UG9ydCBpcyBtdWNoIGVhc2llciB0byB3cml0ZSBub3cgdGhhdCBjb25maWcu cHkgbmV2ZXIgYmxlZWRzCisgICAgICAgICAgIGFic29sdXRlIHBhdGhzLgorICAgICAgICAgLSBQ YXNzIE1vY2tVc2VyIGFuZCBNb2NrRmlsZVN5c3RlbSBieSBkZWZhdWx0IHRvIHByZXZlbnQgVGVz dFdlYktpdFBvcnQgZnJvbSBsZWFraW5nIHN5c3RlbSBkYXRhIHRvIHVuaXR0ZXN0IHJlc3VsdHMu CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0 cy5weTogInRoZWFkIiAtPiAidGhyZWFkIgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9v bC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5OiBUaWdlciBpcyBkZWFkLgorCiAyMDExLTA2LTI3ICBE aWVnbyBHb256YWxleiAgPGRpZWdvaGNnQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgS2VubmV0aCBSb2hkZSBDaHJpc3RpYW5zZW4uCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmlsZXN5c3RlbS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvY29tbW9uL3N5c3RlbS9maWxlc3lzdGVtLnB5CmluZGV4IGU3YzA2OGE5YWQ4NDZiNDZi Y2U3NTk0ODk4YmNlN2Q5ZDkyMzk0YTEuLjM2NTEyNjA2MzI4ODViZTFmOWJlMjI4YTQ0MjFlMTk1 MWQzMzQ3Y2UgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3Rl bS9maWxlc3lzdGVtLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3Rl bS9maWxlc3lzdGVtLnB5CkBAIC01Nyw2ICs1NywxMSBAQCBjbGFzcyBGaWxlU3lzdGVtKG9iamVj dCk6CiAgICAgZGVmIGFic3BhdGgoc2VsZiwgcGF0aCk6CiAgICAgICAgIHJldHVybiBvcy5wYXRo LmFic3BhdGgocGF0aCkKIAorICAgIGRlZiBwYXRoX3RvX21vZHVsZShzZWxmLCBtb2R1bGVfbmFt ZSk6CisgICAgICAgICIiIkEgd3JhcHBlciBmb3IgYWxsIGNhbGxzIHRvIF9fZmlsZV9fIHRvIGFs bG93IGVhc3kgdW5pdCB0ZXN0aW5nLiIiIgorICAgICAgICBpbXBvcnQgc3lzCisgICAgICAgIHJl dHVybiBzeXMubW9kdWxlc1ttb2R1bGVfbmFtZV0uX19maWxlX18KKwogICAgIGRlZiBleHBhbmR1 c2VyKHNlbGYsIHBhdGgpOgogICAgICAgICByZXR1cm4gb3MucGF0aC5leHBhbmR1c2VyKHBhdGgp CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9maWxl c3lzdGVtX21vY2sucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9zeXN0ZW0vZmls ZXN5c3RlbV9tb2NrLnB5CmluZGV4IDIwNDQ2OGY1ZDc1YmZhMDdmMjQ0YTUzMmI2MmJmZGE0YTE0 Zjk4MmUuLjZlYjk1OGExNWY3OGYxNDc2MWRkZThjYjFjZWRlZGFkMWI3ODYyNDcgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9maWxlc3lzdGVtX21vY2su cHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW1f bW9jay5weQpAQCAtNzksNiArNzksOSBAQCBjbGFzcyBNb2NrRmlsZVN5c3RlbShvYmplY3QpOgog ICAgICAgICAgICAgcmV0dXJuIGhvbWVfZGlyZWN0b3J5CiAgICAgICAgIHJldHVybiBob21lX2Rp cmVjdG9yeSArIHNlbGYuc2VwICsgcGFydHNbMV0KIAorICAgIGRlZiBwYXRoX3RvX21vZHVsZShz ZWxmLCBtb2R1bGVfbmFtZSk6CisgICAgICAgIHJldHVybiAiL21vY2svVG9vbHMvU2NyaXB0cy93 ZWJraXRweS8lcyIgJSBtb2R1bGVfbmFtZQorCiAgICAgZGVmIGNoZGlyKHNlbGYsIHBhdGgpOgog ICAgICAgICBwYXRoID0gc2VsZi5ub3JtcGF0aChwYXRoKQogICAgICAgICBpZiBub3Qgc2VsZi5p c2RpcihwYXRoKToKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvYmFzZS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvYmFzZS5weQppbmRleCBmYWJjZjYxNjgzMDgzYjA4ZWM2MDVhMTlmMWZmMDhlN2M0MDNlMDc1 Li5mMWM4NTE4ZjgyZjUzYjY1ZTc0N2M0ZWEzNzM1MzNmOGQ1MWE3OWM3IDEwMDc1NQotLS0gYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CkBAIC05MSwxMCAr OTEsMTEgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICAgICAgICAgICBmaWxlc3lzdGVt PU5vbmUsCiAgICAgICAgICAgICAgICAgIGNvbmZpZz1Ob25lLAogICAgICAgICAgICAgICAgICAq Kmt3YXJncyk6Ci0gICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUKKyAgICAgICAgc2VsZi5f cG9ydF9uYW1lID0gcG9ydF9uYW1lCiAKICAgICAgICAgIyBUaGVzZSBhcmUgZGVmYXVsdCB2YWx1 ZXMgdGhhdCBzaG91bGQgYmUgb3ZlcnJpZGRlbiBpbiBhIHN1YmNsYXNzZXMuCiAgICAgICAgICMg RklYTUU6IFRoZXNlIHNob3VsZCByZWFsbHkgYmUgcGFzc2VkIGluLgorICAgICAgICBzZWxmLl9u YW1lID0gcG9ydF9uYW1lICAjIFN1YmNsYXNzZXMgbWF5IGFwcGVuZCBhIC1WRVJTSU9OIChsaWtl IG1hYy1sZW9wYXJkKS4KICAgICAgICAgc2VsZi5fb3BlcmF0aW5nX3N5c3RlbSA9ICdtYWMnCiAg ICAgICAgIHNlbGYuX3ZlcnNpb24gPSAnJwogICAgICAgICBzZWxmLl9hcmNoaXRlY3R1cmUgPSAn eDg2JwpAQCAtMTYzLDEwICsxNjQsOCBAQCBjbGFzcyBQb3J0KG9iamVjdCk6CiAgICAgICAgIHJl dHVybiAndGhyZWFkcycKIAogICAgIGRlZiBiYXNlbGluZV9wYXRoKHNlbGYpOgotICAgICAgICAi IiJSZXR1cm4gdGhlIGFic29sdXRlIHBhdGggdG8gdGhlIGRpcmVjdG9yeSB0byBzdG9yZSBuZXcg YmFzZWxpbmVzCi0gICAgICAgIGluIGZvciB0aGlzIHBvcnQuIiIiCi0gICAgICAgIGJhc2VsaW5l X3NlYXJjaF9wYXRocyA9IFwKLSAgICAgICAgICAgIHNlbGYuZ2V0X29wdGlvbignYWRkaXRpb25h bF9wbGF0Zm9ybV9kaXJlY3RvcnknLCBbXSkgKyBzZWxmLmJhc2VsaW5lX3NlYXJjaF9wYXRoKCkK KyAgICAgICAgIiIiUmV0dXJuIHRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSBkaXJlY3RvcnkgdG8g c3RvcmUgbmV3IGJhc2VsaW5lcyBpbiBmb3IgdGhpcyBwb3J0LiIiIgorICAgICAgICBiYXNlbGlu ZV9zZWFyY2hfcGF0aHMgPSBzZWxmLmdldF9vcHRpb24oJ2FkZGl0aW9uYWxfcGxhdGZvcm1fZGly ZWN0b3J5JywgW10pICsgc2VsZi5iYXNlbGluZV9zZWFyY2hfcGF0aCgpCiAgICAgICAgIHJldHVy biBiYXNlbGluZV9zZWFyY2hfcGF0aHNbMF0KIAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0 aChzZWxmKToKQEAgLTUzOCwxMCArNTM3LDIwIEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAg ICAgIiIiQ3JlYXRlcyB0aGUgc3BlY2lmaWVkIGRpcmVjdG9yeSBpZiBpdCBkb2Vzbid0IGFscmVh ZHkgZXhpc3QuIiIiCiAgICAgICAgIHNlbGYuX2ZpbGVzeXN0ZW0ubWF5YmVfbWFrZV9kaXJlY3Rv cnkoKnBhdGgpCiAKKyAgICBkZWYgcG9ydF9uYW1lKHNlbGYpOgorICAgICAgICAiIiJUaGUgYmFz ZSBuYW1lIG9mIHRoZSBwb3J0LCBub3QgaW5jbHVkaW5nIHZlcnNpb24gaW5mb3JtYXRpb24uIiIi CisgICAgICAgIHJldHVybiBzZWxmLl9wb3J0X25hbWUKKwogICAgIGRlZiBuYW1lKHNlbGYpOgot ICAgICAgICAiIiJSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIHBvcnQgKGUuZy4sICdtYWMnLCAnY2hy b21pdW0td2luLXhwJykuIiIiCisgICAgICAgICIiIlJldHVybiB0aGUgZnVsbCBuYW1lIG9mIHRo ZSBwb3J0IChlLmcuLCAnbWFjJywgJ2Nocm9taXVtLXdpbi14cCcpLCBpbmNsdWRpbmcgdmVyc2lv bi4iIiIKKyAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQgYmUgcmVwbGFjZWQgYnkgInJldHVy biAiJXMtJXMiIChzZWxmLnBvcnRfbmFtZSgpLCBzZWxmLnZlcnNpb24oKSkiCiAgICAgICAgIHJl dHVybiBzZWxmLl9uYW1lCiAKKyAgICBkZWYgcmVhbF9uYW1lKHNlbGYpOgorICAgICAgICAjIEZJ WE1FOiBTZWVtcyB0aGlzIGlzIG9ubHkgdXNlZCBmb3IgTW9ja0RSVCBhbmQgc2hvdWxkIGJlIHJl bW92ZWQuCisgICAgICAgICIiIlJldHVybnMgdGhlIGFjdHVhbCBuYW1lIG9mIHRoZSBwb3J0LCBu b3QgdGhlIGRlbGVnYXRlJ3MuIiIiCisgICAgICAgIHJldHVybiBzZWxmLm5hbWUoKQorCiAgICAg ZGVmIG9wZXJhdGluZ19zeXN0ZW0oc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9vcGVyYXRp bmdfc3lzdGVtCiAKQEAgLTU2OCwxMCArNTc3LDYgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAg IGRlZiBhcmNoaXRlY3R1cmUoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9hcmNoaXRlY3R1 cmUKIAotICAgIGRlZiByZWFsX25hbWUoc2VsZik6Ci0gICAgICAgICIiIlJldHVybnMgdGhlIGFj dHVhbCBuYW1lIG9mIHRoZSBwb3J0LCBub3QgdGhlIGRlbGVnYXRlJ3MuIiIiCi0gICAgICAgIHJl dHVybiBzZWxmLm5hbWUoKQotCiAgICAgZGVmIGdldF9vcHRpb24oc2VsZiwgbmFtZSwgZGVmYXVs dF92YWx1ZT1Ob25lKToKICAgICAgICAgIyBGSVhNRTogRXZlbnR1YWxseSB3ZSBzaG91bGQgbm90 IGhhdmUgdG8gZG8gYSB0ZXN0IGZvcgogICAgICAgICAjIGhhc2F0dHIoKSwgYW5kIHdlIHNob3Vs ZCBiZSBhYmxlIHRvIGp1c3QgZG8KQEAgLTY0MSw4ICs2NDYsNyBAQCBjbGFzcyBQb3J0KG9iamVj dCk6CiAgICAgICAgIHJldHVybiBzZWxmLl91c2VyLm9wZW5fdXJsKHJlc3VsdHNfZmlsZW5hbWUp CiAKICAgICBkZWYgY3JlYXRlX2RyaXZlcihzZWxmLCB3b3JrZXJfbnVtYmVyKToKLSAgICAgICAg IiIiUmV0dXJuIGEgbmV3bHkgY3JlYXRlZCBiYXNlLkRyaXZlciBzdWJjbGFzcyBmb3Igc3RhcnRp bmcvc3RvcHBpbmcKLSAgICAgICAgdGhlIHRlc3QgZHJpdmVyLiIiIgorICAgICAgICAiIiJSZXR1 cm4gYSBuZXdseSBjcmVhdGVkIGJhc2UuRHJpdmVyIHN1YmNsYXNzIGZvciBzdGFydGluZy9zdG9w cGluZyB0aGUgdGVzdCBkcml2ZXIuIiIiCiAgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJy b3IoJ1BvcnQuY3JlYXRlX2RyaXZlcicpCiAKICAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYpOgpA QCAtODc2LDggKzg4MCw3IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgcmFpc2UgTm90 SW1wbGVtZW50ZWRFcnJvcignUG9ydC5fcGF0aF90b19oZWxwZXInKQogCiAgICAgZGVmIF9wYXRo X3RvX2ltYWdlX2RpZmYoc2VsZik6Ci0gICAgICAgICIiIlJldHVybnMgdGhlIGZ1bGwgcGF0aCB0 byB0aGUgaW1hZ2VfZGlmZiBiaW5hcnksIG9yIE5vbmUgaWYgaXQKLSAgICAgICAgaXMgbm90IGF2 YWlsYWJsZS4KKyAgICAgICAgIiIiUmV0dXJucyB0aGUgZnVsbCBwYXRoIHRvIHRoZSBpbWFnZV9k aWZmIGJpbmFyeSwgb3IgTm9uZSBpZiBpdCBpcyBub3QgYXZhaWxhYmxlLgogCiAgICAgICAgIFRo aXMgaXMgbGlrZWx5IHVzZWQgb25seSBieSBkaWZmX2ltYWdlKCkiIiIKICAgICAgICAgcmFpc2Ug Tm90SW1wbGVtZW50ZWRFcnJvcignUG9ydC5wYXRoX3RvX2ltYWdlX2RpZmYnKQpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9saW51 eC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1f bGludXgucHkKaW5kZXggMWViYTI2NjJhMWU1Njg0Nzc2NDczOGUyZTM4NWQwOGE2NWRiNTllNy4u MTIxMTAzNTQyY2FmYTk1NTM1ODliNzllNzcwOWY5ZmVhMGMzYmVlNCAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9saW51eC5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xp bnV4LnB5CkBAIC00NSwxMiArNDUsNyBAQCBjbGFzcyBDaHJvbWl1bUxpbnV4UG9ydChjaHJvbWl1 bS5DaHJvbWl1bVBvcnQpOgogICAgICAgICAneDg2JzogWydjaHJvbWl1bS1saW51eC14ODYnLCAn Y2hyb21pdW0tbGludXgnLCAnY2hyb21pdW0td2luJywgJ2Nocm9taXVtJywgJ3dpbicsICdtYWMn XSwKICAgICB9CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsICoqa3dh cmdzKToKLSAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdjaHJvbWl1bS1saW51eCcK LSAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1w b3J0X25hbWUsICoqa3dhcmdzKQotCi0gICAgICAgICMgV2UgcmUtc2V0IHRoZSBwb3J0IG5hbWUg b25jZSB0aGUgYmFzZSBvYmplY3QgaXMgZnVsbHkgaW5pdGlhbGl6ZWQKLSAgICAgICAgIyBpbiBv cmRlciB0byBiZSBhYmxlIHRvIGZpbmQgdGhlIERSVCBiaW5hcnkgcHJvcGVybHkuCisgICAgZGVm IF9wYXJzZV9wb3J0X25hbWUoc2VsZiwgcG9ydF9uYW1lKToKICAgICAgICAgaWYgcG9ydF9uYW1l LmVuZHN3aXRoKCctbGludXgnKToKICAgICAgICAgICAgIHNlbGYuX2FyY2hpdGVjdHVyZSA9IHNl bGYuX2RldGVybWluZV9hcmNoaXRlY3R1cmUoKQogICAgICAgICAgICAgIyBGSVhNRTogdGhpcyBp cyBhbiB1Z2x5IGhhY2sgdG8gYXZvaWQgcmVuYW1pbmcgdGhlIEdQVSBwb3J0LgpAQCAtNjQsMTAg KzU5LDE4IEBAIGNsYXNzIENocm9taXVtTGludXhQb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6 CiAgICAgICAgIGFzc2VydCBwb3J0X25hbWUgaW4gKCdjaHJvbWl1bS1saW51eCcsICdjaHJvbWl1 bS1ncHUtbGludXgnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnY2hyb21pdW0tbGlu dXgteDg2JywgJ2Nocm9taXVtLWxpbnV4LXg4Nl82NCcsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICdjaHJvbWl1bS1ncHUtbGludXgteDg2XzY0JykKKyAgICAgICAgc2VsZi5fcG9ydF9u YW1lID0gJ2Nocm9taXVtLWxpbnV4JyAgIyBUaGlzIG1heSBiZSB3cm9uZywgYnV0IHNlZW1zIHRv IG1hdGNoIHRoZSAidWdseSBoYWNrIHRvIGF2b2lkIHJlbmFtaW5nIHRoZSBHUFUgcG9ydCIgYWJv dmUuCiAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUKLSAgICAgICAgc2VsZi5fb3BlcmF0 aW5nX3N5c3RlbSA9ICdsaW51eCcKICAgICAgICAgc2VsZi5fdmVyc2lvbiA9ICdsdWNpZCcgICMg V2Ugb25seSBzdXBwb3J0IGx1Y2lkIHJpZ2h0IG5vdy4KIAorICAgIGRlZiBfX2luaXRfXyhzZWxm LCBwb3J0X25hbWU9Tm9uZSwgKiprd2FyZ3MpOgorICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25h bWUgb3IgJ2Nocm9taXVtLWxpbnV4JworICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBvcnQuX19p bml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAgICAgICMgV2Ug cmUtc2V0IHRoZSBwb3J0IG5hbWUgb25jZSB0aGUgYmFzZSBvYmplY3QgaXMgZnVsbHkgaW5pdGlh bGl6ZWQKKyAgICAgICAgIyBpbiBvcmRlciB0byBiZSBhYmxlIHRvIGZpbmQgdGhlIERSVCBiaW5h cnkgcHJvcGVybHkuCisgICAgICAgIHNlbGYuX3BhcnNlX3BvcnRfbmFtZShwb3J0X25hbWUpCisg ICAgICAgIHNlbGYuX29wZXJhdGluZ19zeXN0ZW0gPSAnbGludXgnCisKICAgICBkZWYgX2RldGVy bWluZV9hcmNoaXRlY3R1cmUoc2VsZik6CiAgICAgICAgIGRyaXZlcl9wYXRoID0gc2VsZi5fcGF0 aF90b19kcml2ZXIoKQogICAgICAgICBmaWxlX291dHB1dCA9ICcnCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX21hYy5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5Cmlu ZGV4IGM3ZTk3N2MzNjJmN2JiNjkyY2ZjMmJjOGJjNzdkODllZWQxYWQ1ZDQuLmE3YmNhOGM0ZTE3 YWYxMTE1NjY2ZTkzYjNiZjlhNGE1MjJkMjNjZmUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5CisrKyBiL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5CkBAIC02Nywx NyArNjcsMjIgQEAgY2xhc3MgQ2hyb21pdW1NYWNQb3J0KGNocm9taXVtLkNocm9taXVtUG9ydCk6 CiAgICAgICAgIF0sCiAgICAgfQogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1O b25lLCBvc192ZXJzaW9uX3N0cmluZz1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgICMgV2UncmUg YSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhpcyBjb2RlIGlzIHJldXNlZCBieSB0aGUK LSAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBhcyB3ZWxsIGFzIHRoZSAnbW9jay0nIGFu ZCAnZHJ5cnVuLScgcG9ydHMuCi0gICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZSBvciAnY2hy b21pdW0tbWFjJwotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBvcnQuX19pbml0X18oc2VsZiwg cG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAgIyBGSVhNRTogdmVyc2lvbiwgbmFt ZSwgZXRjLiBzaG91bGQgYmUgcGFzc2VkIHNlcGFyYXRlbHkgYW5kIHdlIHNob3VsZCBub3QgaGF2 ZSB0byBwYXJzZSBwb3J0X25hbWUuCisgICAgZGVmIF9wYXJzZV9wb3J0X25hbWUoc2VsZiwgcG9y dF9uYW1lLCBvc192ZXJzaW9uX3N0cmluZyk6CiAgICAgICAgIGlmIHBvcnRfbmFtZS5lbmRzd2l0 aCgnLW1hYycpOgogICAgICAgICAgICAgc2VsZi5fdmVyc2lvbiA9IG1hYy5vc192ZXJzaW9uKG9z X3ZlcnNpb25fc3RyaW5nLCBzZWxmLlNVUFBPUlRFRF9PU19WRVJTSU9OUykKICAgICAgICAgICAg IHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBzZWxmLl92ZXJzaW9uCiAgICAgICAgIGVs c2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lW3BvcnRfbmFtZS5pbmRl eCgnLW1hYy0nKSArIDU6XQorICAgICAgICAgICAgc2VsZi5fcG9ydF9uYW1lID0gcG9ydF9uYW1l Wzpwb3J0X25hbWUuaW5kZXgoJy1tYWMtJykgKyBsZW4oJy1tYWMnKV0KKyAgICAgICAgICAgIHNl bGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbcG9ydF9uYW1lLmluZGV4KCctbWFjLScpICsgbGVuKCct bWFjLScpOl0KICAgICAgICAgICAgIGFzc2VydCBzZWxmLl92ZXJzaW9uIGluIHNlbGYuU1VQUE9S VEVEX09TX1ZFUlNJT05TCisKKyAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUs IG9zX3ZlcnNpb25fc3RyaW5nPU5vbmUsICoqa3dhcmdzKToKKyAgICAgICAgIyBXZSdyZSBhIGxp dHRsZSBnZW5lcmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUgaXMgcmV1c2VkIGJ5IHRoZQorICAg ICAgICAjICdnb29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwgYXMgdGhlICdtb2NrLScgYW5kICdk cnlydW4tJyBwb3J0cy4KKyAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdjaHJvbWl1 bS1tYWMnCisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0 X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAgICAgc2VsZi5fcGFyc2VfcG9ydF9uYW1l KHBvcnRfbmFtZSwgb3NfdmVyc2lvbl9zdHJpbmcpCiAgICAgICAgIHNlbGYuX29wZXJhdGluZ19z eXN0ZW0gPSAnbWFjJwogCiAgICAgZGVmIGJhc2VsaW5lX3NlYXJjaF9wYXRoKHNlbGYpOgpkaWZm IC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bV93aW4ucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9t aXVtX3dpbi5weQppbmRleCBiOTAzYzNmZTJhMjdlMGYwM2EwOGY3YmVjYWQyYTRhMWZjZDViMjRi Li44ZTU4ZmFiMzY5NWMxOGUxNTc4ODc2ZjNhYWFmNWU4NWNjMWVhNGFkIDEwMDc1NQotLS0gYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dp bi5weQpAQCAtNjUsMTggKzY1LDIyIEBAIGNsYXNzIENocm9taXVtV2luUG9ydChjaHJvbWl1bS5D aHJvbWl1bVBvcnQpOgogICAgICAgICAnd2luNyc6IFsnY2hyb21pdW0td2luJywgJ2Nocm9taXVt JywgJ3dpbicsICdtYWMnXSwKICAgICB9CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9u YW1lPU5vbmUsIHdpbmRvd3NfdmVyc2lvbj1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgICMgV2Un cmUgYSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhpcyBjb2RlIGlzIHJldXNlZCBieSB0 aGUKLSAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBhcyB3ZWxsIGFzIHRoZSAnbW9jay0n IGFuZCAnZHJ5cnVuLScgcG9ydHMuCi0gICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZSBvciAn Y2hyb21pdW0td2luJwotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBvcnQuX19pbml0X18oc2Vs ZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAgIyBGSVhNRTogdmVyc2lvbiwg bmFtZSwgZXRjLiBzaG91bGQgYmUgcGFzc2VkIHNlcGFyYXRlbHkgYW5kIHdlIHNob3VsZCBub3Qg aGF2ZSB0byBwYXJzZSBwb3J0X25hbWUuCisgICAgZGVmIF9wYXJzZV9wb3J0X25hbWUoc2VsZiwg cG9ydF9uYW1lLCB3aW5kb3dzX3ZlcnNpb24pOgogICAgICAgICBpZiBwb3J0X25hbWUuZW5kc3dp dGgoJy13aW4nKToKICAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBvc192ZXJzaW9uKHdpbmRv d3NfdmVyc2lvbikKICAgICAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBz ZWxmLl92ZXJzaW9uCiAgICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0g cG9ydF9uYW1lW3BvcnRfbmFtZS5pbmRleCgnLXdpbi0nKSArIDU6XQotICAgICAgICAgICAgYXNz ZXJ0IHNlbGYuX3ZlcnNpb24gaW4gc2VsZi5TVVBQT1JURURfVkVSU0lPTlMKKyAgICAgICAgICAg IHNlbGYuX3BvcnRfbmFtZSA9IHBvcnRfbmFtZVs6cG9ydF9uYW1lLmluZGV4KCctd2luLScpICsg bGVuKCctd2luJyldCisgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lW3BvcnRf bmFtZS5pbmRleCgnLXdpbi0nKSArIGxlbignLXdpbi0nKTpdCisgICAgICAgICAgICBhc3NlcnQg c2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUywgIiVzIGlzIG5vdCBpbiAl cyIgJSAoc2VsZi5fdmVyc2lvbiwgc2VsZi5TVVBQT1JURURfVkVSU0lPTlMpCiAKKyAgICBkZWYg X19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIHdpbmRvd3NfdmVyc2lvbj1Ob25lLCAqKmt3 YXJncyk6CisgICAgICAgICMgV2UncmUgYSBsaXR0bGUgZ2VuZXJpYyBoZXJlIGJlY2F1c2UgdGhp cyBjb2RlIGlzIHJldXNlZCBieSB0aGUKKyAgICAgICAgIyAnZ29vZ2xlLWNocm9tZScgcG9ydCBh cyB3ZWxsIGFzIHRoZSAnbW9jay0nIGFuZCAnZHJ5cnVuLScgcG9ydHMuCisgICAgICAgIHBvcnRf bmFtZSA9IHBvcnRfbmFtZSBvciAnY2hyb21pdW0td2luJworICAgICAgICBjaHJvbWl1bS5DaHJv bWl1bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisg ICAgICAgIHNlbGYuX3BhcnNlX3BvcnRfbmFtZShwb3J0X25hbWUsIHdpbmRvd3NfdmVyc2lvbikK ICAgICAgICAgc2VsZi5fb3BlcmF0aW5nX3N5c3RlbSA9ICd3aW4nCiAKICAgICBkZWYgc2V0dXBf ZW52aXJvbl9mb3Jfc2VydmVyKHNlbGYpOgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jb25maWcucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L2NvbmZpZy5weQppbmRleCA2NTQ0MTcwZWNlNDdmZGI2OTQwNzQy MTg4YWFmYTcwZDIxNTMyMDQ3Li5kZWJiY2JhNjBmNGJmY2YxZWVkZjBkNmY1MjVmNzgxZWQxYzU4 YzNjIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2NvbmZpZy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0 L2NvbmZpZy5weQpAQCAtMTE4LDcgKzExOCw4IEBAIGNsYXNzIENvbmZpZyhvYmplY3QpOgogICAg ICAgICAjCiAgICAgICAgICMgVGhpcyBjb2RlIHdpbGwgYWxzbyB3b3JrIGlmIHRoZXJlIGlzIG5v IFNDTSBzeXN0ZW0gYXQgYWxsLgogICAgICAgICBpZiBub3Qgc2VsZi5fd2Via2l0X2Jhc2VfZGly OgotICAgICAgICAgICAgYWJzcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0uYWJzcGF0aChfX2ZpbGVf XykKKyAgICAgICAgICAgIGNvbmZpZ19tb2R1bGVfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0ucGF0 aF90b19tb2R1bGUoc2VsZi5fX21vZHVsZV9fKQorICAgICAgICAgICAgYWJzcGF0aCA9IHNlbGYu X2ZpbGVzeXN0ZW0uYWJzcGF0aChjb25maWdfbW9kdWxlX3BhdGgpICAjIEZJWE1FOiBJIHN1c3Bl Y3QgdGhpcyBpcyBhIG5vb3AuCiAgICAgICAgICAgICBzZWxmLl93ZWJraXRfYmFzZV9kaXIgPSBh YnNwYXRoWzA6YWJzcGF0aC5maW5kKCdUb29scycpIC0gMV0KICAgICAgICAgcmV0dXJuIHNlbGYu X3dlYmtpdF9iYXNlX2RpcgogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L21hYy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvbWFjLnB5CmluZGV4IGE2ODVjMWJkYTE1M2FmYzMxMjZhNGM1Y2U3MmU2ZGI4NGU1 MjE2MmIuLmRiYTRjMjg4OWI2NzAzNGZiODFlOTdmMTM0NTFhMjQ2OTcyNjUwYzAgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CisrKyBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CkBAIC0zNCw3 ICszNCw3IEBAIGltcG9ydCByZQogCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0Lndl YmtpdCBpbXBvcnQgV2ViS2l0UG9ydAogCi1fbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtp dHB5LmxheW91dF90ZXN0cy5wb3J0Lm1hYyIpCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19u YW1lX18pCiAKIAogZGVmIG9zX3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwgc3VwcG9y dGVkX3ZlcnNpb25zPU5vbmUpOgpAQCAtNDgsOCArNDgsMTAgQEAgZGVmIG9zX3ZlcnNpb24ob3Nf dmVyc2lvbl9zdHJpbmc9Tm9uZSwgc3VwcG9ydGVkX3ZlcnNpb25zPU5vbmUpOgogICAgIHZlcnNp b25fc3RyaW5ncyA9IHsKICAgICAgICAgNTogJ2xlb3BhcmQnLAogICAgICAgICA2OiAnc25vd2xl b3BhcmQnLAorICAgICAgICAjIEFkZCA3OiAnbGlvbicgaGVyZT8KICAgICB9CiAgICAgYXNzZXJ0 IHJlbGVhc2VfdmVyc2lvbiA+PSBtaW4odmVyc2lvbl9zdHJpbmdzLmtleXMoKSkKKyAgICAjIEZJ WE1FOiBUaGVyZSBpcyBubyBtYWMtZnV0dXJlIGRpcmVjdG9yeSwgSSBkb24ndCB1bmRlcnN0YW5k IHdoeSB0aGlzIGNvZGUgaXMgaGVyZS4KICAgICB2ZXJzaW9uX3N0cmluZyA9IHZlcnNpb25fc3Ry aW5ncy5nZXQocmVsZWFzZV92ZXJzaW9uLCAnZnV0dXJlJykKICAgICBpZiBzdXBwb3J0ZWRfdmVy c2lvbnM6CiAgICAgICAgIGFzc2VydCB2ZXJzaW9uX3N0cmluZyBpbiBzdXBwb3J0ZWRfdmVyc2lv bnMKQEAgLTU3LDcgKzU5LDYgQEAgZGVmIG9zX3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmc9Tm9u ZSwgc3VwcG9ydGVkX3ZlcnNpb25zPU5vbmUpOgogCiAKIGNsYXNzIE1hY1BvcnQoV2ViS2l0UG9y dCk6Ci0gICAgIiIiV2ViS2l0IE1hYyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBjbGFzcy4i IiIKICAgICAjIEZJWE1FOiAnd2syJyBwcm9iYWJseSBzaG91bGRuJ3QgYmUgYSB2ZXJzaW9uLCBp dCBzaG91bGQgcHJvYmFibHkgYmUKICAgICAjIGEgbW9kaWZpZXIsIGxpa2UgJ2Nocm9taXVtLWdw dScgaXMgdG8gJ2Nocm9taXVtJy4KICAgICBTVVBQT1JURURfVkVSU0lPTlMgPSAoJ2xlb3BhcmQn LCAnc25vd2xlb3BhcmQnLCAnZnV0dXJlJywgJ3drMicpCkBAIC02NiwxOCArNjcsMjUgQEAgY2xh c3MgTWFjUG9ydChXZWJLaXRQb3J0KToKICAgICAgICAgJ2xlb3BhcmQnOiBbJ21hYy1sZW9wYXJk JywgJ21hYy1zbm93bGVvcGFyZCcsICdtYWMnXSwKICAgICAgICAgJ3Nub3dsZW9wYXJkJzogWydt YWMtc25vd2xlb3BhcmQnLCAnbWFjJ10sCiAgICAgICAgICdmdXR1cmUnOiBbJ21hYyddLAorICAg ICAgICAjIEZJWE1FOiBUaGlzIGlzbid0IHF1aXRlIHJpZ2h0IGZvciB3azIsIGl0IHNob3VsZCBp bmNsdWRlIG1hYy1WRVJTSU9OIGFzIHdlbGwuCiAgICAgICAgICd3azInOiBbJ21hYy13azInLCAn bWFjJ10sCiAgICAgfQogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT1Ob25lLCBv c192ZXJzaW9uX3N0cmluZz1Ob25lLCAqKmt3YXJncyk6Ci0gICAgICAgIHBvcnRfbmFtZSA9IHBv cnRfbmFtZSBvciAnbWFjJwotICAgICAgICBXZWJLaXRQb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRf bmFtZT1wb3J0X25hbWUsICoqa3dhcmdzKQorICAgICMgRklYTUU6IHZlcnNpb24sIG5hbWUsIGV0 Yy4gc2hvdWxkIGJlIHBhc3NlZCBzZXBhcmF0ZWx5IGFuZCB3ZSBzaG91bGQgbm90IGhhdmUgdG8g cGFyc2UgcG9ydF9uYW1lLgorICAgIGRlZiBfcGFyc2VfcG9ydF9uYW1lKHNlbGYsIHBvcnRfbmFt ZSwgb3NfdmVyc2lvbl9zdHJpbmcpOgogICAgICAgICBpZiBwb3J0X25hbWUgPT0gJ21hYyc6CiAg ICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gb3NfdmVyc2lvbihvc192ZXJzaW9uX3N0cmluZykK ICAgICAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBzZWxmLl92ZXJzaW9u CiAgICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lWzQ6 XQotICAgICAgICAgICAgYXNzZXJ0IHNlbGYuX3ZlcnNpb24gaW4gc2VsZi5TVVBQT1JURURfVkVS U0lPTlMKKyAgICAgICAgICAgIGFzc2VydCBwb3J0X25hbWUuc3RhcnRzd2l0aCgnbWFjJykKKyAg ICAgICAgICAgIHNlbGYuX3BvcnRfbmFtZSA9ICdtYWMnCisgICAgICAgICAgICBzZWxmLl92ZXJz aW9uID0gcG9ydF9uYW1lW2xlbignbWFjLScpOl0KKyAgICAgICAgICAgIGFzc2VydCBzZWxmLl92 ZXJzaW9uIGluIHNlbGYuU1VQUE9SVEVEX1ZFUlNJT05TLCAiJXMgaXMgbm90IGluICVzIiAlIChz ZWxmLl92ZXJzaW9uLCBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUykKKworICAgIGRlZiBfX2luaXRf XyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgb3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwgKiprd2FyZ3Mp OgorICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25hbWUgb3IgJ21hYycKKyAgICAgICAgV2ViS2l0 UG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAg ICAgc2VsZi5fcGFyc2VfcG9ydF9uYW1lKHBvcnRfbmFtZSwgb3NfdmVyc2lvbl9zdHJpbmcpCiAg ICAgICAgIHNlbGYuX29wZXJhdGluZ19zeXN0ZW0gPSAnbWFjJwogICAgICAgICBpZiBub3QgaGFz YXR0cihzZWxmLl9vcHRpb25zLCAndGltZS1vdXQtbXMnKSBvciBzZWxmLl9vcHRpb25zLnRpbWVf b3V0X21zIGlzIE5vbmU6CiAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnRpbWVfb3V0X21zID0g MzUwMDAKQEAgLTk0LDI0ICsxMDIsOSBAQCBjbGFzcyBNYWNQb3J0KFdlYktpdFBvcnQpOgogICAg IGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKICAgICAgICAgcmV0dXJuIG1hcChzZWxm Ll93ZWJraXRfYmFzZWxpbmVfcGF0aCwgc2VsZi5GQUxMQkFDS19QQVRIU1tzZWxmLl92ZXJzaW9u XSkKIAotICAgIGRlZiBwYXRoX3RvX3Rlc3RfZXhwZWN0YXRpb25zX2ZpbGUoc2VsZik6Ci0gICAg ICAgIHJldHVybiBzZWxmLnBhdGhfZnJvbV93ZWJraXRfYmFzZSgnTGF5b3V0VGVzdHMnLCAncGxh dGZvcm0nLAotICAgICAgICAgICAnbWFjJywgJ3Rlc3RfZXhwZWN0YXRpb25zLnR4dCcpCi0KICAg ICBkZWYgaXNfY3Jhc2hfcmVwb3J0ZXIoc2VsZiwgcHJvY2Vzc19uYW1lKToKICAgICAgICAgcmV0 dXJuIHJlLnNlYXJjaChyJ1JlcG9ydENyYXNoJywgcHJvY2Vzc19uYW1lKQogCi0gICAgZGVmIF9z a2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgICMgRklYTUU6IFRoaXMgbWV0aG9kIHdp bGwgbmVlZCB0byBiZSBtYWRlIHdvcmsgZm9yIG5vbi1tYWMKLSAgICAgICAgIyBwbGF0Zm9ybXMg YW5kIG1vdmVkIGludG8gYmFzZS5Qb3J0LgotICAgICAgICBza2lwcGVkX2ZpbGVzID0gW10KLSAg ICAgICAgaWYgc2VsZi5fbmFtZSBpbiAoJ21hYy1sZW9wYXJkJywgJ21hYy1zbm93bGVvcGFyZCcp OgotICAgICAgICAgICAgc2tpcHBlZF9maWxlcy5hcHBlbmQoc2VsZi5fZmlsZXN5c3RlbS5qb2lu KAotICAgICAgICAgICAgICAgIHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUp LCAnU2tpcHBlZCcpKQotICAgICAgICBza2lwcGVkX2ZpbGVzLmFwcGVuZChzZWxmLl9maWxlc3lz dGVtLmpvaW4oc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoJ21hYycpLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ1NraXBwZWQnKSkKLSAgICAgICAgcmV0dXJu IHNraXBwZWRfZmlsZXMKLQogICAgIGRlZiBfYnVpbGRfamF2YV90ZXN0X3N1cHBvcnQoc2VsZik6 CiAgICAgICAgIGphdmFfdGVzdHNfcGF0aCA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxh eW91dF90ZXN0c19kaXIoKSwgImphdmEiKQogICAgICAgICBidWlsZF9qYXZhID0gWyIvdXNyL2Jp bi9tYWtlIiwgIi1DIiwgamF2YV90ZXN0c19wYXRoXQpAQCAtMTI0LDggKzExNyw3IEBAIGNsYXNz IE1hY1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9qYXZhX3Rl c3Rfc3VwcG9ydCgpCiAKICAgICBkZWYgX3BhdGhfdG9fYXBhY2hlX2NvbmZpZ19maWxlKHNlbGYp OgotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYubGF5b3V0X3Rlc3Rz X2RpcigpLCAnaHR0cCcsICdjb25mJywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAnYXBhY2hlMi1odHRwZC5jb25mJykKKyAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0 ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ2h0dHAnLCAnY29uZicsICdhcGFjaGUy LWh0dHBkLmNvbmYnKQogCiAgICAgZGVmIF9wYXRoX3RvX3dlYmNvcmVfbGlicmFyeShzZWxmKToK ICAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgoJ1dlYkNvcmUuZnJhbWV3b3JrL1ZlcnNp b25zL0EvV2ViQ29yZScpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CmluZGV4IDI4ZmM4NWU2ZWEyNWQ1Yjk1NmE0 OWMxY2UxZjA2OTVhNjMwMDY1OGUuLjU2YTFjN2Q2NDY5ZjAzOTE2ODNmYWVjMjllY2YwMDgzYzhh MGViYjYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvbWFjX3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvbWFjX3VuaXR0ZXN0LnB5CkBAIC00MCwyNCArNDAsMjAgQEAgY2xhc3MgTWFjVGVz dChwb3J0X3Rlc3RjYXNlLlBvcnRUZXN0Q2FzZSk6CiAgICAgICAgICAgICByZXR1cm4gTm9uZQog ICAgICAgICByZXR1cm4gbWFjLk1hY1BvcnQKIAotICAgIGRlZiBhc3NlcnRfc2tpcHBlZF9maWxl c19mb3JfdmVyc2lvbihzZWxmLCBwb3J0X25hbWUsIGV4cGVjdGVkX3BhdGhzKToKKyAgICBkZWYg YXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZiwgcG9ydF9uYW1lLCBleHBlY3Rl ZF9wYXRocyk6CiAgICAgICAgIHBvcnQgPSBtYWMuTWFjUG9ydChwb3J0X25hbWU9cG9ydF9uYW1l KQotICAgICAgICBza2lwcGVkX3BhdGhzID0gcG9ydC5fc2tpcHBlZF9maWxlX3BhdGhzKCkKLSAg ICAgICAgIyBGSVhNRTogX3NraXBwZWRfZmlsZV9wYXRocyBzaG91bGQgcmV0dXJuIFdlYktpdC1y ZWxhdGl2ZSBwYXRocy4KLSAgICAgICAgIyBTbyB0byBtYWtlIGl0IHVuaXQgdGVzdGFibGUsIHdl IHN0cmlwIHRoZSBXZWJLaXQgZGlyZWN0b3J5IGZyb20gdGhlIHBhdGguCi0gICAgICAgIHJlbGF0 aXZlX3BhdGhzID0gW3BhdGhbbGVuKHBvcnQucGF0aF9mcm9tX3dlYmtpdF9iYXNlKCkpOl0gZm9y IHBhdGggaW4gc2tpcHBlZF9wYXRoc10KLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZWxhdGl2 ZV9wYXRocywgZXhwZWN0ZWRfcGF0aHMpCi0KLSAgICBkZWYgdGVzdF9za2lwcGVkX2ZpbGVfcGF0 aHMoc2VsZik6Ci0gICAgICAgICMgV2Ugc2tpcCB0aGlzIG9uIHdpbjMyIGJlY2F1c2Ugd2UgdXNl ICcvJyBhcyB0aGUgZGlyIHNlcGFyYXRvciBhbmQgaXQncwotICAgICAgICAjIG5vdCB3b3J0aCBt YWtpbmcgcGxhdGZvcm0taW5kZXBlbmRlbnQuCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9y dC5fc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygpLCBleHBlY3RlZF9wYXRocykKKworICAgIGRl ZiB0ZXN0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZik6CisgICAgICAgICMgRklYTUU6 IFRoaXMgc2hvdWxkIG5vIGxvbmdlciBiZSBuZWNlc3NhcnksIGJ1dCBJJ20gbm90IGJyYXZlIGVu b3VnaCB0byByZW1vdmUgaXQuCiAgICAgICAgIGlmIHN5cy5wbGF0Zm9ybSA9PSAnd2luMzInOgog ICAgICAgICAgICAgcmV0dXJuIE5vbmUKIAotICAgICAgICBzZWxmLmFzc2VydF9za2lwcGVkX2Zp bGVzX2Zvcl92ZXJzaW9uKCdtYWMtc25vd2xlb3BhcmQnLAotICAgICAgICAgICAgWycvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vbWFjLXNub3dsZW9wYXJkL1NraXBwZWQnLCAnL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy9Ta2lwcGVkJ10pCi0gICAgICAgIHNlbGYuYXNzZXJ0X3NraXBwZWRfZmlsZXNf Zm9yX3ZlcnNpb24oJ21hYy1sZW9wYXJkJywKLSAgICAgICAgICAgIFsnL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy1sZW9wYXJkL1NraXBwZWQnLCAnL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9T a2lwcGVkJ10pCisgICAgICAgIHNlbGYuYXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMo J21hYy1zbm93bGVvcGFyZCcsIHNldChbJ21hYy1zbm93bGVvcGFyZCcsICdtYWMnXSkpCisgICAg ICAgIHNlbGYuYXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoJ21hYy1sZW9wYXJkJywg c2V0KFsnbWFjLWxlb3BhcmQnLCAnbWFjJ10pKQorICAgICAgICAjIFdlIGNhbm5vdCB0ZXN0IGp1 c3QgIm1hYyIgaGVyZSBhcyB0aGUgTWFjUG9ydCBjb25zdHJ1Y3RvciBhdXRvbWF0aWNhbGx5IGZp bGxzIGluIHRoZSB2ZXJzaW9uIGZyb20gdGhlIHJ1bm5pbmcgT1MuCisgICAgICAgICMgc2VsZi5h c3NlcnRfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygnbWFjJywgWydtYWMnXSkKKwogCiAgICAg ZXhhbXBsZV9za2lwcGVkX2ZpbGUgPSB1IiIiCiAjIDxyZGFyOi8vcHJvYmxlbS81NjQ3OTUyPiBm YXN0L2V2ZW50cy9tb3VzZW91dC1vbi13aW5kb3cuaHRtbCBuZWVkcyBtYWMgRFJUIHRvIGlzc3Vl IG1vdXNlIG91dCBldmVudHMKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvcXQucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L3F0LnB5CmluZGV4IDYwYjBjMzI5Mjc3NjUyOGYwN2YwZDYzNDE5Y2I0MjY5ZmU1YzQ0 YTIuLmNjMmM1NDc2NDAwNWE4OGJlMTlmMjIwYTVjYzk2NWI0OTUzYjNmOWEgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5weQpAQCAtMzUsMTIgKzM1 LDEwIEBAIGltcG9ydCB3ZWJraXQKIAogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC53 ZWJraXQgaW1wb3J0IFdlYktpdFBvcnQKIAotX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJr aXRweS5sYXlvdXRfdGVzdHMucG9ydC5xdCIpCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19u YW1lX18pCiAKIAogY2xhc3MgUXRQb3J0KFdlYktpdFBvcnQpOgotICAgICIiIlF0V2ViS2l0IGlt cGxlbWVudGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIiIgotCiAgICAgZGVmIF9faW5pdF9fKHNl bGYsICoqa3dhcmdzKToKICAgICAgICAga3dhcmdzLnNldGRlZmF1bHQoJ3BvcnRfbmFtZScsICdx dCcpCiAgICAgICAgIFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwgKiprd2FyZ3MpCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weSBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CmluZGV4 IDc1YWEwNWFkOTZiMTI0ZDQ0NzMwNTI2NzYwZDgzMDk3ZGViYWJiMGQuLjdjMzk2MWVhY2YwMWVj ZWFiMWNjMjdmMmU2YWQyYjA4YjEyMWQ2ZjAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CkBAIC02NSwxMiArNjUsMjEgQEAgY2xh c3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAgICAgICAgcmV0dXJuICJXZWJLaXRUZXN0 UnVubmVyIgogICAgICAgICByZXR1cm4gIkR1bXBSZW5kZXJUcmVlIgogCisgICAgIyBGSVhNRTog VGhpcyBpcyBub3QgYSB2ZXJ5IHVzZWZ1bCBkZWZhdWx0IGltcGxlbWVudGF0aW9uLCBhcyBpdHMg d3JvbmcgZm9yIGFueQorICAgICMgcG9ydCB3aGljaCByZXF1aXJlcyBwbGF0Zm9ybS1zcGVjZmlj IHJlc3VsdHMuIFdlIHNob3VsZCByZXBsYWNlIHRoaXMgd2l0aCBhIHNtYXJ0ZXIKKyAgICAjIGlt cGxlbWVudGF0aW9uIHNoYXJlZCBieSBhbGwgcG9ydHMuCiAgICAgZGVmIGJhc2VsaW5lX3NlYXJj aF9wYXRoKHNlbGYpOgotICAgICAgICByZXR1cm4gW3NlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRo KHNlbGYuX25hbWUpXQorICAgICAgICBzZWFyY2hfcGF0aHMgPSBbc2VsZi5uYW1lKCldCisgICAg ICAgIGlmIHNlbGYuZ2V0X29wdGlvbignd2Via2l0X3Rlc3RfcnVubmVyJyk6CisgICAgICAgICAg ICBzZWFyY2hfcGF0aHMuaW5zZXJ0KDAsIHNlbGYud2syX3BvcnRfbmFtZSgpKQorICAgICAgICBy ZXR1cm4gc2VhcmNoX3BhdGhzCisKKyAgICBkZWYgX2V4cGVjdGF0aW9uc19zZWFyY2hfcGF0aChz ZWxmKToKKyAgICAgICAgIyB0ZXN0X2V4cGVjdGF0aW9ucyBhcmUgYWx3YXlzIGluIG1hYy8gbm90 IG1hYy1sZW9wYXJkLyBieSBjb252ZW50aW9uLCBoZW5jZSB3ZSB1c2UgcG9ydF9uYW1lKCkgaW5z dGVhZCBvZiBuYW1lKCkuCisgICAgICAgIHJldHVybiBzZWxmLndrMl9wb3J0X25hbWUoKSBpZiBz ZWxmLmdldF9vcHRpb24oJ3dlYmtpdF90ZXN0X3J1bm5lcicpIGVsc2Ugc2VsZi5wb3J0X25hbWUo KQogCiAgICAgZGVmIHBhdGhfdG9fdGVzdF9leHBlY3RhdGlvbnNfZmlsZShzZWxmKToKLSAgICAg ICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0 aChzZWxmLl9uYW1lKSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAndGVz dF9leHBlY3RhdGlvbnMudHh0JykKKyAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9p bihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxmLl9leHBlY3RhdGlvbnNfc2VhcmNoX3Bh dGgoKSksICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQnKQogCiAgICAgZGVmIF9yZXN1bHRzX2Zvcl9w bGF0Zm9ybShzZWxmLCBwbGF0Zm9ybSk6CiAgICAgICAgIGJ1aWxkZXJfbmFtZSA9IGJ1aWxkZXJz LmJ1aWxkZXJfbmFtZV9mb3JfcGxhdGZvcm0ocGxhdGZvcm0pCkBAIC0yODQsMTIgKzI5MywyNSBA QCBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAgICAgICB0ZXN0c190b19za2lw LmFwcGVuZChsaW5lKQogICAgICAgICByZXR1cm4gdGVzdHNfdG9fc2tpcAogCi0gICAgZGVmIF9z a2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6Ci0gICAgICAgIHJldHVybiBbc2VsZi5fZmlsZXN5c3Rl bS5qb2luKHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpLCAnU2tpcHBlZCcp XQorICAgIGRlZiB3azJfcG9ydF9uYW1lKHNlbGYpOgorICAgICAgICByZXR1cm4gIiVzLXdrMiIg JSBzZWxmLnBvcnRfbmFtZSgpCisKKyAgICBkZWYgX3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMo c2VsZik6CisgICAgICAgICMgVW5saWtlIGJhc2VsaW5lX3NlYXJjaF9wYXRoLCB3ZSBvbmx5IHdh bnQgdG8gc2VhcmNoIFtXSzItUE9SVCwgUE9SVC1WRVJTSU9OLCBQT1JUXSBub3QgdGhlIGZ1bGwg Y2FzYWRlLgorICAgICAgICAjIE5vdGUgb3JkZXIgZG9lc24ndCBtYXR0ZXIgc2luY2UgdGhlIFNr aXBwZWQgZmlsZSBjb250ZW50cyBhcmUgYWxsIGNvbWJpbmVkLgorICAgICAgICBzZWFyY2hfcGF0 aHMgPSBzZXQoW3NlbGYucG9ydF9uYW1lKCksIHNlbGYubmFtZSgpXSkKKyAgICAgICAgaWYgc2Vs Zi5nZXRfb3B0aW9uKCd3ZWJraXRfdGVzdF9ydW5uZXInKToKKyAgICAgICAgICAgICMgUXVvdGlu ZyBvbGQtcnVuLXdlYmtpdC10ZXN0czoKKyAgICAgICAgICAgICMgQmVjYXVzZSBuZWFybHkgYWxs IG9mIHRoZSBza2lwcGVkIHRlc3RzIGZvciBXZWJLaXQgMiBvbiBNYWMgYXJlIGR1ZSB0bworICAg ICAgICAgICAgIyBjcm9zcy1wbGF0Zm9ybSBpc3N1ZXMsIHRoZSBXaW5kb3dzIGFuZCBRdCBwb3J0 cyB1c2UgdGhlIE1hYyBza2lwcGVkIGxpc3QKKyAgICAgICAgICAgICMgYWRkaXRpb25hbGx5IHRv IHRoZWlyIG93biB0byBhdm9pZCBtYWludGFpbmluZyBzZXBhcmF0ZSBsaXN0cy4KKyAgICAgICAg ICAgIHNlYXJjaF9wYXRocy51cGRhdGUoW3NlbGYud2syX3BvcnRfbmFtZSgpLCAibWFjLXdrMiJd KQorICAgICAgICByZXR1cm4gc2VhcmNoX3BhdGhzCiAKICAgICBkZWYgX2V4cGVjdGF0aW9uc19m cm9tX3NraXBwZWRfZmlsZXMoc2VsZik6CiAgICAgICAgIHRlc3RzX3RvX3NraXAgPSBbXQotICAg ICAgICBmb3IgZmlsZW5hbWUgaW4gc2VsZi5fc2tpcHBlZF9maWxlX3BhdGhzKCk6CisgICAgICAg IGZvciBzZWFyY2hfcGF0aCBpbiBzZWxmLl9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCk6Cisg ICAgICAgICAgICBmaWxlbmFtZSA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRf YmFzZWxpbmVfcGF0aChzZWFyY2hfcGF0aCksICJTa2lwcGVkIikKICAgICAgICAgICAgIGlmIG5v dCBzZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhmaWxlbmFtZSk6CiAgICAgICAgICAgICAgICAgX2xv Zy53YXJuKCJGYWlsZWQgdG8gb3BlbiBTa2lwcGVkIGZpbGU6ICVzIiAlIGZpbGVuYW1lKQogICAg ICAgICAgICAgICAgIGNvbnRpbnVlCkBAIC0yOTgsMTIgKzMyMCwxNCBAQCBjbGFzcyBXZWJLaXRQ b3J0KGJhc2UuUG9ydCk6CiAgICAgICAgIHJldHVybiB0ZXN0c190b19za2lwCiAKICAgICBkZWYg dGVzdF9leHBlY3RhdGlvbnMoc2VsZik6Ci0gICAgICAgICMgVGhlIFdlYktpdCBtYWMgcG9ydCB1 c2VzIGEgY29tYmluYXRpb24gb2YgYSB0ZXN0X2V4cGVjdGF0aW9ucyBmaWxlCi0gICAgICAgICMg YW5kICdTa2lwcGVkJyBmaWxlcy4KKyAgICAgICAgIyBUaGlzIGFsbG93cyBwb3J0cyB0byB1c2Ug YSBjb21iaW5hdGlvbiBvZiB0ZXN0X2V4cGVjdGF0aW9ucy50eHQgZmlsZXMgYW5kIFNraXBwZWQg bGlzdHMuCisgICAgICAgIGV4cGVjdGF0aW9ucyA9IHNlbGYuX3NraXBwZWRfbGlzdF9hc19leHBl Y3RhdGlvbnNfZmlsZSgpCiAgICAgICAgIGV4cGVjdGF0aW9uc19wYXRoID0gc2VsZi5wYXRoX3Rv X3Rlc3RfZXhwZWN0YXRpb25zX2ZpbGUoKQotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3Rl bS5yZWFkX3RleHRfZmlsZShleHBlY3RhdGlvbnNfcGF0aCkgKyBzZWxmLl9za2lwcygpCisgICAg ICAgIGlmIHNlbGYuX2ZpbGVzeXN0ZW0uZXhpc3RzKGV4cGVjdGF0aW9uc19wYXRoKToKKyAgICAg ICAgICAgIGV4cGVjdGF0aW9ucyArPSBzZWxmLl9maWxlc3lzdGVtLnJlYWRfdGV4dF9maWxlKGV4 cGVjdGF0aW9uc19wYXRoKQorICAgICAgICByZXR1cm4gZXhwZWN0YXRpb25zCiAKLSAgICBkZWYg X3NraXBzKHNlbGYpOgorICAgIGRlZiBfc2tpcHBlZF9saXN0X2FzX2V4cGVjdGF0aW9uc19maWxl KHNlbGYpOgogICAgICAgICAjIEVhY2ggU2tpcHBlZCBmaWxlIGNvbnRhaW5zIGEgbGlzdCBvZiBm aWxlcwogICAgICAgICAjIG9yIGRpcmVjdG9yaWVzIHRvIGJlIHNraXBwZWQgZHVyaW5nIHRoZSB0 ZXN0IHJ1bi4gVGhlIHRvdGFsIGxpc3QKICAgICAgICAgIyBvZiB0ZXN0cyB0byBza2lwcGVkIGlz IGdpdmVuIGJ5IHRoZSBjb250ZW50cyBvZiB0aGUgZ2VuZXJpYwpAQCAtMzEzLDggKzMzNyw3IEBA IGNsYXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAgIyBmb3JtYXQgZXhwZWN0ZWQg YnkgdGVzdF9leHBlY3RhdGlvbnMuCiAKICAgICAgICAgdGVzdHNfdG9fc2tpcCA9IHNlbGYuc2tp cHBlZF9sYXlvdXRfdGVzdHMoKQotICAgICAgICBza2lwX2xpbmVzID0gbWFwKGxhbWJkYSB0ZXN0 X3BhdGg6ICJCVUdfU0tJUFBFRCBTS0lQIDogJXMgPSBGQUlMIiAlCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHRlc3RfcGF0aCwgdGVzdHNfdG9fc2tpcCkKKyAgICAgICAgc2tpcF9s aW5lcyA9IG1hcChsYW1iZGEgdGVzdF9wYXRoOiAiQlVHX1NLSVBQRUQgU0tJUCA6ICVzID0gRkFJ TCIgJSB0ZXN0X3BhdGgsIHRlc3RzX3RvX3NraXApCiAgICAgICAgIHJldHVybiAiXG4iLmpvaW4o c2tpcF9saW5lcykKIAogICAgIGRlZiBza2lwcGVkX2xheW91dF90ZXN0cyhzZWxmKToKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3Vu aXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJr aXRfdW5pdHRlc3QucHkKaW5kZXggZmY0OTM5ZGJmMTRjMmQzMjdiOGI0ZTUzMDUyNzYxOThjNmMy MmQzNC4uY2QyMTE5Y2EyYTU3ZWUyZDc0NGYxOTc1NTg5ODk0YmU2NTYzMjkwMiAxMDA3NTUKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJraXRfdW5pdHRl c3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93ZWJr aXRfdW5pdHRlc3QucHkKQEAgLTI3LDcgKzI3LDcgQEAKIAogaW1wb3J0IHVuaXR0ZXN0CiAKLWZy b20gd2Via2l0cHkuY29tbW9uLnN5c3RlbSBpbXBvcnQgZmlsZXN5c3RlbV9tb2NrCitmcm9tIHdl YmtpdHB5LmNvbW1vbi5zeXN0ZW0uZmlsZXN5c3RlbV9tb2NrIGltcG9ydCBNb2NrRmlsZVN5c3Rl bQogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLm91dHB1dGNhcHR1cmUgaW1wb3J0IE91dHB1 dENhcHR1cmUKIAogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMucG9ydC53ZWJraXQgaW1wb3J0 IFdlYktpdFBvcnQKQEAgLTQzLDEyICs0MywxMCBAQCBjbGFzcyBUZXN0V2ViS2l0UG9ydChXZWJL aXRQb3J0KToKICAgICAgICAgICAgICAgICAgKiprd2FyZ3MpOgogICAgICAgICBzZWxmLnN5bWJv bF9saXN0ID0gc3ltYm9sX2xpc3QKICAgICAgICAgc2VsZi5mZWF0dXJlX2xpc3QgPSBmZWF0dXJl X2xpc3QKLSAgICAgICAgc2VsZi5leHBlY3RhdGlvbnNfZmlsZSA9IGV4cGVjdGF0aW9uc19maWxl Ci0gICAgICAgIHNlbGYuc2tpcHNfZmlsZSA9IHNraXBzX2ZpbGUKICAgICAgICAgZXhlY3V0aXZl ID0gZXhlY3V0aXZlIG9yIE1vY2tFeGVjdXRpdmUoc2hvdWxkX2xvZz1GYWxzZSkKLSAgICAgICAg ZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0gb3IgZmlsZXN5c3RlbV9tb2NrLk1vY2tGaWxlU3lzdGVt KCkKKyAgICAgICAgZmlsZXN5c3RlbSA9IGZpbGVzeXN0ZW0gb3IgTW9ja0ZpbGVTeXN0ZW0oKQog ICAgICAgICB1c2VyID0gdXNlciBvciBNb2NrVXNlcigpCi0gICAgICAgIFdlYktpdFBvcnQuX19p bml0X18oc2VsZiwgZXhlY3V0aXZlPWV4ZWN1dGl2ZSwgZmlsZXN5c3RlbT1maWxlc3lzdGVtLCB1 c2VyPU1vY2tVc2VyKCksICoqa3dhcmdzKQorICAgICAgICBXZWJLaXRQb3J0Ll9faW5pdF9fKHNl bGYsIHBvcnRfbmFtZT0idGVzdCIsIGV4ZWN1dGl2ZT1leGVjdXRpdmUsIGZpbGVzeXN0ZW09Zmls ZXN5c3RlbSwgdXNlcj1Nb2NrVXNlcigpLCAqKmt3YXJncykKIAogICAgIGRlZiBfcnVudGltZV9m ZWF0dXJlX2xpc3Qoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLmZlYXR1cmVfbGlzdApAQCAt NjIsMTYgKzYwLDYgQEAgY2xhc3MgVGVzdFdlYktpdFBvcnQoV2ViS2l0UG9ydCk6CiAgICAgZGVm IF90ZXN0c19mb3JfZGlzYWJsZWRfZmVhdHVyZXMoc2VsZik6CiAgICAgICAgIHJldHVybiBbImFj Y2Vzc2liaWxpdHkiLCBdCiAKLSAgICBkZWYgcGF0aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxl KHNlbGYpOgotICAgICAgICBpZiBzZWxmLmV4cGVjdGF0aW9uc19maWxlOgotICAgICAgICAgICAg cmV0dXJuIHNlbGYuZXhwZWN0YXRpb25zX2ZpbGUKLSAgICAgICAgcmV0dXJuIFdlYktpdFBvcnQu cGF0aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKHNlbGYpCi0KLSAgICBkZWYgX3NraXBwZWRf ZmlsZV9wYXRocyhzZWxmKToKLSAgICAgICAgaWYgc2VsZi5za2lwc19maWxlOgotICAgICAgICAg ICAgcmV0dXJuIFtzZWxmLnNraXBzX2ZpbGVdCi0gICAgICAgIHJldHVybiBbXQotCiAKIGNsYXNz IFdlYktpdFBvcnRUZXN0KHBvcnRfdGVzdGNhc2UuUG9ydFRlc3RDYXNlKToKICAgICBkZWYgcG9y dF9tYWtlcihzZWxmLCBwbGF0Zm9ybSk6CkBAIC0xMDEsMTYgKzg5LDIzIEBAIGNsYXNzIFdlYktp dFBvcnRUZXN0KHBvcnRfdGVzdGNhc2UuUG9ydFRlc3RDYXNlKToKICAgICBkZWYgdGVzdF9za2lw cGVkX2xheW91dF90ZXN0cyhzZWxmKToKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChUZXN0V2Vi S2l0UG9ydChOb25lLCBOb25lKS5za2lwcGVkX2xheW91dF90ZXN0cygpLCBzZXQoWyJtZWRpYSJd KSkKIAorICAgIGRlZiB0ZXN0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZik6CisgICAg ICAgIHBvcnQgPSBUZXN0V2ViS2l0UG9ydCgpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9y dC5fc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygpLCBzZXQoWyd0ZXN0J10pKQorICAgICAgICBw b3J0Ll9uYW1lID0gInRlc3QtdmVyc2lvbiIKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChwb3J0 Ll9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCksIHNldChbJ3Rlc3QnLCAndGVzdC12ZXJzaW9u J10pKQorICAgICAgICBwb3J0Ll9vcHRpb25zID0gTW9ja09wdGlvbnMod2Via2l0X3Rlc3RfcnVu bmVyPVRydWUpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9ydC5fc2tpcHBlZF9maWxlX3Nl YXJjaF9wYXRocygpLCBzZXQoWyd0ZXN0JywgJ3Rlc3QtdmVyc2lvbicsICd0ZXN0LXdrMicsICdt YWMtd2syJ10pKQorCiAgICAgZGVmIHRlc3RfdGVzdF9leHBlY3RhdGlvbnMoc2VsZik6CiAgICAg ICAgICMgQ2hlY2sgdGhhdCB3ZSByZWFkIGJvdGggdGhlIGV4cGVjdGF0aW9ucyBmaWxlIGFuZCBh bnl0aGluZyBpbiBhCiAgICAgICAgICMgU2tpcHBlZCBmaWxlLCBhbmQgdGhhdCB3ZSBpbmNsdWRl IHRoZSBmZWF0dXJlIGFuZCBwbGF0Zm9ybSBjaGVja3MuCiAgICAgICAgIGZpbGVzID0gewotICAg ICAgICAgICAgJy90bXAvdGVzdF9leHBlY3RhdGlvbnMudHh0JzogJ0JVR19URVNURVhQRUNUQVRJ T05TIFNLSVAgOiBmYXN0L2h0bWwvYXJ0aWNsZS1lbGVtZW50Lmh0bWwgPSBGQUlMXG4nLAotICAg ICAgICAgICAgJy90bXAvU2tpcHBlZCc6ICdmYXN0L2h0bWwva2V5Z2VuLmh0bWwnLAorICAgICAg ICAgICAgJy9tb2NrL0xheW91dFRlc3RzL3BsYXRmb3JtL3Rlc3QvdGVzdF9leHBlY3RhdGlvbnMu dHh0JzogJ0JVR19URVNURVhQRUNUQVRJT05TIFNLSVAgOiBmYXN0L2h0bWwvYXJ0aWNsZS1lbGVt ZW50Lmh0bWwgPSBGQUlMXG4nLAorICAgICAgICAgICAgJy9tb2NrL0xheW91dFRlc3RzL3BsYXRm b3JtL3Rlc3QvU2tpcHBlZCc6ICdmYXN0L2h0bWwva2V5Z2VuLmh0bWwnLAogICAgICAgICB9Ci0g ICAgICAgIG1vY2tfZnMgPSBmaWxlc3lzdGVtX21vY2suTW9ja0ZpbGVTeXN0ZW0oZmlsZXMpCi0g ICAgICAgIHBvcnQgPSBUZXN0V2ViS2l0UG9ydChleHBlY3RhdGlvbnNfZmlsZT0nL3RtcC90ZXN0 X2V4cGVjdGF0aW9ucy50eHQnLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2tpcHNf ZmlsZT0nL3RtcC9Ta2lwcGVkJywgZmlsZXN5c3RlbT1tb2NrX2ZzKQorICAgICAgICBtb2NrX2Zz ID0gTW9ja0ZpbGVTeXN0ZW0oZmlsZXMpCisgICAgICAgIHBvcnQgPSBUZXN0V2ViS2l0UG9ydChm aWxlc3lzdGVtPW1vY2tfZnMpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwocG9ydC50ZXN0X2V4 cGVjdGF0aW9ucygpLAogICAgICAgICAiIiJCVUdfVEVTVEVYUEVDVEFUSU9OUyBTS0lQIDogZmFz dC9odG1sL2FydGljbGUtZWxlbWVudC5odG1sID0gRkFJTAogQlVHX1NLSVBQRUQgU0tJUCA6IGZh c3QvaHRtbC9rZXlnZW4uaHRtbCA9IEZBSUwKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lc2VydmVyX3VuaXR0ZXN0LnB5IGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3JlYmFzZWxpbmVzZXJ2ZXJfdW5pdHRlc3Qu cHkKaW5kZXggNTNkMGM4OTFhYTAzNDJmZmEyZWQxZGFhNWE5NDVlMGUzZWU5MWU4OC4uNTdkYTBm ODc2MzRiZjM4NGNlMzAzNzcyNTI0YjkxMDc5OTRlMjgzYSAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3JlYmFzZWxpbmVzZXJ2ZXJfdW5pdHRlc3QucHkK KysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3JlYmFzZWxpbmVzZXJ2 ZXJfdW5pdHRlc3QucHkKQEAgLTI3NCwxMyArMjc0LDEzIEBAIGNsYXNzIEdldEJhc2VsaW5lc1Rl c3QodW5pdHRlc3QuVGVzdENhc2UpOgogICAgICAgICAgICAgZXhwZWN0ZWRfYmFzZWxpbmVzPXsn YmFzZSc6IHsnLnR4dCc6IFRydWV9fSkKIAogICAgIGRlZiBfYXNzZXJ0QmFzZWxpbmVzKHNlbGYs IHRlc3RfZmlsZXMsIHRlc3RfbmFtZSwgZXhwZWN0ZWRfYmFzZWxpbmVzKToKLSAgICAgICAgYWN0 dWFsX2Jhc2VsaW5lcyA9IHJlYmFzZWxpbmVzZXJ2ZXIuX2dldF90ZXN0X2Jhc2VsaW5lcygKLSAg ICAgICAgICAgIHRlc3RfbmFtZSwgZ2V0X3Rlc3RfY29uZmlnKHRlc3RfZmlsZXMpKQorICAgICAg ICBhY3R1YWxfYmFzZWxpbmVzID0gcmViYXNlbGluZXNlcnZlci5fZ2V0X3Rlc3RfYmFzZWxpbmVz KHRlc3RfbmFtZSwgZ2V0X3Rlc3RfY29uZmlnKHRlc3RfZmlsZXMpKQogICAgICAgICBzZWxmLmFz c2VydEVxdWFsKGV4cGVjdGVkX2Jhc2VsaW5lcywgYWN0dWFsX2Jhc2VsaW5lcykKIAogCiBkZWYg Z2V0X3Rlc3RfY29uZmlnKHRlc3RfZmlsZXM9W10sIHJlc3VsdF9maWxlcz1bXSk6Ci0gICAgbGF5 b3V0X3Rlc3RzX2RpcmVjdG9yeSA9IGJhc2UuUG9ydCgpLmxheW91dF90ZXN0c19kaXIoKQorICAg ICMgV2UgY291bGQgZ3JhYiB0aGlzIGZyb20gcG9ydC5sYXlvdXRfdGVzdHNfZGlyKCksIGJ1dCBp bnN0YW50aWF0aW5nIGEgZnVsbHkgbW9ja2VkIHBvcnQgaXMgYSBwYWluLgorICAgIGxheW91dF90 ZXN0c19kaXJlY3RvcnkgPSAiL21vY2svTGF5b3V0VGVzdHMiCiAgICAgcmVzdWx0c19kaXJlY3Rv cnkgPSAnL1dlYktpdEJ1aWxkL0RlYnVnL2xheW91dC10ZXN0LXJlc3VsdHMnCiAgICAgbW9ja19m aWxlc3lzdGVtID0gZmlsZXN5c3RlbV9tb2NrLk1vY2tGaWxlU3lzdGVtKCkKICAgICBmb3IgZmls ZSBpbiB0ZXN0X2ZpbGVzOgo= 99159 2011-06-29 15:10:52 -0700 2011-06-29 16:33:28 -0700 further reduced patch, still no functional changes bug-63501-20110629151051.patch text/plain 26503 eric U3VidmVyc2lvbiBSZXZpc2lvbjogOTAwNTIKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCA5YjM3MDI4MGM3ZDYwYmQ5ZDhlNzZmOWFkNWZiODE5MmVi MzkwODcyLi5kMTQwOTkyOGMxYWNhNzM0YzUyNjExYjU0NzZlYmIxMzljNmVlYzVkIDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzcg QEAKKzIwMTEtMDYtMjcgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNpbXBsaWZ5IHNraXBwZWQg ZmlsZSBmaW5kaW5nIGluIHByZXBhcmF0aW9uIGZvciBhZGRpbmcgd2syIHNraXBwZWQgbGlzdCBm YWxsYmFjaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjM1MDEKKworICAgICAgICBUaGUgZ29hbCB3YXMgdG8gYWRkIHN1cHBvcnQgZm9yIHdrMiBza2lw cGVkIGxpc3RzLgorICAgICAgICBIb3dldmVyLCBJIGZvdW5kIHRoYXQgb3VyIHNraXBwZWQgbGlz dCBjb21wdXRhdGlvbiB3YXMgYQorICAgICAgICBtYW51YWwgaGFjayAod2hpY2ggb25seSB3b3Jr ZWQgZm9yIHRoZSBtYWMgcG9ydCkuCisKKyAgICAgICAgU28gSSBmaXhlZCBhIEZJWE1FIHRvIG1v dmUgdGhlIHNraXBwZWQgbGlzdCBmaW5kaW5nCisgICAgICAgIGludG8gV2ViS2l0UG9ydCBpbnN0 ZWFkIG9mIE1hY1BvcnQuCisgICAgICAgIERvaW5nIHNvIHJlcXVpcmVkIGFkZGluZyBhIHBvcnRf bmFtZSgpIGFjY2Vzc29yIGFuZAorICAgICAgICB1bnRhbmdsaW5nIHRoZSBtZXNzIHRoYXQgaXMg b3VyIHBvcnRfbmFtZSBhcmd1bWVudCAicGFyc2luZyIuCisKKyAgICAgICAgKE91ciBjdXJyZW50 IHN5c3RlbSBvZiBzb21ldGltZXMgcGFzc2luZyAiY2hyb21pdW0tbWFjIiBhbmQKKyAgICAgICAg c29tZXRpbWVzICJjaHJvbWl1bS1tYWMtbGVvcGFyZCIgb3Igd29yc2UgImNocm9taXVtLWdwdS1t YWMtbGVvcGFyZCIKKyAgICAgICAgYXMgdGhlIHBvcnRfbmFtZSBhcmd1bWVudCBhbmQgZXhwZWN0 aW5nIFdlYktpdFBvcnQoKSB0byBkbyB0aGUgcmlnaHQKKyAgICAgICAgdGhpbmcgaXMgYWJzdXJk LikKKworICAgICAgICBJIGFkZGVkIGEgbmV3IF9wYXJzZV9wb3J0X25hbWUgbWV0aG9kIHRvIGhh bmRsZSB0aGUgdmFyaW91cworICAgICAgICBwb3NzaWJsZSBwb3J0X25hbWUgdmFsdWVzLiAgTm93 IHRoYXQgd2UgaGF2ZSBhIHNoYXJlZCBtZXRob2QKKyAgICAgICAgd2UgY291bGQgcHJvYmFibHkg anVzdCBjYWxsIF9wYXJzZV9wb3J0X25hbWUoKSBmcm9tIHRoZQorICAgICAgICBXZWJLaXRQb3J0 IGNvbnN0cnVjdG9yIGFuZCBnZXQgcmlkIG9mIG1hbnkgb2YgdGhlIHN1YmNsYXNzIGNvbnN0cnVj dG9ycy4KKworICAgICAgICBJbiBvcmRlciB0byB0ZXN0IG15IG5ldyBfc2tpcHBlZF9maWxlX3Nl YXJjaF9wYXRocyBtZXRob2QsIEkKKyAgICAgICAgZml4ZWQgYW5vdGhlciBGSVhNRSBieSBtYWtp bmcgaXQgcmV0dXJuIHJlbGF0aXZlIHBhdGhzLiAgSG93ZXZlcgorICAgICAgICBpbiBkb2luZyBz byBJIGZvdW5kIHRoYXQgdGhlIFRlc3RXZWJLaXRQb3J0IHdlIHdlcmUgdXNpbmcgaW4KKyAgICAg ICAgd2Via2l0X3VuaXR0ZXN0LnB5IHdhcyBhY2Nlc3NpbmcgdGhlIHJlYWwgZmlsZXN5c3RlbSB0 aHJvdWdoIHRoZSB1c2UKKyAgICAgICAgb2YgdGhlIF9fZmlsZV9fIHZhcmlhYmxlLgorCisgICAg ICAgIFNvIHRvIGZpeCB0aGF0LCBJIGFkZGVkIGEgcGF0aF9mb3JfbW9kdWxlIGFic3RyYWN0aW9u IG9udG8gZmlsZXN5c3RlbS5weS4KKworICAgICAgICBJIG9mIGNvdXJzZSByZW1vdmVkIHNvbWUg cmVkdW5kYW50IGRvY3N0cmluZ3MgYW5kIG1vdmVkIGFic29sdXRlCisgICAgICAgIG1vZHVsZSBu YW1lcyB0byBfX2ZpbGVfXyBhbG9uZyB0aGUgd2F5LgorCisgICAgICAgIEkgYWxzbyBmaXhlZCB0 aGUgdGVzdF9leHBlY3RhdGlvbnNfcGF0aCBjb2RlIGluIFdlYktpdFBvcnQgdG8gdXNlIHBvcnRf bmFtZSgpLgorICAgICAgICBJdCB3YXMgdXNpbmcgbmFtZSgpIHdoaWNoIHdvdWxkIHJldHVybiBQ T1JULVZFUlNJT04gc28gTWFjUG9ydCB3YXMgb3ZlcnJpZGluZworICAgICAgICBpdCB0byB1c2Ug anVzdCBQT1JULiAgQWZ0ZXIgZml4aW5nIHRlc3RfZXhwZWN0YXRpb25zX3BhdGggdG8gdXNlIHBv cnRfbmFtZSgpCisgICAgICAgIChhbmQgbWFraW5nIGl0IGF3YXJlIG9mIHdlYmtpdDIpIEkgd2Fz IGFibGUgdG8gcmVtb3ZlIHRoZSBNYWNQb3J0IGltcGxlbWVudGF0aW9uLgorCisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS9jb21tb24vY2hlY2tvdXQvc2NtL2dpdC5weTogInRoZWFkIiAtPiAi dGhyZWFkIgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvY29tbW9uL3N5c3RlbS9maWxlc3lz dGVtLnB5OgorICAgICAgICAgLSBUaGlzIGNhbiBiZSB1c2VkIHRvIHdyYXAgYWxsIGNhbGxzIHRv IF9fZmlsZV9fIHRvIG1ha2UgdGhlbSB1bml0LXRlc3QgZnJpZW5kbHkuCisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9jb21tb24vc3lzdGVtL2ZpbGVzeXN0ZW1fbW9jay5weToKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHk6CisgICAgICAgICAt IEFkZCBwb3J0X25hbWUoKSB0byBhY2Nlc3MgIm1hYyIsIHNpbmNlIG5hbWUoKSByZXR1cm5zICJt YWMtbGVvcGFyZCIgZXRjLgorICAgICAgICAgLSBEb2N1bWVudCB0aGF0IHJlYWxfbmFtZSgpIHNl ZW1zIHRvIGhhdmUgbm8gcHVycG9zZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L2J1aWxkZXJzLnB5OgorICAgICAgICAgLSBSZW1vdmUgdGlnZXIgc3VwcG9y dCwgd2Via2l0IG5vIGxvbmdlciBzdXBwb3J0cyB0aWdlci4KKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5OgorICAgICAgICAgLSBB ZGQgX3BhcnNlX3BvcnRfbmFtZSgpLCBldmVudHVhbGx5IHdlIG1pZ2h0IGNhbGwgdGhpcyBmcm9t IFdlYktpdFBvcnQgZGlyZWN0bHkuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHk6CisgICAgICAgICAtIEFkZCBfcGFyc2VfcG9ydF9u YW1lLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21p dW1fd2luLnB5OgorICAgICAgICAgLSBBZGQgX3BhcnNlX3BvcnRfbmFtZS4KKyAgICAgICAgKiBT Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2NvbmZpZy5weToKKyAgICAgICAgIC0g VXNlIHRoZSBuZXcgcGF0aF90b19tb2R1bGUgYWJzdHJhY3Rpb24gaW5zdGVhZCBvZiBfX2ZpbGVf XyB0byBtYWtlIGl0CisgICAgICAgICAgIGVhc2llciB0byB1bml0dGVzdCBjb25maWcucHkgY29k ZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weToK KyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hYy5weToKKyAg ICAgICAgIC0gTW92ZSBTa2lwcGVkLWZpbGUgZmluZGluZyBjb2RlIGRvd24gdG8gV2ViS2l0UG9y dAorICAgICAgICAgLSBSZW1vdmUgdGlnZXIgc3VwcG9ydC4KKyAgICAgICAgKiBTY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weToKKyAgICAgICAgKiBTY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5OgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5OgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5OgorICAgICAgICAg LSBUZXN0V2ViS2l0UG9ydCBpcyBtdWNoIGVhc2llciB0byB3cml0ZSBub3cgdGhhdCBjb25maWcu cHkgbmV2ZXIgYmxlZWRzCisgICAgICAgICAgIGFic29sdXRlIHBhdGhzLgorICAgICAgICAgLSBQ YXNzIE1vY2tVc2VyIGFuZCBNb2NrRmlsZVN5c3RlbSBieSBkZWZhdWx0IHRvIHByZXZlbnQgVGVz dFdlYktpdFBvcnQgZnJvbSBsZWFraW5nIHN5c3RlbSBkYXRhIHRvIHVuaXR0ZXN0IHJlc3VsdHMu CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0 cy5weTogInRoZWFkIiAtPiAidGhyZWFkIgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9v bC9jb21tYW5kcy9yZWJhc2VsaW5lLnB5OiBUaWdlciBpcyBkZWFkLgorCiAyMDExLTA2LTI5ICBF cmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAgICAgICBBZGFtIHNheXMgY293Ym95 cyBkb24ndCByZXZpZXcgKG9yIHVuaXQgdGVzdCkuCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggZmFiY2Y2MTY4MzA4M2IwOGVjNjA1 YTE5ZjFmZjA4ZTdjNDAzZTA3NS4uMDNlNDM3MzgzNTg1YTgwMjBmN2MyYzk3NTc2MTA2ZDIxNWMy N2Y0YSAxMDA3NTUKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9iYXNlLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv YmFzZS5weQpAQCAtOTEsMTAgKzkxLDExIEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAg ICAgICAgICAgZmlsZXN5c3RlbT1Ob25lLAogICAgICAgICAgICAgICAgICBjb25maWc9Tm9uZSwK ICAgICAgICAgICAgICAgICAgKiprd2FyZ3MpOgotICAgICAgICBzZWxmLl9uYW1lID0gcG9ydF9u YW1lCisgICAgICAgIHNlbGYuX3BvcnRfbmFtZSA9IHBvcnRfbmFtZQogCiAgICAgICAgICMgVGhl c2UgYXJlIGRlZmF1bHQgdmFsdWVzIHRoYXQgc2hvdWxkIGJlIG92ZXJyaWRkZW4gaW4gYSBzdWJj bGFzc2VzLgogICAgICAgICAjIEZJWE1FOiBUaGVzZSBzaG91bGQgcmVhbGx5IGJlIHBhc3NlZCBp bi4KKyAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSAgIyBTdWJjbGFzc2VzIG1heSBhcHBl bmQgYSAtVkVSU0lPTiAobGlrZSBtYWMtbGVvcGFyZCkuCiAgICAgICAgIHNlbGYuX29wZXJhdGlu Z19zeXN0ZW0gPSAnbWFjJwogICAgICAgICBzZWxmLl92ZXJzaW9uID0gJycKICAgICAgICAgc2Vs Zi5fYXJjaGl0ZWN0dXJlID0gJ3g4NicKQEAgLTE2MywxMCArMTY0LDggQEAgY2xhc3MgUG9ydChv YmplY3QpOgogICAgICAgICByZXR1cm4gJ3RocmVhZHMnCiAKICAgICBkZWYgYmFzZWxpbmVfcGF0 aChzZWxmKToKLSAgICAgICAgIiIiUmV0dXJuIHRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSBkaXJl Y3RvcnkgdG8gc3RvcmUgbmV3IGJhc2VsaW5lcwotICAgICAgICBpbiBmb3IgdGhpcyBwb3J0LiIi IgotICAgICAgICBiYXNlbGluZV9zZWFyY2hfcGF0aHMgPSBcCi0gICAgICAgICAgICBzZWxmLmdl dF9vcHRpb24oJ2FkZGl0aW9uYWxfcGxhdGZvcm1fZGlyZWN0b3J5JywgW10pICsgc2VsZi5iYXNl bGluZV9zZWFyY2hfcGF0aCgpCisgICAgICAgICIiIlJldHVybiB0aGUgYWJzb2x1dGUgcGF0aCB0 byB0aGUgZGlyZWN0b3J5IHRvIHN0b3JlIG5ldyBiYXNlbGluZXMgaW4gZm9yIHRoaXMgcG9ydC4i IiIKKyAgICAgICAgYmFzZWxpbmVfc2VhcmNoX3BhdGhzID0gc2VsZi5nZXRfb3B0aW9uKCdhZGRp dGlvbmFsX3BsYXRmb3JtX2RpcmVjdG9yeScsIFtdKSArIHNlbGYuYmFzZWxpbmVfc2VhcmNoX3Bh dGgoKQogICAgICAgICByZXR1cm4gYmFzZWxpbmVfc2VhcmNoX3BhdGhzWzBdCiAKICAgICBkZWYg YmFzZWxpbmVfc2VhcmNoX3BhdGgoc2VsZik6CkBAIC01MzgsMTAgKzUzNywyMSBAQCBjbGFzcyBQ b3J0KG9iamVjdCk6CiAgICAgICAgICIiIkNyZWF0ZXMgdGhlIHNwZWNpZmllZCBkaXJlY3Rvcnkg aWYgaXQgZG9lc24ndCBhbHJlYWR5IGV4aXN0LiIiIgogICAgICAgICBzZWxmLl9maWxlc3lzdGVt Lm1heWJlX21ha2VfZGlyZWN0b3J5KCpwYXRoKQogCisgICAgZGVmIHBvcnRfbmFtZShzZWxmKToK KyAgICAgICAgIiIiVGhlIGJhc2UgbmFtZSBvZiB0aGUgcG9ydCAoZS5nLiBtYWMsIHdpbiwgcXQs IGNocm9taXVtLCBldGMuKS4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYuX3BvcnRfbmFtZQorCiAg ICAgZGVmIG5hbWUoc2VsZik6Ci0gICAgICAgICIiIlJldHVybiB0aGUgbmFtZSBvZiB0aGUgcG9y dCAoZS5nLiwgJ21hYycsICdjaHJvbWl1bS13aW4teHAnKS4iIiIKKyAgICAgICAgIiIiUmV0dXJu cyBhIG5hbWUgdGhhdCB1bmlxdWVseSBpZGVudGlmaWVzIHRoaXMgcGFydGljdWxhciB0eXBlIG9m IHBvcnQKKyAgICAgICAgKGUuZy4sICJtYWMtc25vd2xlb3BhcmQiIG9yICJjaHJvbWl1bS1ncHUt bGludXgteDg2X3g2NCIgYW5kIGNhbiBiZSBwYXNzZWQKKyAgICAgICAgdG8gZmFjdG9yeS5nZXQo KSB0byBpbnN0YW50aWF0ZSB0aGUgcG9ydC4iIiIKICAgICAgICAgcmV0dXJuIHNlbGYuX25hbWUK IAorICAgIGRlZiByZWFsX25hbWUoc2VsZik6CisgICAgICAgICMgRklYTUU6IFNlZW1zIHRoaXMg aXMgdXNlZCBmb3IgTW9ja0RSVCBhbmQgc2hvdWxkIGJlIHJlbW92ZWQuCisgICAgICAgICIiIlJl dHVybnMgdGhlIG5hbWUgb2YgdGhlIHBvcnQgYXMgcGFzc2VkIHRvIHRoZSAtLXBsYXRmb3JtIGNv bW1hbmQgbGluZSBhcmd1bWVudC4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYubmFtZSgpCisKICAg ICBkZWYgb3BlcmF0aW5nX3N5c3RlbShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX29wZXJh dGluZ19zeXN0ZW0KIApAQCAtNTY4LDEwICs1NzgsNiBAQCBjbGFzcyBQb3J0KG9iamVjdCk6CiAg ICAgZGVmIGFyY2hpdGVjdHVyZShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX2FyY2hpdGVj dHVyZQogCi0gICAgZGVmIHJlYWxfbmFtZShzZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyB0aGUg YWN0dWFsIG5hbWUgb2YgdGhlIHBvcnQsIG5vdCB0aGUgZGVsZWdhdGUncy4iIiIKLSAgICAgICAg cmV0dXJuIHNlbGYubmFtZSgpCi0KICAgICBkZWYgZ2V0X29wdGlvbihzZWxmLCBuYW1lLCBkZWZh dWx0X3ZhbHVlPU5vbmUpOgogICAgICAgICAjIEZJWE1FOiBFdmVudHVhbGx5IHdlIHNob3VsZCBu b3QgaGF2ZSB0byBkbyBhIHRlc3QgZm9yCiAgICAgICAgICMgaGFzYXR0cigpLCBhbmQgd2Ugc2hv dWxkIGJlIGFibGUgdG8ganVzdCBkbwpAQCAtNjQxLDggKzY0Nyw3IEBAIGNsYXNzIFBvcnQob2Jq ZWN0KToKICAgICAgICAgcmV0dXJuIHNlbGYuX3VzZXIub3Blbl91cmwocmVzdWx0c19maWxlbmFt ZSkKIAogICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgotICAgICAg ICAiIiJSZXR1cm4gYSBuZXdseSBjcmVhdGVkIGJhc2UuRHJpdmVyIHN1YmNsYXNzIGZvciBzdGFy dGluZy9zdG9wcGluZwotICAgICAgICB0aGUgdGVzdCBkcml2ZXIuIiIiCisgICAgICAgICIiIlJl dHVybiBhIG5ld2x5IGNyZWF0ZWQgYmFzZS5Ecml2ZXIgc3ViY2xhc3MgZm9yIHN0YXJ0aW5nL3N0 b3BwaW5nIHRoZSB0ZXN0IGRyaXZlci4iIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRF cnJvcignUG9ydC5jcmVhdGVfZHJpdmVyJykKIAogICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZik6 CkBAIC04NzYsOCArODgxLDcgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICByYWlzZSBO b3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0Ll9wYXRoX3RvX2hlbHBlcicpCiAKICAgICBkZWYgX3Bh dGhfdG9faW1hZ2VfZGlmZihzZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyB0aGUgZnVsbCBwYXRo IHRvIHRoZSBpbWFnZV9kaWZmIGJpbmFyeSwgb3IgTm9uZSBpZiBpdAotICAgICAgICBpcyBub3Qg YXZhaWxhYmxlLgorICAgICAgICAiIiJSZXR1cm5zIHRoZSBmdWxsIHBhdGggdG8gdGhlIGltYWdl X2RpZmYgYmluYXJ5LCBvciBOb25lIGlmIGl0IGlzIG5vdCBhdmFpbGFibGUuCiAKICAgICAgICAg VGhpcyBpcyBsaWtlbHkgdXNlZCBvbmx5IGJ5IGRpZmZfaW1hZ2UoKSIiIgogICAgICAgICByYWlz ZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0LnBhdGhfdG9faW1hZ2VfZGlmZicpCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xp bnV4LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bV9saW51eC5weQppbmRleCAxZWJhMjY2MmExZTU2ODQ3NzY0NzM4ZTJlMzg1ZDA4YTY1ZGI1OWU3 Li4xMjExMDM1NDJjYWZhOTU1MzU4OWI3OWU3NzA5ZjlmZWEwYzNiZWU0IDEwMDY0NAotLS0gYS9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5 CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1f bGludXgucHkKQEAgLTQ1LDEyICs0NSw3IEBAIGNsYXNzIENocm9taXVtTGludXhQb3J0KGNocm9t aXVtLkNocm9taXVtUG9ydCk6CiAgICAgICAgICd4ODYnOiBbJ2Nocm9taXVtLWxpbnV4LXg4Nics ICdjaHJvbWl1bS1saW51eCcsICdjaHJvbWl1bS13aW4nLCAnY2hyb21pdW0nLCAnd2luJywgJ21h YyddLAogICAgIH0KIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgKipr d2FyZ3MpOgotICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25hbWUgb3IgJ2Nocm9taXVtLWxpbnV4 JwotICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1l PXBvcnRfbmFtZSwgKiprd2FyZ3MpCi0KLSAgICAgICAgIyBXZSByZS1zZXQgdGhlIHBvcnQgbmFt ZSBvbmNlIHRoZSBiYXNlIG9iamVjdCBpcyBmdWxseSBpbml0aWFsaXplZAotICAgICAgICAjIGlu IG9yZGVyIHRvIGJlIGFibGUgdG8gZmluZCB0aGUgRFJUIGJpbmFyeSBwcm9wZXJseS4KKyAgICBk ZWYgX3BhcnNlX3BvcnRfbmFtZShzZWxmLCBwb3J0X25hbWUpOgogICAgICAgICBpZiBwb3J0X25h bWUuZW5kc3dpdGgoJy1saW51eCcpOgogICAgICAgICAgICAgc2VsZi5fYXJjaGl0ZWN0dXJlID0g c2VsZi5fZGV0ZXJtaW5lX2FyY2hpdGVjdHVyZSgpCiAgICAgICAgICAgICAjIEZJWE1FOiB0aGlz IGlzIGFuIHVnbHkgaGFjayB0byBhdm9pZCByZW5hbWluZyB0aGUgR1BVIHBvcnQuCkBAIC02NCwx MCArNTksMTggQEAgY2xhc3MgQ2hyb21pdW1MaW51eFBvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0 KToKICAgICAgICAgYXNzZXJ0IHBvcnRfbmFtZSBpbiAoJ2Nocm9taXVtLWxpbnV4JywgJ2Nocm9t aXVtLWdwdS1saW51eCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdjaHJvbWl1bS1s aW51eC14ODYnLCAnY2hyb21pdW0tbGludXgteDg2XzY0JywKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgJ2Nocm9taXVtLWdwdS1saW51eC14ODZfNjQnKQorICAgICAgICBzZWxmLl9wb3J0 X25hbWUgPSAnY2hyb21pdW0tbGludXgnICAjIFRoaXMgbWF5IGJlIHdyb25nLCBidXQgc2VlbXMg dG8gbWF0Y2ggdGhlICJ1Z2x5IGhhY2sgdG8gYXZvaWQgcmVuYW1pbmcgdGhlIEdQVSBwb3J0IiBh Ym92ZS4KICAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZQotICAgICAgICBzZWxmLl9vcGVy YXRpbmdfc3lzdGVtID0gJ2xpbnV4JwogICAgICAgICBzZWxmLl92ZXJzaW9uID0gJ2x1Y2lkJyAg IyBXZSBvbmx5IHN1cHBvcnQgbHVjaWQgcmlnaHQgbm93LgogCisgICAgZGVmIF9faW5pdF9fKHNl bGYsIHBvcnRfbmFtZT1Ob25lLCAqKmt3YXJncyk6CisgICAgICAgIHBvcnRfbmFtZSA9IHBvcnRf bmFtZSBvciAnY2hyb21pdW0tbGludXgnCisgICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5f X2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICAgICAgIyBX ZSByZS1zZXQgdGhlIHBvcnQgbmFtZSBvbmNlIHRoZSBiYXNlIG9iamVjdCBpcyBmdWxseSBpbml0 aWFsaXplZAorICAgICAgICAjIGluIG9yZGVyIHRvIGJlIGFibGUgdG8gZmluZCB0aGUgRFJUIGJp bmFyeSBwcm9wZXJseS4KKyAgICAgICAgc2VsZi5fcGFyc2VfcG9ydF9uYW1lKHBvcnRfbmFtZSkK KyAgICAgICAgc2VsZi5fb3BlcmF0aW5nX3N5c3RlbSA9ICdsaW51eCcKKwogICAgIGRlZiBfZGV0 ZXJtaW5lX2FyY2hpdGVjdHVyZShzZWxmKToKICAgICAgICAgZHJpdmVyX3BhdGggPSBzZWxmLl9w YXRoX3RvX2RyaXZlcigpCiAgICAgICAgIGZpbGVfb3V0cHV0ID0gJycKZGlmZiAtLWdpdCBhL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5IGIv VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHkK aW5kZXggYzdlOTc3YzM2MmY3YmI2OTJjZmMyYmM4YmM3N2Q4OWVlZDFhZDVkNC4uMGI2OTlhMmY4 MWVmMzlkMzMxYmFhNmVmYzVkNGExZjgwYmQxOTgzYyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHkKKysrIGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMucHkKQEAgLTY3 LDE3ICs2NywyMSBAQCBjbGFzcyBDaHJvbWl1bU1hY1BvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0 KToKICAgICAgICAgXSwKICAgICB9CiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1l PU5vbmUsIG9zX3ZlcnNpb25fc3RyaW5nPU5vbmUsICoqa3dhcmdzKToKLSAgICAgICAgIyBXZSdy ZSBhIGxpdHRsZSBnZW5lcmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUgaXMgcmV1c2VkIGJ5IHRo ZQotICAgICAgICAjICdnb29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwgYXMgdGhlICdtb2NrLScg YW5kICdkcnlydW4tJyBwb3J0cy4KLSAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdj aHJvbWl1bS1tYWMnCi0gICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxm LCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICBkZWYgX3BhcnNlX3BvcnRfbmFt ZShzZWxmLCBwb3J0X25hbWUsIG9zX3ZlcnNpb25fc3RyaW5nKToKICAgICAgICAgaWYgcG9ydF9u YW1lLmVuZHN3aXRoKCctbWFjJyk6CiAgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gbWFjLm9z X3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmcsIHNlbGYuU1VQUE9SVEVEX09TX1ZFUlNJT05TKQog ICAgICAgICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSArICctJyArIHNlbGYuX3ZlcnNpb24K ICAgICAgICAgZWxzZToKLSAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbcG9y dF9uYW1lLmluZGV4KCctbWFjLScpICsgNTpdCisgICAgICAgICAgICBzZWxmLl9wb3J0X25hbWUg PSBwb3J0X25hbWVbOnBvcnRfbmFtZS5pbmRleCgnLW1hYy0nKSArIGxlbignLW1hYycpXQorICAg ICAgICAgICAgc2VsZi5fdmVyc2lvbiA9IHBvcnRfbmFtZVtwb3J0X25hbWUuaW5kZXgoJy1tYWMt JykgKyBsZW4oJy1tYWMtJyk6XQogICAgICAgICAgICAgYXNzZXJ0IHNlbGYuX3ZlcnNpb24gaW4g c2VsZi5TVVBQT1JURURfT1NfVkVSU0lPTlMKKworICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0 X25hbWU9Tm9uZSwgb3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwgKiprd2FyZ3MpOgorICAgICAgICAj IFdlJ3JlIGEgbGl0dGxlIGdlbmVyaWMgaGVyZSBiZWNhdXNlIHRoaXMgY29kZSBpcyByZXVzZWQg YnkgdGhlCisgICAgICAgICMgJ2dvb2dsZS1jaHJvbWUnIHBvcnQgYXMgd2VsbCBhcyB0aGUgJ21v Y2stJyBhbmQgJ2RyeXJ1bi0nIHBvcnRzLgorICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25hbWUg b3IgJ2Nocm9taXVtLW1hYycKKyAgICAgICAgY2hyb21pdW0uQ2hyb21pdW1Qb3J0Ll9faW5pdF9f KHNlbGYsIHBvcnRfbmFtZT1wb3J0X25hbWUsICoqa3dhcmdzKQorICAgICAgICBzZWxmLl9wYXJz ZV9wb3J0X25hbWUocG9ydF9uYW1lLCBvc192ZXJzaW9uX3N0cmluZykKICAgICAgICAgc2VsZi5f b3BlcmF0aW5nX3N5c3RlbSA9ICdtYWMnCiAKICAgICBkZWYgYmFzZWxpbmVfc2VhcmNoX3BhdGgo c2VsZik6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L2Nocm9taXVtX3dpbi5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvY2hyb21pdW1fd2luLnB5CmluZGV4IGI5MDNjM2ZlMmEyN2UwZjAzYTA4ZjdiZWNhZDJh NGExZmNkNWIyNGIuLjVhZjk3ZWQxNWIzYTU4ZDAyYWQ3YzZhNjVkNzRmMzg0ZGJkOGE2NzggMTAw NzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21p dW1fd2luLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv Y2hyb21pdW1fd2luLnB5CkBAIC02NSwxOCArNjUsMjEgQEAgY2xhc3MgQ2hyb21pdW1XaW5Qb3J0 KGNocm9taXVtLkNocm9taXVtUG9ydCk6CiAgICAgICAgICd3aW43JzogWydjaHJvbWl1bS13aW4n LCAnY2hyb21pdW0nLCAnd2luJywgJ21hYyddLAogICAgIH0KIAotICAgIGRlZiBfX2luaXRfXyhz ZWxmLCBwb3J0X25hbWU9Tm9uZSwgd2luZG93c192ZXJzaW9uPU5vbmUsICoqa3dhcmdzKToKLSAg ICAgICAgIyBXZSdyZSBhIGxpdHRsZSBnZW5lcmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUgaXMg cmV1c2VkIGJ5IHRoZQotICAgICAgICAjICdnb29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwgYXMg dGhlICdtb2NrLScgYW5kICdkcnlydW4tJyBwb3J0cy4KLSAgICAgICAgcG9ydF9uYW1lID0gcG9y dF9uYW1lIG9yICdjaHJvbWl1bS13aW4nCi0gICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5f X2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICBkZWYgX3Bh cnNlX3BvcnRfbmFtZShzZWxmLCBwb3J0X25hbWUsIHdpbmRvd3NfdmVyc2lvbik6CiAgICAgICAg IGlmIHBvcnRfbmFtZS5lbmRzd2l0aCgnLXdpbicpOgogICAgICAgICAgICAgc2VsZi5fdmVyc2lv biA9IG9zX3ZlcnNpb24od2luZG93c192ZXJzaW9uKQogICAgICAgICAgICAgc2VsZi5fbmFtZSA9 IHBvcnRfbmFtZSArICctJyArIHNlbGYuX3ZlcnNpb24KICAgICAgICAgZWxzZToKLSAgICAgICAg ICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbcG9ydF9uYW1lLmluZGV4KCctd2luLScpICsg NTpdCi0gICAgICAgICAgICBhc3NlcnQgc2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9W RVJTSU9OUworICAgICAgICAgICAgc2VsZi5fcG9ydF9uYW1lID0gcG9ydF9uYW1lWzpwb3J0X25h bWUuaW5kZXgoJy13aW4tJykgKyBsZW4oJy13aW4nKV0KKyAgICAgICAgICAgIHNlbGYuX3ZlcnNp b24gPSBwb3J0X25hbWVbcG9ydF9uYW1lLmluZGV4KCctd2luLScpICsgbGVuKCctd2luLScpOl0K KyAgICAgICAgICAgIGFzc2VydCBzZWxmLl92ZXJzaW9uIGluIHNlbGYuU1VQUE9SVEVEX1ZFUlNJ T05TLCAiJXMgaXMgbm90IGluICVzIiAlIChzZWxmLl92ZXJzaW9uLCBzZWxmLlNVUFBPUlRFRF9W RVJTSU9OUykKIAorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgd2luZG93 c192ZXJzaW9uPU5vbmUsICoqa3dhcmdzKToKKyAgICAgICAgIyBXZSdyZSBhIGxpdHRsZSBnZW5l cmljIGhlcmUgYmVjYXVzZSB0aGlzIGNvZGUgaXMgcmV1c2VkIGJ5IHRoZQorICAgICAgICAjICdn b29nbGUtY2hyb21lJyBwb3J0IGFzIHdlbGwgYXMgdGhlICdtb2NrLScgYW5kICdkcnlydW4tJyBw b3J0cy4KKyAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdjaHJvbWl1bS13aW4nCisg ICAgICAgIGNocm9taXVtLkNocm9taXVtUG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9cG9y dF9uYW1lLCAqKmt3YXJncykKKyAgICAgICAgc2VsZi5fcGFyc2VfcG9ydF9uYW1lKHBvcnRfbmFt ZSwgd2luZG93c192ZXJzaW9uKQogICAgICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0gJ3dp bicKIAogICAgIGRlZiBzZXR1cF9lbnZpcm9uX2Zvcl9zZXJ2ZXIoc2VsZik6CmRpZmYgLS1naXQg YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hYy5weSBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CmluZGV4IGE2ODVjMWJk YTE1M2FmYzMxMjZhNGM1Y2U3MmU2ZGI4NGU1MjE2MmIuLjU2MWQ5NWI2MjQ3ZmQyYjlhNzI3MjA1 ZTA4NjMzMmY3NzlmMzNlMjkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvbWFjLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3BvcnQvbWFjLnB5CkBAIC00OCw2ICs0OCw3IEBAIGRlZiBvc192ZXJzaW9uKG9zX3Zl cnNpb25fc3RyaW5nPU5vbmUsIHN1cHBvcnRlZF92ZXJzaW9ucz1Ob25lKToKICAgICB2ZXJzaW9u X3N0cmluZ3MgPSB7CiAgICAgICAgIDU6ICdsZW9wYXJkJywKICAgICAgICAgNjogJ3Nub3dsZW9w YXJkJywKKyAgICAgICAgIyBBZGQgNzogJ2xpb24nIGhlcmU/CiAgICAgfQogICAgIGFzc2VydCBy ZWxlYXNlX3ZlcnNpb24gPj0gbWluKHZlcnNpb25fc3RyaW5ncy5rZXlzKCkpCiAgICAgdmVyc2lv bl9zdHJpbmcgPSB2ZXJzaW9uX3N0cmluZ3MuZ2V0KHJlbGVhc2VfdmVyc2lvbiwgJ2Z1dHVyZScp CkBAIC01Nyw3ICs1OCw2IEBAIGRlZiBvc192ZXJzaW9uKG9zX3ZlcnNpb25fc3RyaW5nPU5vbmUs IHN1cHBvcnRlZF92ZXJzaW9ucz1Ob25lKToKIAogCiBjbGFzcyBNYWNQb3J0KFdlYktpdFBvcnQp OgotICAgICIiIldlYktpdCBNYWMgaW1wbGVtZW50YXRpb24gb2YgdGhlIFBvcnQgY2xhc3MuIiIi CiAgICAgIyBGSVhNRTogJ3drMicgcHJvYmFibHkgc2hvdWxkbid0IGJlIGEgdmVyc2lvbiwgaXQg c2hvdWxkIHByb2JhYmx5IGJlCiAgICAgIyBhIG1vZGlmaWVyLCBsaWtlICdjaHJvbWl1bS1ncHUn IGlzIHRvICdjaHJvbWl1bScuCiAgICAgU1VQUE9SVEVEX1ZFUlNJT05TID0gKCdsZW9wYXJkJywg J3Nub3dsZW9wYXJkJywgJ2Z1dHVyZScsICd3azInKQpAQCAtNjYsMTggKzY2LDI0IEBAIGNsYXNz IE1hY1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgICdsZW9wYXJkJzogWydtYWMtbGVvcGFyZCcs ICdtYWMtc25vd2xlb3BhcmQnLCAnbWFjJ10sCiAgICAgICAgICdzbm93bGVvcGFyZCc6IFsnbWFj LXNub3dsZW9wYXJkJywgJ21hYyddLAogICAgICAgICAnZnV0dXJlJzogWydtYWMnXSwKKyAgICAg ICAgIyBGSVhNRTogVGhpcyBpc24ndCBxdWl0ZSByaWdodCBmb3Igd2syLCBpdCBzaG91bGQgaW5j bHVkZSBtYWMtVkVSU0lPTiBhcyB3ZWxsLgogICAgICAgICAnd2syJzogWydtYWMtd2syJywgJ21h YyddLAogICAgIH0KIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0X25hbWU9Tm9uZSwgb3Nf dmVyc2lvbl9zdHJpbmc9Tm9uZSwgKiprd2FyZ3MpOgotICAgICAgICBwb3J0X25hbWUgPSBwb3J0 X25hbWUgb3IgJ21hYycKLSAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCBwb3J0X25h bWU9cG9ydF9uYW1lLCAqKmt3YXJncykKKyAgICBkZWYgX3BhcnNlX3BvcnRfbmFtZShzZWxmLCBw b3J0X25hbWUsIG9zX3ZlcnNpb25fc3RyaW5nKToKICAgICAgICAgaWYgcG9ydF9uYW1lID09ICdt YWMnOgogICAgICAgICAgICAgc2VsZi5fdmVyc2lvbiA9IG9zX3ZlcnNpb24ob3NfdmVyc2lvbl9z dHJpbmcpCiAgICAgICAgICAgICBzZWxmLl9uYW1lID0gcG9ydF9uYW1lICsgJy0nICsgc2VsZi5f dmVyc2lvbgogICAgICAgICBlbHNlOgotICAgICAgICAgICAgc2VsZi5fdmVyc2lvbiA9IHBvcnRf bmFtZVs0Ol0KLSAgICAgICAgICAgIGFzc2VydCBzZWxmLl92ZXJzaW9uIGluIHNlbGYuU1VQUE9S VEVEX1ZFUlNJT05TCisgICAgICAgICAgICBhc3NlcnQgcG9ydF9uYW1lLnN0YXJ0c3dpdGgoJ21h YycpCisgICAgICAgICAgICBzZWxmLl9wb3J0X25hbWUgPSAnbWFjJworICAgICAgICAgICAgc2Vs Zi5fdmVyc2lvbiA9IHBvcnRfbmFtZVtsZW4oJ21hYy0nKTpdCisgICAgICAgICAgICBhc3NlcnQg c2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUywgIiVzIGlzIG5vdCBpbiAl cyIgJSAoc2VsZi5fdmVyc2lvbiwgc2VsZi5TVVBQT1JURURfVkVSU0lPTlMpCisKKyAgICBkZWYg X19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsIG9zX3ZlcnNpb25fc3RyaW5nPU5vbmUsICoq a3dhcmdzKToKKyAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICdtYWMnCisgICAgICAg IFdlYktpdFBvcnQuX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3Mp CisgICAgICAgIHNlbGYuX3BhcnNlX3BvcnRfbmFtZShwb3J0X25hbWUsIG9zX3ZlcnNpb25fc3Ry aW5nKQogICAgICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0gJ21hYycKICAgICAgICAgaWYg bm90IGhhc2F0dHIoc2VsZi5fb3B0aW9ucywgJ3RpbWUtb3V0LW1zJykgb3Igc2VsZi5fb3B0aW9u cy50aW1lX291dF9tcyBpcyBOb25lOgogICAgICAgICAgICAgc2VsZi5fb3B0aW9ucy50aW1lX291 dF9tcyA9IDM1MDAwCkBAIC05NCwyNCArMTAwLDkgQEAgY2xhc3MgTWFjUG9ydChXZWJLaXRQb3J0 KToKICAgICBkZWYgYmFzZWxpbmVfc2VhcmNoX3BhdGgoc2VsZik6CiAgICAgICAgIHJldHVybiBt YXAoc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgsIHNlbGYuRkFMTEJBQ0tfUEFUSFNbc2VsZi5f dmVyc2lvbl0pCiAKLSAgICBkZWYgcGF0aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKHNlbGYp OgotICAgICAgICByZXR1cm4gc2VsZi5wYXRoX2Zyb21fd2Via2l0X2Jhc2UoJ0xheW91dFRlc3Rz JywgJ3BsYXRmb3JtJywKLSAgICAgICAgICAgJ21hYycsICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQn KQotCiAgICAgZGVmIGlzX2NyYXNoX3JlcG9ydGVyKHNlbGYsIHByb2Nlc3NfbmFtZSk6CiAgICAg ICAgIHJldHVybiByZS5zZWFyY2gocidSZXBvcnRDcmFzaCcsIHByb2Nlc3NfbmFtZSkKIAotICAg IGRlZiBfc2tpcHBlZF9maWxlX3BhdGhzKHNlbGYpOgotICAgICAgICAjIEZJWE1FOiBUaGlzIG1l dGhvZCB3aWxsIG5lZWQgdG8gYmUgbWFkZSB3b3JrIGZvciBub24tbWFjCi0gICAgICAgICMgcGxh dGZvcm1zIGFuZCBtb3ZlZCBpbnRvIGJhc2UuUG9ydC4KLSAgICAgICAgc2tpcHBlZF9maWxlcyA9 IFtdCi0gICAgICAgIGlmIHNlbGYuX25hbWUgaW4gKCdtYWMtbGVvcGFyZCcsICdtYWMtc25vd2xl b3BhcmQnKToKLSAgICAgICAgICAgIHNraXBwZWRfZmlsZXMuYXBwZW5kKHNlbGYuX2ZpbGVzeXN0 ZW0uam9pbigKLSAgICAgICAgICAgICAgICBzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxm Ll9uYW1lKSwgJ1NraXBwZWQnKSkKLSAgICAgICAgc2tpcHBlZF9maWxlcy5hcHBlbmQoc2VsZi5f ZmlsZXN5c3RlbS5qb2luKHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKCdtYWMnKSwKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdTa2lwcGVkJykpCi0gICAgICAg IHJldHVybiBza2lwcGVkX2ZpbGVzCi0KICAgICBkZWYgX2J1aWxkX2phdmFfdGVzdF9zdXBwb3J0 KHNlbGYpOgogICAgICAgICBqYXZhX3Rlc3RzX3BhdGggPSBzZWxmLl9maWxlc3lzdGVtLmpvaW4o c2VsZi5sYXlvdXRfdGVzdHNfZGlyKCksICJqYXZhIikKICAgICAgICAgYnVpbGRfamF2YSA9IFsi L3Vzci9iaW4vbWFrZSIsICItQyIsIGphdmFfdGVzdHNfcGF0aF0KQEAgLTEyNCw4ICsxMTUsNyBA QCBjbGFzcyBNYWNQb3J0KFdlYktpdFBvcnQpOgogICAgICAgICByZXR1cm4gc2VsZi5fYnVpbGRf amF2YV90ZXN0X3N1cHBvcnQoKQogCiAgICAgZGVmIF9wYXRoX3RvX2FwYWNoZV9jb25maWdfZmls ZShzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91 dF90ZXN0c19kaXIoKSwgJ2h0dHAnLCAnY29uZicsCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgJ2FwYWNoZTItaHR0cGQuY29uZicpCisgICAgICAgIHJldHVybiBzZWxmLl9m aWxlc3lzdGVtLmpvaW4oc2VsZi5sYXlvdXRfdGVzdHNfZGlyKCksICdodHRwJywgJ2NvbmYnLCAn YXBhY2hlMi1odHRwZC5jb25mJykKIAogICAgIGRlZiBfcGF0aF90b193ZWJjb3JlX2xpYnJhcnko c2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9wYXRoKCdXZWJDb3JlLmZyYW1ld29y ay9WZXJzaW9ucy9BL1dlYkNvcmUnKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9tYWNfdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weQppbmRleCAyOGZjODVlNmVhMjVk NWI5NTZhNDljMWNlMWYwNjk1YTYzMDA2NThlLi41NmExYzdkNjQ2OWYwMzkxNjgzZmFlYzI5ZWNm MDA4M2M4YTBlYmI2IDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L21hY191bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weQpAQCAtNDAsMjQgKzQwLDIwIEBAIGNsYXNz IE1hY1Rlc3QocG9ydF90ZXN0Y2FzZS5Qb3J0VGVzdENhc2UpOgogICAgICAgICAgICAgcmV0dXJu IE5vbmUKICAgICAgICAgcmV0dXJuIG1hYy5NYWNQb3J0CiAKLSAgICBkZWYgYXNzZXJ0X3NraXBw ZWRfZmlsZXNfZm9yX3ZlcnNpb24oc2VsZiwgcG9ydF9uYW1lLCBleHBlY3RlZF9wYXRocyk6Cisg ICAgZGVmIGFzc2VydF9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKHNlbGYsIHBvcnRfbmFtZSwg ZXhwZWN0ZWRfcGF0aHMpOgogICAgICAgICBwb3J0ID0gbWFjLk1hY1BvcnQocG9ydF9uYW1lPXBv cnRfbmFtZSkKLSAgICAgICAgc2tpcHBlZF9wYXRocyA9IHBvcnQuX3NraXBwZWRfZmlsZV9wYXRo cygpCi0gICAgICAgICMgRklYTUU6IF9za2lwcGVkX2ZpbGVfcGF0aHMgc2hvdWxkIHJldHVybiBX ZWJLaXQtcmVsYXRpdmUgcGF0aHMuCi0gICAgICAgICMgU28gdG8gbWFrZSBpdCB1bml0IHRlc3Rh YmxlLCB3ZSBzdHJpcCB0aGUgV2ViS2l0IGRpcmVjdG9yeSBmcm9tIHRoZSBwYXRoLgotICAgICAg ICByZWxhdGl2ZV9wYXRocyA9IFtwYXRoW2xlbihwb3J0LnBhdGhfZnJvbV93ZWJraXRfYmFzZSgp KTpdIGZvciBwYXRoIGluIHNraXBwZWRfcGF0aHNdCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo cmVsYXRpdmVfcGF0aHMsIGV4cGVjdGVkX3BhdGhzKQotCi0gICAgZGVmIHRlc3Rfc2tpcHBlZF9m aWxlX3BhdGhzKHNlbGYpOgotICAgICAgICAjIFdlIHNraXAgdGhpcyBvbiB3aW4zMiBiZWNhdXNl IHdlIHVzZSAnLycgYXMgdGhlIGRpciBzZXBhcmF0b3IgYW5kIGl0J3MKLSAgICAgICAgIyBub3Qg d29ydGggbWFraW5nIHBsYXRmb3JtLWluZGVwZW5kZW50LgorICAgICAgICBzZWxmLmFzc2VydEVx dWFsKHBvcnQuX3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoKSwgZXhwZWN0ZWRfcGF0aHMpCisK KyAgICBkZWYgdGVzdF9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKHNlbGYpOgorICAgICAgICAj IEZJWE1FOiBUaGlzIHNob3VsZCBubyBsb25nZXIgYmUgbmVjZXNzYXJ5LCBidXQgSSdtIG5vdCBi cmF2ZSBlbm91Z2ggdG8gcmVtb3ZlIGl0LgogICAgICAgICBpZiBzeXMucGxhdGZvcm0gPT0gJ3dp bjMyJzoKICAgICAgICAgICAgIHJldHVybiBOb25lCiAKLSAgICAgICAgc2VsZi5hc3NlcnRfc2tp cHBlZF9maWxlc19mb3JfdmVyc2lvbignbWFjLXNub3dsZW9wYXJkJywKLSAgICAgICAgICAgIFsn L0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy1zbm93bGVvcGFyZC9Ta2lwcGVkJywgJy9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMvU2tpcHBlZCddKQotICAgICAgICBzZWxmLmFzc2VydF9za2lwcGVk X2ZpbGVzX2Zvcl92ZXJzaW9uKCdtYWMtbGVvcGFyZCcsCi0gICAgICAgICAgICBbJy9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMtbGVvcGFyZC9Ta2lwcGVkJywgJy9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9tYWMvU2tpcHBlZCddKQorICAgICAgICBzZWxmLmFzc2VydF9za2lwcGVkX2ZpbGVfc2VhcmNo X3BhdGhzKCdtYWMtc25vd2xlb3BhcmQnLCBzZXQoWydtYWMtc25vd2xlb3BhcmQnLCAnbWFjJ10p KQorICAgICAgICBzZWxmLmFzc2VydF9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCdtYWMtbGVv cGFyZCcsIHNldChbJ21hYy1sZW9wYXJkJywgJ21hYyddKSkKKyAgICAgICAgIyBXZSBjYW5ub3Qg dGVzdCBqdXN0ICJtYWMiIGhlcmUgYXMgdGhlIE1hY1BvcnQgY29uc3RydWN0b3IgYXV0b21hdGlj YWxseSBmaWxscyBpbiB0aGUgdmVyc2lvbiBmcm9tIHRoZSBydW5uaW5nIE9TLgorICAgICAgICAj IHNlbGYuYXNzZXJ0X3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoJ21hYycsIFsnbWFjJ10pCisK IAogICAgIGV4YW1wbGVfc2tpcHBlZF9maWxlID0gdSIiIgogIyA8cmRhcjovL3Byb2JsZW0vNTY0 Nzk1Mj4gZmFzdC9ldmVudHMvbW91c2VvdXQtb24td2luZG93Lmh0bWwgbmVlZHMgbWFjIERSVCB0 byBpc3N1ZSBtb3VzZSBvdXQgZXZlbnRzCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5CmluZGV4IDc1YWEwNWFkOTZiMTI0ZDQ0NzMwNTI2 NzYwZDgzMDk3ZGViYWJiMGQuLmI4NzY3YTQ0ZWZjYzkwNTM2NmQyMTBjNzQ5ZWQ1MTNkZTk0OTk0 MjcgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2Via2l0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2Via2l0LnB5CkBAIC02NSwxMiArNjUsMjEgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQp OgogICAgICAgICAgICAgcmV0dXJuICJXZWJLaXRUZXN0UnVubmVyIgogICAgICAgICByZXR1cm4g IkR1bXBSZW5kZXJUcmVlIgogCisgICAgIyBGSVhNRTogVGhpcyBpcyBub3QgYSB2ZXJ5IHVzZWZ1 bCBkZWZhdWx0IGltcGxlbWVudGF0aW9uLCBhcyBpdHMgd3JvbmcgZm9yIGFueQorICAgICMgcG9y dCB3aGljaCByZXF1aXJlcyBwbGF0Zm9ybS1zcGVjZmljIHJlc3VsdHMuIFdlIHNob3VsZCByZXBs YWNlIHRoaXMgd2l0aCBhIHNtYXJ0ZXIKKyAgICAjIGltcGxlbWVudGF0aW9uIHNoYXJlZCBieSBh bGwgcG9ydHMuCiAgICAgZGVmIGJhc2VsaW5lX3NlYXJjaF9wYXRoKHNlbGYpOgotICAgICAgICBy ZXR1cm4gW3NlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpXQorICAgICAgICBz ZWFyY2hfcGF0aHMgPSBbc2VsZi5uYW1lKCldCisgICAgICAgIGlmIHNlbGYuZ2V0X29wdGlvbign d2Via2l0X3Rlc3RfcnVubmVyJyk6CisgICAgICAgICAgICBzZWFyY2hfcGF0aHMuaW5zZXJ0KDAs IHNlbGYud2syX3BvcnRfbmFtZSgpKQorICAgICAgICByZXR1cm4gc2VhcmNoX3BhdGhzCisKKyAg ICBkZWYgX2V4cGVjdGF0aW9uc19zZWFyY2hfcGF0aChzZWxmKToKKyAgICAgICAgIyB0ZXN0X2V4 cGVjdGF0aW9ucyBhcmUgYWx3YXlzIGluIG1hYy8gbm90IG1hYy1sZW9wYXJkLyBieSBjb252ZW50 aW9uLCBoZW5jZSB3ZSB1c2UgcG9ydF9uYW1lKCkgaW5zdGVhZCBvZiBuYW1lKCkuCisgICAgICAg IHJldHVybiBzZWxmLndrMl9wb3J0X25hbWUoKSBpZiBzZWxmLmdldF9vcHRpb24oJ3dlYmtpdF90 ZXN0X3J1bm5lcicpIGVsc2Ugc2VsZi5wb3J0X25hbWUoKQogCiAgICAgZGVmIHBhdGhfdG9fdGVz dF9leHBlY3RhdGlvbnNfZmlsZShzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0 ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxmLl9uYW1lKSwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAndGVzdF9leHBlY3RhdGlvbnMudHh0JykKKyAg ICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVf cGF0aChzZWxmLl9leHBlY3RhdGlvbnNfc2VhcmNoX3BhdGgoKSksICd0ZXN0X2V4cGVjdGF0aW9u cy50eHQnKQogCiAgICAgZGVmIF9yZXN1bHRzX2Zvcl9wbGF0Zm9ybShzZWxmLCBwbGF0Zm9ybSk6 CiAgICAgICAgIGJ1aWxkZXJfbmFtZSA9IGJ1aWxkZXJzLmJ1aWxkZXJfbmFtZV9mb3JfcGxhdGZv cm0ocGxhdGZvcm0pCkBAIC0yODQsMTIgKzI5MywyNSBAQCBjbGFzcyBXZWJLaXRQb3J0KGJhc2Uu UG9ydCk6CiAgICAgICAgICAgICB0ZXN0c190b19za2lwLmFwcGVuZChsaW5lKQogICAgICAgICBy ZXR1cm4gdGVzdHNfdG9fc2tpcAogCi0gICAgZGVmIF9za2lwcGVkX2ZpbGVfcGF0aHMoc2VsZik6 Ci0gICAgICAgIHJldHVybiBbc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYuX3dlYmtpdF9iYXNl bGluZV9wYXRoKHNlbGYuX25hbWUpLCAnU2tpcHBlZCcpXQorICAgIGRlZiB3azJfcG9ydF9uYW1l KHNlbGYpOgorICAgICAgICByZXR1cm4gIiVzLXdrMiIgJSBzZWxmLnBvcnRfbmFtZSgpCisKKyAg ICBkZWYgX3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoc2VsZik6CisgICAgICAgICMgVW5saWtl IGJhc2VsaW5lX3NlYXJjaF9wYXRoLCB3ZSBvbmx5IHdhbnQgdG8gc2VhcmNoIFtXSzItUE9SVCwg UE9SVC1WRVJTSU9OLCBQT1JUXSBub3QgdGhlIGZ1bGwgY2FzYWRlLgorICAgICAgICAjIE5vdGUg b3JkZXIgZG9lc24ndCBtYXR0ZXIgc2luY2UgdGhlIFNraXBwZWQgZmlsZSBjb250ZW50cyBhcmUg YWxsIGNvbWJpbmVkLgorICAgICAgICBzZWFyY2hfcGF0aHMgPSBzZXQoW3NlbGYucG9ydF9uYW1l KCksIHNlbGYubmFtZSgpXSkKKyAgICAgICAgaWYgc2VsZi5nZXRfb3B0aW9uKCd3ZWJraXRfdGVz dF9ydW5uZXInKToKKyAgICAgICAgICAgICMgUXVvdGluZyBvbGQtcnVuLXdlYmtpdC10ZXN0czoK KyAgICAgICAgICAgICMgQmVjYXVzZSBuZWFybHkgYWxsIG9mIHRoZSBza2lwcGVkIHRlc3RzIGZv ciBXZWJLaXQgMiBvbiBNYWMgYXJlIGR1ZSB0bworICAgICAgICAgICAgIyBjcm9zcy1wbGF0Zm9y bSBpc3N1ZXMsIHRoZSBXaW5kb3dzIGFuZCBRdCBwb3J0cyB1c2UgdGhlIE1hYyBza2lwcGVkIGxp c3QKKyAgICAgICAgICAgICMgYWRkaXRpb25hbGx5IHRvIHRoZWlyIG93biB0byBhdm9pZCBtYWlu dGFpbmluZyBzZXBhcmF0ZSBsaXN0cy4KKyAgICAgICAgICAgIHNlYXJjaF9wYXRocy51cGRhdGUo W3NlbGYud2syX3BvcnRfbmFtZSgpLCAibWFjLXdrMiJdKQorICAgICAgICByZXR1cm4gc2VhcmNo X3BhdGhzCiAKICAgICBkZWYgX2V4cGVjdGF0aW9uc19mcm9tX3NraXBwZWRfZmlsZXMoc2VsZik6 CiAgICAgICAgIHRlc3RzX3RvX3NraXAgPSBbXQotICAgICAgICBmb3IgZmlsZW5hbWUgaW4gc2Vs Zi5fc2tpcHBlZF9maWxlX3BhdGhzKCk6CisgICAgICAgIGZvciBzZWFyY2hfcGF0aCBpbiBzZWxm Ll9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCk6CisgICAgICAgICAgICBmaWxlbmFtZSA9IHNl bGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLl93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWFyY2hfcGF0 aCksICJTa2lwcGVkIikKICAgICAgICAgICAgIGlmIG5vdCBzZWxmLl9maWxlc3lzdGVtLmV4aXN0 cyhmaWxlbmFtZSk6CiAgICAgICAgICAgICAgICAgX2xvZy53YXJuKCJGYWlsZWQgdG8gb3BlbiBT a2lwcGVkIGZpbGU6ICVzIiAlIGZpbGVuYW1lKQogICAgICAgICAgICAgICAgIGNvbnRpbnVlCkBA IC0yOTgsMTIgKzMyMCwxNCBAQCBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAg IHJldHVybiB0ZXN0c190b19za2lwCiAKICAgICBkZWYgdGVzdF9leHBlY3RhdGlvbnMoc2VsZik6 Ci0gICAgICAgICMgVGhlIFdlYktpdCBtYWMgcG9ydCB1c2VzIGEgY29tYmluYXRpb24gb2YgYSB0 ZXN0X2V4cGVjdGF0aW9ucyBmaWxlCi0gICAgICAgICMgYW5kICdTa2lwcGVkJyBmaWxlcy4KKyAg ICAgICAgIyBUaGlzIGFsbG93cyBwb3J0cyB0byB1c2UgYSBjb21iaW5hdGlvbiBvZiB0ZXN0X2V4 cGVjdGF0aW9ucy50eHQgZmlsZXMgYW5kIFNraXBwZWQgbGlzdHMuCisgICAgICAgIGV4cGVjdGF0 aW9ucyA9IHNlbGYuX3NraXBwZWRfbGlzdF9hc19leHBlY3RhdGlvbnMoKQogICAgICAgICBleHBl Y3RhdGlvbnNfcGF0aCA9IHNlbGYucGF0aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKCkKLSAg ICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0ucmVhZF90ZXh0X2ZpbGUoZXhwZWN0YXRpb25z X3BhdGgpICsgc2VsZi5fc2tpcHMoKQorICAgICAgICBpZiBzZWxmLl9maWxlc3lzdGVtLmV4aXN0 cyhleHBlY3RhdGlvbnNfcGF0aCk6CisgICAgICAgICAgICBleHBlY3RhdGlvbnMgKz0gc2VsZi5f ZmlsZXN5c3RlbS5yZWFkX3RleHRfZmlsZShleHBlY3RhdGlvbnNfcGF0aCkKKyAgICAgICAgcmV0 dXJuIGV4cGVjdGF0aW9ucwogCi0gICAgZGVmIF9za2lwcyhzZWxmKToKKyAgICBkZWYgX3NraXBw ZWRfbGlzdF9hc19leHBlY3RhdGlvbnMoc2VsZik6CiAgICAgICAgICMgRWFjaCBTa2lwcGVkIGZp bGUgY29udGFpbnMgYSBsaXN0IG9mIGZpbGVzCiAgICAgICAgICMgb3IgZGlyZWN0b3JpZXMgdG8g YmUgc2tpcHBlZCBkdXJpbmcgdGhlIHRlc3QgcnVuLiBUaGUgdG90YWwgbGlzdAogICAgICAgICAj IG9mIHRlc3RzIHRvIHNraXBwZWQgaXMgZ2l2ZW4gYnkgdGhlIGNvbnRlbnRzIG9mIHRoZSBnZW5l cmljCkBAIC0zMTMsOCArMzM3LDcgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAg ICAgICAjIGZvcm1hdCBleHBlY3RlZCBieSB0ZXN0X2V4cGVjdGF0aW9ucy4KIAogICAgICAgICB0 ZXN0c190b19za2lwID0gc2VsZi5za2lwcGVkX2xheW91dF90ZXN0cygpCi0gICAgICAgIHNraXBf bGluZXMgPSBtYXAobGFtYmRhIHRlc3RfcGF0aDogIkJVR19TS0lQUEVEIFNLSVAgOiAlcyA9IEZB SUwiICUKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9wYXRoLCB0ZXN0c190 b19za2lwKQorICAgICAgICBza2lwX2xpbmVzID0gbWFwKGxhbWJkYSB0ZXN0X3BhdGg6ICJCVUdf U0tJUFBFRCBTS0lQIDogJXMgPSBGQUlMIiAlIHRlc3RfcGF0aCwgdGVzdHNfdG9fc2tpcCkKICAg ICAgICAgcmV0dXJuICJcbiIuam9pbihza2lwX2xpbmVzKQogCiAgICAgZGVmIHNraXBwZWRfbGF5 b3V0X3Rlc3RzKHNlbGYpOgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC93ZWJraXRfdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdF91bml0dGVzdC5weQppbmRleCA0MWY4NWZhYWRhM2Qw YmY3NWMyNWJjYzVlYjNkNzRkNTY5Nzk5NzdjLi4zOWIwM2JhMGI3NDY5YjM2NDhkYzM1YzA5Mzg3 OTJhNGJjZGFiYmVlIDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L3dlYmtpdF91bml0dGVzdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdF91bml0dGVzdC5weQpAQCAtODksNiArODksMTQgQEAg Y2xhc3MgV2ViS2l0UG9ydFRlc3QocG9ydF90ZXN0Y2FzZS5Qb3J0VGVzdENhc2UpOgogICAgIGRl ZiB0ZXN0X3NraXBwZWRfbGF5b3V0X3Rlc3RzKHNlbGYpOgogICAgICAgICBzZWxmLmFzc2VydEVx dWFsKFRlc3RXZWJLaXRQb3J0KE5vbmUsIE5vbmUpLnNraXBwZWRfbGF5b3V0X3Rlc3RzKCksIHNl dChbIm1lZGlhIl0pKQogCisgICAgZGVmIHRlc3Rfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocyhz ZWxmKToKKyAgICAgICAgcG9ydCA9IFRlc3RXZWJLaXRQb3J0KCkKKyAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbChwb3J0Ll9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCksIHNldChbJ3Rlc3R3ZWJr aXRwb3J0J10pKQorICAgICAgICBwb3J0Ll9uYW1lID0gInRlc3QtdmVyc2lvbiIKKyAgICAgICAg c2VsZi5hc3NlcnRFcXVhbChwb3J0Ll9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhzKCksIHNldChb J3Rlc3QnLCAndGVzdC12ZXJzaW9uJ10pKQorICAgICAgICBwb3J0Ll9vcHRpb25zID0gTW9ja09w dGlvbnMod2Via2l0X3Rlc3RfcnVubmVyPVRydWUpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo cG9ydC5fc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygpLCBzZXQoWyd0ZXN0JywgJ3Rlc3QtdmVy c2lvbicsICd0ZXN0LXdrMicsICdtYWMtd2syJ10pKQorCiAgICAgZGVmIHRlc3RfdGVzdF9leHBl Y3RhdGlvbnMoc2VsZik6CiAgICAgICAgICMgQ2hlY2sgdGhhdCB3ZSByZWFkIGJvdGggdGhlIGV4 cGVjdGF0aW9ucyBmaWxlIGFuZCBhbnl0aGluZyBpbiBhCiAgICAgICAgICMgU2tpcHBlZCBmaWxl LCBhbmQgdGhhdCB3ZSBpbmNsdWRlIHRoZSBmZWF0dXJlIGFuZCBwbGF0Zm9ybSBjaGVja3MuCg== 99179 2011-06-29 16:33:31 -0700 2011-06-29 17:04:48 -0700 Patch bug-63501-20110629163330.patch text/plain 34810 eric U3VidmVyc2lvbiBSZXZpc2lvbjogOTAwNTIKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBi L1Rvb2xzL0NoYW5nZUxvZwppbmRleCA5YjM3MDI4MGM3ZDYwYmQ5ZDhlNzZmOWFkNWZiODE5MmVi MzkwODcyLi5mYzg0M2JkNWU2NzBhZTdjMjE5OTVlYjdjYjQ0MTEyYmMyMTMyZGMxIDEwMDY0NAot LS0gYS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTEg QEAKKzIwMTEtMDYtMjcgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFNpbXBsaWZ5IHNraXBwZWQg ZmlsZSBmaW5kaW5nIGluIHByZXBhcmF0aW9uIGZvciBhZGRpbmcgd2syIHNraXBwZWQgbGlzdCBm YWxsYmFjaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 NjM1MDEKKworICAgICAgICBUaGUgZ29hbCB3YXMgdG8gYWRkIHN1cHBvcnQgZm9yIHdrMiBza2lw cGVkIGxpc3RzLgorICAgICAgICBIb3dldmVyLCBJIGZvdW5kIHRoYXQgb3VyIHNraXBwZWQgbGlz dCBjb21wdXRhdGlvbiB3YXMgYQorICAgICAgICBtYW51YWwgaGFjayAod2hpY2ggb25seSB3b3Jr ZWQgZm9yIHRoZSBtYWMgcG9ydCkuCisKKyAgICAgICAgU28gSSBmaXhlZCBhIEZJWE1FIHRvIG1v dmUgdGhlIHNraXBwZWQgbGlzdCBmaW5kaW5nCisgICAgICAgIGludG8gV2ViS2l0UG9ydCBpbnN0 ZWFkIG9mIE1hY1BvcnQuCisgICAgICAgIERvaW5nIHNvIHJlcXVpcmVkIHRoZSBjb25jZXB0IG9m IGEgInBvcnRfbmFtZSIsIHNpbmNlIHByZXZpb3VzbHkKKyAgICAgICAgdGhlIG9ubHkgbmFtZSBh Y2Nlc3NpYmxlIGZyb20gYSBwb3J0IG9iamVjdCB3YXMgbmFtZSgpCisgICAgICAgIHdoaWNoIGlu Y2x1ZGVzIG1hbnkgdGhpbmdzIGJleW9uZCAibWFjIiBvciAiY2hyb21pdW0iLCBldGMuCisKKyAg ICAgICAgRXZlbnR1YWxseSBJIGJlbGlldmUgd2UnbGwgd2FudCB0byByZS10aGluayB0aGUgd2F5 IHRoYXQgd2UgcGFzcworICAgICAgICBpbiBhIHBvcnRfbmFtZSBhcmd1bWVudCB0byBQb3J0IHN1 YmNsYXNzZXMgYW5kIGV4cGVjdCB0aGVtIHRvIHBhcnNlCisgICAgICAgIGl0LiAgQnV0IGZvciBu b3cgSSBqdXN0IGFkZGVkIGEgY2xzLnBvcnRfbmFtZSB2YXJpYWJsZSB3aGljaCBjb250YWlucwor ICAgICAgICB0aGUgc3RhdGljIGluZm9ybWF0aW9uIG5lZWRlZCB0byBjb21wdXRlIHdrMiBuYW1l cyBhcyB3ZWxsIGFzCisgICAgICAgIGNvbXB1dGUgU2tpcHBlZCBsaXN0IGZhbGxiYWNrIHdoaWNo IHdvcmtzIGZvciBNYWMvV2luL1F0IGFuZCBHdGsuCisKKyAgICAgICAgSW4gb3JkZXIgdG8gdGVz dCBteSBuZXcgX3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMgbWV0aG9kLCBJCisgICAgICAgIGZp eGVkIGFub3RoZXIgRklYTUUgYnkgbWFraW5nIGl0IHJldHVybiByZWxhdGl2ZSBwYXRocy4KKwor ICAgICAgICBJIGFsc28gZml4ZWQgdGhlIHRlc3RfZXhwZWN0YXRpb25zX3BhdGggY29kZSBpbiBX ZWJLaXRQb3J0IHRvIHVzZSBwb3J0X25hbWUuCisgICAgICAgIEl0IHdhcyB1c2luZyBuYW1lKCkg d2hpY2ggd291bGQgcmV0dXJuIFBPUlQtVkVSU0lPTiBzbyBNYWNQb3J0IHdhcyBvdmVycmlkaW5n CisgICAgICAgIGl0IHRvIHVzZSBqdXN0IFBPUlQuICBBZnRlciBmaXhpbmcgdGVzdF9leHBlY3Rh dGlvbnNfcGF0aCB0byB1c2UgcG9ydF9uYW1lCisgICAgICAgIChhbmQgbWFraW5nIGl0IGF3YXJl IG9mIHdlYmtpdDIpIEkgd2FzIGFibGUgdG8gcmVtb3ZlIHRoZSBNYWNQb3J0IGltcGxlbWVudGF0 aW9uLgorCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNl LnB5OgorICAgICAgICAgLSBBZGQgcG9ydF9uYW1lKCkgdG8gYWNjZXNzICJtYWMiLCBzaW5jZSBu YW1lKCkgcmV0dXJucyAibWFjLWxlb3BhcmQiIGV0Yy4KKyAgICAgICAgIC0gRG9jdW1lbnQgdGhh dCByZWFsX25hbWUoKSBzZWVtcyB0byBoYXZlIG5vIHB1cnBvc2UuCisgICAgICAgICogU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9saW51eC5weToKKyAgICAgICAg IC0gQWRkIF9wYXJzZV9wb3J0X25hbWUoKSwgZXZlbnR1YWxseSB3ZSBtaWdodCBjYWxsIHRoaXMg ZnJvbSBXZWJLaXRQb3J0IGRpcmVjdGx5LgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW1fbWFjLnB5OgorICAgICAgICAgLSBBZGQgX3BhcnNlX3Bv cnRfbmFtZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2No cm9taXVtX3dpbi5weToKKyAgICAgICAgIC0gQWRkIF9wYXJzZV9wb3J0X25hbWUuCisgICAgICAg ICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9ndGsucHk6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHk6CisgICAgICAgICAtIE1v dmUgU2tpcHBlZC1maWxlIGZpbmRpbmcgY29kZSBkb3duIHRvIFdlYktpdFBvcnQKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L21hY191bml0dGVzdC5weToKKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5OgorICAgICAg ICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0LnB5OgorICAgICAg ICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5 OgorCiAyMDExLTA2LTI5ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAgICAg ICBBZGFtIHNheXMgY293Ym95cyBkb24ndCByZXZpZXcgKG9yIHVuaXQgdGVzdCkuCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggZmFi Y2Y2MTY4MzA4M2IwOGVjNjA1YTE5ZjFmZjA4ZTdjNDAzZTA3NS4uODZiMTBlN2NkYjExNmVkMGIy YmY0MWY3M2IzNWQyNDljZTk3MTllYiAxMDA3NTUKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weQpAQCAtNjYsMTAgKzY2LDcgQEAgX2xvZyA9IGxvZ3V0 aWxzLmdldF9sb2dnZXIoX19maWxlX18pCiAKIAogY2xhc3MgRHVtbXlPcHRpb25zKG9iamVjdCk6 Ci0gICAgIiIiRmFrZSBpbXBsZW1lbnRhdGlvbiBvZiBvcHRwYXJzZS5WYWx1ZXMuIENsb25lZCBm cm9tCi0gICAgd2Via2l0cHkudG9vbC5tb2NrdG9vbC5Nb2NrT3B0aW9ucy4KLQotICAgICIiIgor ICAgICIiIkZha2UgaW1wbGVtZW50YXRpb24gb2Ygb3B0cGFyc2UuVmFsdWVzLiBDbG9uZWQgZnJv bSB3ZWJraXRweS50b29sLm1vY2t0b29sLk1vY2tPcHRpb25zLiIiIgogCiAgICAgZGVmIF9faW5p dF9fKHNlbGYsICoqa3dhcmdzKToKICAgICAgICAgIyBUaGUgY2FsbGVyIGNhbiBzZXQgb3B0aW9u IHZhbHVlcyB1c2luZyBrZXl3b3JkIGFyZ3VtZW50cy4gV2UgZG9uJ3QKQEAgLTgxLDIwICs3OCwy MSBAQCBjbGFzcyBEdW1teU9wdGlvbnMob2JqZWN0KToKICAgICAgICAgICAgIHNlbGYuX19kaWN0 X19ba2V5XSA9IHZhbHVlCiAKIAotIyBGSVhNRTogVGhpcyBjbGFzcyBzaG91bGQgbWVyZ2Ugd2l0 aCB3ZWJraXRweS53ZWJraXRfcG9ydCBhdCBzb21lIHBvaW50LgorIyBGSVhNRTogVGhpcyBjbGFz cyBzaG91bGQgbWVyZ2Ugd2l0aCB3ZWJraXRweS5jb21tb24uY29uZmlnLnBvcnRzLgogY2xhc3Mg UG9ydChvYmplY3QpOgogICAgICIiIkFic3RyYWN0IGNsYXNzIGZvciBQb3J0LXNwZWNpZmljIGhv b2tzIGZvciB0aGUgbGF5b3V0X3Rlc3QgcGFja2FnZS4iIiIKIAorICAgIHBvcnRfbmFtZSA9IE5v bmUgICMgU3ViY2xhc3NlcyBvdmVycmlkZSB0aGlzCisKICAgICBkZWYgX19pbml0X18oc2VsZiwg cG9ydF9uYW1lPU5vbmUsIG9wdGlvbnM9Tm9uZSwKICAgICAgICAgICAgICAgICAgZXhlY3V0aXZl PU5vbmUsCiAgICAgICAgICAgICAgICAgIHVzZXI9Tm9uZSwKICAgICAgICAgICAgICAgICAgZmls ZXN5c3RlbT1Ob25lLAogICAgICAgICAgICAgICAgICBjb25maWc9Tm9uZSwKICAgICAgICAgICAg ICAgICAgKiprd2FyZ3MpOgotICAgICAgICBzZWxmLl9uYW1lID0gcG9ydF9uYW1lCiAKICAgICAg ICAgIyBUaGVzZSBhcmUgZGVmYXVsdCB2YWx1ZXMgdGhhdCBzaG91bGQgYmUgb3ZlcnJpZGRlbiBp biBhIHN1YmNsYXNzZXMuCi0gICAgICAgICMgRklYTUU6IFRoZXNlIHNob3VsZCByZWFsbHkgYmUg cGFzc2VkIGluLgorICAgICAgICBzZWxmLl9uYW1lID0gcG9ydF9uYW1lIG9yIHNlbGYucG9ydF9u YW1lICAjIFN1YmNsYXNzZXMgbWF5IGFwcGVuZCBhIC1WRVJTSU9OIChsaWtlIG1hYy1sZW9wYXJk KSBvciBvdGhlciBxdWFsaWZpZXJzLgogICAgICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0g J21hYycKICAgICAgICAgc2VsZi5fdmVyc2lvbiA9ICcnCiAgICAgICAgIHNlbGYuX2FyY2hpdGVj dHVyZSA9ICd4ODYnCkBAIC0xMTIsOSArMTEwLDggQEAgY2xhc3MgUG9ydChvYmplY3QpOgogCiAg ICAgICAgIHNlbGYuX2hlbHBlciA9IE5vbmUKICAgICAgICAgc2VsZi5faHR0cF9zZXJ2ZXIgPSBO b25lCi0gICAgICAgIHNlbGYuX3dlYmtpdF9iYXNlX2RpciA9IE5vbmUKICAgICAgICAgc2VsZi5f d2Vic29ja2V0X3NlcnZlciA9IE5vbmUKLSAgICAgICAgc2VsZi5faHR0cF9sb2NrID0gTm9uZQor ICAgICAgICBzZWxmLl9odHRwX2xvY2sgPSBOb25lICAjIEZJWE1FOiBXaHkgZG9lcyB0aGlzIGxp dmUgb24gdGhlIHBvcnQgb2JqZWN0PwogCiAgICAgICAgICMgUHl0aG9uJ3MgUG9wZW4gaGFzIGEg YnVnIHRoYXQgY2F1c2VzIGFueSBwaXBlcyBvcGVuZWQgdG8gYQogICAgICAgICAjIHByb2Nlc3Mg dGhhdCBjYW4ndCBiZSBleGVjdXRlZCB0byBiZSBsZWFrZWQuICBTaW5jZSB0aGlzCkBAIC0xMzIs MTIgKzEyOSwxMSBAQCBjbGFzcyBQb3J0KG9iamVjdCk6CiAgICAgICAgIHNlbGYuX3dkaWZmX2F2 YWlsYWJsZSA9IE5vbmUKIAogICAgICAgICAjIEZJWE1FOiBwcmV0dHlwYXRjaC5weSBrbm93cyB0 aGlzIHBhdGgsIHdoeSBpcyBpdCBjb3BpZWQgaGVyZT8KLSAgICAgICAgc2VsZi5fcHJldHR5X3Bh dGNoX3BhdGggPSBzZWxmLnBhdGhfZnJvbV93ZWJraXRfYmFzZSgiV2Vic2l0ZXMiLAotICAgICAg ICAgICAgImJ1Z3Mud2Via2l0Lm9yZyIsICJQcmV0dHlQYXRjaCIsICJwcmV0dGlmeS5yYiIpCisg ICAgICAgIHNlbGYuX3ByZXR0eV9wYXRjaF9wYXRoID0gc2VsZi5wYXRoX2Zyb21fd2Via2l0X2Jh c2UoIldlYnNpdGVzIiwgImJ1Z3Mud2Via2l0Lm9yZyIsICJQcmV0dHlQYXRjaCIsICJwcmV0dGlm eS5yYiIpCiAgICAgICAgIHNlbGYuX3ByZXR0eV9wYXRjaF9hdmFpbGFibGUgPSBOb25lCiAKICAg ICAgICAgc2VsZi5zZXRfb3B0aW9uX2RlZmF1bHQoJ2NvbmZpZ3VyYXRpb24nLCBzZWxmLmRlZmF1 bHRfY29uZmlndXJhdGlvbigpKQotICAgICAgICBzZWxmLl90ZXN0X2NvbmZpZ3VyYXRpb24gPSBO b25lCisgICAgICAgIHNlbGYuX3Rlc3RfY29uZmlndXJhdGlvbiA9IE5vbmUgICMgRklYTUU6IFRo aXMgZG9lcyBub3QgYmVsb25nIG9uIHRoZSByZWFsIG9iamVjdC4KICAgICAgICAgc2VsZi5fbXVs dGlwcm9jZXNzaW5nX2lzX2F2YWlsYWJsZSA9IChtdWx0aXByb2Nlc3NpbmcgaXMgbm90IE5vbmUp CiAgICAgICAgIHNlbGYuX3Jlc3VsdHNfZGlyZWN0b3J5ID0gTm9uZQogICAgICAgICBzZWxmLnNl dF9vcHRpb25fZGVmYXVsdCgndXNlX2FwYWNoZScsIHNlbGYuX2RlZmF1bHRfdG9fYXBhY2hlKCkp CkBAIC0xNTMsOCArMTQ5LDcgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICByZXR1cm4g c2VsZi5fcHJldHR5X3BhdGNoX2F2YWlsYWJsZQogCiAgICAgZGVmIGRlZmF1bHRfY2hpbGRfcHJv Y2Vzc2VzKHNlbGYpOgotICAgICAgICAiIiJSZXR1cm4gdGhlIG51bWJlciBvZiBEdW1wUmVuZGVy VHJlZSBpbnN0YW5jZXMgdG8gdXNlIGZvciB0aGlzCi0gICAgICAgIHBvcnQuIiIiCisgICAgICAg ICIiIlJldHVybiB0aGUgbnVtYmVyIG9mIER1bXBSZW5kZXJUcmVlIGluc3RhbmNlcyB0byB1c2Ug Zm9yIHRoaXMgcG9ydC4iIiIKICAgICAgICAgcmV0dXJuIHNlbGYuX2V4ZWN1dGl2ZS5jcHVfY291 bnQoKQogCiAgICAgZGVmIGRlZmF1bHRfd29ya2VyX21vZGVsKHNlbGYpOgpAQCAtMTYzLDEwICsx NTgsOCBAQCBjbGFzcyBQb3J0KG9iamVjdCk6CiAgICAgICAgIHJldHVybiAndGhyZWFkcycKIAog ICAgIGRlZiBiYXNlbGluZV9wYXRoKHNlbGYpOgotICAgICAgICAiIiJSZXR1cm4gdGhlIGFic29s dXRlIHBhdGggdG8gdGhlIGRpcmVjdG9yeSB0byBzdG9yZSBuZXcgYmFzZWxpbmVzCi0gICAgICAg IGluIGZvciB0aGlzIHBvcnQuIiIiCi0gICAgICAgIGJhc2VsaW5lX3NlYXJjaF9wYXRocyA9IFwK LSAgICAgICAgICAgIHNlbGYuZ2V0X29wdGlvbignYWRkaXRpb25hbF9wbGF0Zm9ybV9kaXJlY3Rv cnknLCBbXSkgKyBzZWxmLmJhc2VsaW5lX3NlYXJjaF9wYXRoKCkKKyAgICAgICAgIiIiUmV0dXJu IHRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSBkaXJlY3RvcnkgdG8gc3RvcmUgbmV3IGJhc2VsaW5l cyBpbiBmb3IgdGhpcyBwb3J0LiIiIgorICAgICAgICBiYXNlbGluZV9zZWFyY2hfcGF0aHMgPSBz ZWxmLmdldF9vcHRpb24oJ2FkZGl0aW9uYWxfcGxhdGZvcm1fZGlyZWN0b3J5JywgW10pICsgc2Vs Zi5iYXNlbGluZV9zZWFyY2hfcGF0aCgpCiAgICAgICAgIHJldHVybiBiYXNlbGluZV9zZWFyY2hf cGF0aHNbMF0KIAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKQEAgLTI0Nywx MSArMjQwLDExIEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgcmV0dXJuIGV4cGVjdGVk X3RleHQgIT0gYWN0dWFsX3RleHQKIAogICAgIGRlZiBjb21wYXJlX2F1ZGlvKHNlbGYsIGV4cGVj dGVkX2F1ZGlvLCBhY3R1YWxfYXVkaW8pOgorICAgICAgICAjIEZJWE1FOiBJZiB3ZSBnaXZlIHRo aXMgbWV0aG9kIGEgYmV0dGVyIG5hbWUgaXQgd29uJ3QgbmVlZCB0aGlzIGRvY3N0cmluZyAoZS5n LiBhcmVfYXVkaW9fcmVzdWx0c19lcXVhbCgpKS4KICAgICAgICAgIiIiUmV0dXJuIHdoZXRoZXIg dGhlIHR3byBhdWRpbyBmaWxlcyBhcmUgKm5vdCogZXF1YWwuIiIiCiAgICAgICAgIHJldHVybiBl eHBlY3RlZF9hdWRpbyAhPSBhY3R1YWxfYXVkaW8KIAotICAgIGRlZiBkaWZmX2ltYWdlKHNlbGYs IGV4cGVjdGVkX2NvbnRlbnRzLCBhY3R1YWxfY29udGVudHMsCi0gICAgICAgICAgICAgICAgICAg ZGlmZl9maWxlbmFtZT1Ob25lLCB0b2xlcmFuY2U9MCk6CisgICAgZGVmIGRpZmZfaW1hZ2Uoc2Vs ZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywgZGlmZl9maWxlbmFtZT1Ob25l LCB0b2xlcmFuY2U9MCk6CiAgICAgICAgICIiIkNvbXBhcmUgdHdvIGltYWdlcyBhbmQgcHJvZHVj ZSBhIGRlbHRhIGltYWdlIGZpbGUuCiAKICAgICAgICAgUmV0dXJuIFRydWUgaWYgdGhlIHR3byBp bWFnZXMgYXJlIGRpZmZlcmVudCwgRmFsc2UgaWYgdGhleSBhcmUgdGhlIHNhbWUuCkBAIC0zMzMs OCArMzI2LDcgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogCiAgICAgICAgIGJhc2VsaW5lcyA9IFtd CiAgICAgICAgIGZvciBwbGF0Zm9ybV9kaXIgaW4gYmFzZWxpbmVfc2VhcmNoX3BhdGg6Ci0gICAg ICAgICAgICBpZiBzZWxmLnBhdGhfZXhpc3RzKHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihwbGF0Zm9y bV9kaXIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBiYXNlbGluZV9maWxlbmFtZSkpOgorICAgICAgICAgICAgaWYgc2VsZi5wYXRoX2V4aXN0 cyhzZWxmLl9maWxlc3lzdGVtLmpvaW4ocGxhdGZvcm1fZGlyLCBiYXNlbGluZV9maWxlbmFtZSkp OgogICAgICAgICAgICAgICAgIGJhc2VsaW5lcy5hcHBlbmQoKHBsYXRmb3JtX2RpciwgYmFzZWxp bmVfZmlsZW5hbWUpKQogCiAgICAgICAgICAgICBpZiBub3QgYWxsX2Jhc2VsaW5lcyBhbmQgYmFz ZWxpbmVzOgpAQCAtMzcxLDggKzM2Myw4IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAg VGhpcyByb3V0aW5lIGlzIGdlbmVyaWMgYnV0IGlzIGltcGxlbWVudGVkIGhlcmUgdG8gbGl2ZSBh bG9uZ3NpZGUKICAgICAgICAgdGhlIG90aGVyIGJhc2VsaW5lIGFuZCBmaWxlbmFtZSBtYW5pcHVs YXRpb24gcm91dGluZXMuCiAgICAgICAgICIiIgotICAgICAgICBwbGF0Zm9ybV9kaXIsIGJhc2Vs aW5lX2ZpbGVuYW1lID0gc2VsZi5leHBlY3RlZF9iYXNlbGluZXMoCi0gICAgICAgICAgICBmaWxl bmFtZSwgc3VmZml4KVswXQorICAgICAgICAjIEZJWE1FOiBUaGUgWzBdIGhlcmUgaXMgdmVyeSBt eXN0ZXJpb3VzLCBhcyBpcyB0aGUgZGVzdHJ1Y3R1cmVkIHJldHVybi4KKyAgICAgICAgcGxhdGZv cm1fZGlyLCBiYXNlbGluZV9maWxlbmFtZSA9IHNlbGYuZXhwZWN0ZWRfYmFzZWxpbmVzKGZpbGVu YW1lLCBzdWZmaXgpWzBdCiAgICAgICAgIGlmIHBsYXRmb3JtX2RpcjoKICAgICAgICAgICAgIHJl dHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4ocGxhdGZvcm1fZGlyLCBiYXNlbGluZV9maWxlbmFt ZSkKICAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0 c19kaXIoKSwgYmFzZWxpbmVfZmlsZW5hbWUpCkBAIC00NTYsOSArNDQ4LDcgQEAgY2xhc3MgUG9y dChvYmplY3QpOgogICAgICAgICByZXR1cm4gdGVzdF9maWxlcy5maW5kKHNlbGYsIHBhdGhzKQog CiAgICAgZGVmIHRlc3RfZGlycyhzZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyB0aGUgbGlzdCBv ZiB0b3AtbGV2ZWwgdGVzdCBkaXJlY3Rvcmllcy4KLQotICAgICAgICBVc2VkIGJ5IC0tY2xvYmJl ci1vbGQtcmVzdWx0cy4iIiIKKyAgICAgICAgIiIiUmV0dXJucyB0aGUgbGlzdCBvZiB0b3AtbGV2 ZWwgdGVzdCBkaXJlY3Rvcmllcy4iIiIKICAgICAgICAgbGF5b3V0X3Rlc3RzX2RpciA9IHNlbGYu bGF5b3V0X3Rlc3RzX2RpcigpCiAgICAgICAgIHJldHVybiBmaWx0ZXIobGFtYmRhIHg6IHNlbGYu X2ZpbGVzeXN0ZW0uaXNkaXIoc2VsZi5fZmlsZXN5c3RlbS5qb2luKGxheW91dF90ZXN0c19kaXIs IHgpKSwKICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9maWxlc3lzdGVtLmxpc3RkaXIobGF5 b3V0X3Rlc3RzX2RpcikpCkBAIC01MzksOSArNTI5LDE2IEBAIGNsYXNzIFBvcnQob2JqZWN0KToK ICAgICAgICAgc2VsZi5fZmlsZXN5c3RlbS5tYXliZV9tYWtlX2RpcmVjdG9yeSgqcGF0aCkKIAog ICAgIGRlZiBuYW1lKHNlbGYpOgotICAgICAgICAiIiJSZXR1cm4gdGhlIG5hbWUgb2YgdGhlIHBv cnQgKGUuZy4sICdtYWMnLCAnY2hyb21pdW0td2luLXhwJykuIiIiCisgICAgICAgICIiIlJldHVy bnMgYSBuYW1lIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGlzIHBhcnRpY3VsYXIgdHlwZSBv ZiBwb3J0CisgICAgICAgIChlLmcuLCAibWFjLXNub3dsZW9wYXJkIiBvciAiY2hyb21pdW0tZ3B1 LWxpbnV4LXg4Nl94NjQiIGFuZCBjYW4gYmUgcGFzc2VkCisgICAgICAgIHRvIGZhY3RvcnkuZ2V0 KCkgdG8gaW5zdGFudGlhdGUgdGhlIHBvcnQuIiIiCiAgICAgICAgIHJldHVybiBzZWxmLl9uYW1l CiAKKyAgICBkZWYgcmVhbF9uYW1lKHNlbGYpOgorICAgICAgICAjIEZJWE1FOiBTZWVtcyB0aGlz IGlzIG9ubHkgdXNlZCBmb3IgTW9ja0RSVCBhbmQgc2hvdWxkIGJlIHJlbW92ZWQuCisgICAgICAg ICIiIlJldHVybnMgdGhlIG5hbWUgb2YgdGhlIHBvcnQgYXMgcGFzc2VkIHRvIHRoZSAtLXBsYXRm b3JtIGNvbW1hbmQgbGluZSBhcmd1bWVudC4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYubmFtZSgp CisKICAgICBkZWYgb3BlcmF0aW5nX3N5c3RlbShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYu X29wZXJhdGluZ19zeXN0ZW0KIApAQCAtNTY4LDEwICs1NjUsNiBAQCBjbGFzcyBQb3J0KG9iamVj dCk6CiAgICAgZGVmIGFyY2hpdGVjdHVyZShzZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuX2Fy Y2hpdGVjdHVyZQogCi0gICAgZGVmIHJlYWxfbmFtZShzZWxmKToKLSAgICAgICAgIiIiUmV0dXJu cyB0aGUgYWN0dWFsIG5hbWUgb2YgdGhlIHBvcnQsIG5vdCB0aGUgZGVsZWdhdGUncy4iIiIKLSAg ICAgICAgcmV0dXJuIHNlbGYubmFtZSgpCi0KICAgICBkZWYgZ2V0X29wdGlvbihzZWxmLCBuYW1l LCBkZWZhdWx0X3ZhbHVlPU5vbmUpOgogICAgICAgICAjIEZJWE1FOiBFdmVudHVhbGx5IHdlIHNo b3VsZCBub3QgaGF2ZSB0byBkbyBhIHRlc3QgZm9yCiAgICAgICAgICMgaGFzYXR0cigpLCBhbmQg d2Ugc2hvdWxkIGJlIGFibGUgdG8ganVzdCBkbwpAQCAtNjQxLDggKzYzNCw3IEBAIGNsYXNzIFBv cnQob2JqZWN0KToKICAgICAgICAgcmV0dXJuIHNlbGYuX3VzZXIub3Blbl91cmwocmVzdWx0c19m aWxlbmFtZSkKIAogICAgIGRlZiBjcmVhdGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgot ICAgICAgICAiIiJSZXR1cm4gYSBuZXdseSBjcmVhdGVkIGJhc2UuRHJpdmVyIHN1YmNsYXNzIGZv ciBzdGFydGluZy9zdG9wcGluZwotICAgICAgICB0aGUgdGVzdCBkcml2ZXIuIiIiCisgICAgICAg ICIiIlJldHVybiBhIG5ld2x5IGNyZWF0ZWQgYmFzZS5Ecml2ZXIgc3ViY2xhc3MgZm9yIHN0YXJ0 aW5nL3N0b3BwaW5nIHRoZSB0ZXN0IGRyaXZlci4iIiIKICAgICAgICAgcmFpc2UgTm90SW1wbGVt ZW50ZWRFcnJvcignUG9ydC5jcmVhdGVfZHJpdmVyJykKIAogICAgIGRlZiBzdGFydF9oZWxwZXIo c2VsZik6CkBAIC04NzYsOCArODY4LDcgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICBy YWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0Ll9wYXRoX3RvX2hlbHBlcicpCiAKICAgICBk ZWYgX3BhdGhfdG9faW1hZ2VfZGlmZihzZWxmKToKLSAgICAgICAgIiIiUmV0dXJucyB0aGUgZnVs bCBwYXRoIHRvIHRoZSBpbWFnZV9kaWZmIGJpbmFyeSwgb3IgTm9uZSBpZiBpdAotICAgICAgICBp cyBub3QgYXZhaWxhYmxlLgorICAgICAgICAiIiJSZXR1cm5zIHRoZSBmdWxsIHBhdGggdG8gdGhl IGltYWdlX2RpZmYgYmluYXJ5LCBvciBOb25lIGlmIGl0IGlzIG5vdCBhdmFpbGFibGUuCiAKICAg ICAgICAgVGhpcyBpcyBsaWtlbHkgdXNlZCBvbmx5IGJ5IGRpZmZfaW1hZ2UoKSIiIgogICAgICAg ICByYWlzZSBOb3RJbXBsZW1lbnRlZEVycm9yKCdQb3J0LnBhdGhfdG9faW1hZ2VfZGlmZicpCmRp ZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9t aXVtLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bS5weQppbmRleCBiZDJkYjVmNjk2ZGM1Y2E0ZWQ5YjNkOTIwOWJlOGJiYjhiYmI0OTAxLi5jNjM1 NGU1MjMxMzQwM2E5NGZjYWYyMGI3Mjc5Y2NmZTdkODMzNjE0IDEwMDY0NAotLS0gYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtLnB5CisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hyb21pdW0ucHkKQEAgLTUzLDkg KzUzLDExIEBAIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnNlcnZlcnMgaW1wb3J0IHdlYnNv Y2tldF9zZXJ2ZXIKIF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rl c3RzLnBvcnQuY2hyb21pdW0iKQogCiAKLSMgRklYTUU6IFRoaXMgZnVuY3Rpb24gZG9lc24ndCBi ZWxvbmcgaW4gdGhpcyBwYWNrYWdlLgogY2xhc3MgQ2hyb21pdW1Qb3J0KGJhc2UuUG9ydCk6CiAg ICAgIiIiQWJzdHJhY3QgYmFzZSBjbGFzcyBmb3IgQ2hyb21pdW0gaW1wbGVtZW50YXRpb25zIG9m IHRoZSBQb3J0IGNsYXNzLiIiIgorCisgICAgcG9ydF9uYW1lID0gImNocm9taXVtIgorCiAgICAg QUxMX0JBU0VMSU5FX1ZBUklBTlRTID0gWwogICAgICAgICAnY2hyb21pdW0tbWFjLXNub3dsZW9w YXJkJywgJ2Nocm9taXVtLW1hYy1sZW9wYXJkJywKICAgICAgICAgJ2Nocm9taXVtLXdpbi13aW43 JywgJ2Nocm9taXVtLXdpbi12aXN0YScsICdjaHJvbWl1bS13aW4teHAnLApAQCAtMzQ2LDggKzM0 OCw2IEBAIGNsYXNzIENocm9taXVtUG9ydChiYXNlLlBvcnQpOgogCiAKIGNsYXNzIENocm9taXVt RHJpdmVyKGJhc2UuRHJpdmVyKToKLSAgICAiIiJBYnN0cmFjdCBpbnRlcmZhY2UgZm9yIERSVC4i IiIKLQogICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0LCB3b3JrZXJfbnVtYmVyKToKICAgICAg ICAgc2VsZi5fcG9ydCA9IHBvcnQKICAgICAgICAgc2VsZi5fd29ya2VyX251bWJlciA9IHdvcmtl cl9udW1iZXIKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvY2hyb21pdW1fbGludXgucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L2Nocm9taXVtX2xpbnV4LnB5CmluZGV4IDFlYmEyNjYyYTFlNTY4NDc3NjQ3Mzhl MmUzODVkMDhhNjVkYjU5ZTcuLjQ0ODFmZDIwMDJiNmE1NDUzMjU3MTU2NWY2MDA0Yjc1OTBiOWE4 OTEgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv Y2hyb21pdW1fbGludXgucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC9jaHJvbWl1bV9saW51eC5weQpAQCAtNDgsNyArNDgsNiBAQCBjbGFzcyBDaHJvbWl1 bUxpbnV4UG9ydChjaHJvbWl1bS5DaHJvbWl1bVBvcnQpOgogICAgIGRlZiBfX2luaXRfXyhzZWxm LCBwb3J0X25hbWU9Tm9uZSwgKiprd2FyZ3MpOgogICAgICAgICBwb3J0X25hbWUgPSBwb3J0X25h bWUgb3IgJ2Nocm9taXVtLWxpbnV4JwogICAgICAgICBjaHJvbWl1bS5DaHJvbWl1bVBvcnQuX19p bml0X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCi0KICAgICAgICAgIyBX ZSByZS1zZXQgdGhlIHBvcnQgbmFtZSBvbmNlIHRoZSBiYXNlIG9iamVjdCBpcyBmdWxseSBpbml0 aWFsaXplZAogICAgICAgICAjIGluIG9yZGVyIHRvIGJlIGFibGUgdG8gZmluZCB0aGUgRFJUIGJp bmFyeSBwcm9wZXJseS4KICAgICAgICAgaWYgcG9ydF9uYW1lLmVuZHN3aXRoKCctbGludXgnKToK ZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvY2hy b21pdW1fbWFjLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9j aHJvbWl1bV9tYWMucHkKaW5kZXggYzdlOTc3YzM2MmY3YmI2OTJjZmMyYmM4YmM3N2Q4OWVlZDFh ZDVkNC4uZDMwYTFkZDhhMDk5YWRiNWU3Yjg0ODA5NzQwNGQ3M2U1MzE3YzdiNCAxMDA2NDQKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV9tYWMu cHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1 bV9tYWMucHkKQEAgLTc2LDcgKzc2LDcgQEAgY2xhc3MgQ2hyb21pdW1NYWNQb3J0KGNocm9taXVt LkNocm9taXVtUG9ydCk6CiAgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gbWFjLm9zX3ZlcnNp b24ob3NfdmVyc2lvbl9zdHJpbmcsIHNlbGYuU1VQUE9SVEVEX09TX1ZFUlNJT05TKQogICAgICAg ICAgICAgc2VsZi5fbmFtZSA9IHBvcnRfbmFtZSArICctJyArIHNlbGYuX3ZlcnNpb24KICAgICAg ICAgZWxzZToKLSAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbcG9ydF9uYW1l LmluZGV4KCctbWFjLScpICsgNTpdCisgICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9u YW1lW3BvcnRfbmFtZS5pbmRleCgnLW1hYy0nKSArIGxlbignLW1hYy0nKTpdCiAgICAgICAgICAg ICBhc3NlcnQgc2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9PU19WRVJTSU9OUwogICAg ICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0gJ21hYycKIApkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9jaHJvbWl1bV93aW4ucHkgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQppbmRl eCBiOTAzYzNmZTJhMjdlMGYwM2EwOGY3YmVjYWQyYTRhMWZjZDViMjRiLi4zYjc1NjgzMDMxYjY3 ZDIxMTEwYjJlNjM5MjdiZDRjMzg1Mzc3MmRhIDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQorKysgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Nocm9taXVtX3dpbi5weQpAQCAtNzQsOSAr NzQsOCBAQCBjbGFzcyBDaHJvbWl1bVdpblBvcnQoY2hyb21pdW0uQ2hyb21pdW1Qb3J0KToKICAg ICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBvc192ZXJzaW9uKHdpbmRvd3NfdmVyc2lvbikKICAg ICAgICAgICAgIHNlbGYuX25hbWUgPSBwb3J0X25hbWUgKyAnLScgKyBzZWxmLl92ZXJzaW9uCiAg ICAgICAgIGVsc2U6Ci0gICAgICAgICAgICBzZWxmLl92ZXJzaW9uID0gcG9ydF9uYW1lW3BvcnRf bmFtZS5pbmRleCgnLXdpbi0nKSArIDU6XQotICAgICAgICAgICAgYXNzZXJ0IHNlbGYuX3ZlcnNp b24gaW4gc2VsZi5TVVBQT1JURURfVkVSU0lPTlMKLQorICAgICAgICAgICAgc2VsZi5fdmVyc2lv biA9IHBvcnRfbmFtZVtwb3J0X25hbWUuaW5kZXgoJy13aW4tJykgKyBsZW4oJy13aW4tJyk6XQor ICAgICAgICAgICAgYXNzZXJ0IHNlbGYuX3ZlcnNpb24gaW4gc2VsZi5TVVBQT1JURURfVkVSU0lP TlMsICIlcyBpcyBub3QgaW4gJXMiICUgKHNlbGYuX3ZlcnNpb24sIHNlbGYuU1VQUE9SVEVEX1ZF UlNJT05TKQogICAgICAgICBzZWxmLl9vcGVyYXRpbmdfc3lzdGVtID0gJ3dpbicKIAogICAgIGRl ZiBzZXR1cF9lbnZpcm9uX2Zvcl9zZXJ2ZXIoc2VsZik6CmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2d0ay5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvZ3RrLnB5CmluZGV4IDAxODA5N2MxNTgzNmMyYjNkMDg0 N2VjOTM0NTc2MzZlZDZkYTI3OTguLjFmM2NmYjU0ZWRiMDkzMmY0ZTM5OWEzMGQ5NmMxODQwNmI2 ZGQ4MDAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvZ3RrLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv Z3RrLnB5CkBAIC0zOSw4ICszOSw2IEBAIF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0 cHkubGF5b3V0X3Rlc3RzLnBvcnQuZ3RrIikKIAogCiBjbGFzcyBHdGtEcml2ZXIod2Via2l0Lldl YktpdERyaXZlcik6Ci0gICAgIiIiV2ViS2l0IEd0ayBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgRHJp dmVyIGNsYXNzLiIiIgotCiAgICAgZGVmIHN0YXJ0KHNlbGYpOgogICAgICAgICBkaXNwbGF5X2lk ID0gc2VsZi5fd29ya2VyX251bWJlciArIDEKICAgICAgICAgcnVuX3h2ZmIgPSBbIlh2ZmIiLCAi OiVkIiAlIChkaXNwbGF5X2lkKV0KQEAgLTU3LDI3ICs1NSwyMCBAQCBjbGFzcyBHdGtEcml2ZXIo d2Via2l0LldlYktpdERyaXZlcik6CiAKIAogY2xhc3MgR3RrUG9ydCh3ZWJraXQuV2ViS2l0UG9y dCk6Ci0gICAgIiIiV2ViS2l0IEd0ayBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBjbGFzcy4i IiIKLQotICAgIGRlZiBfX2luaXRfXyhzZWxmLCAqKmt3YXJncyk6Ci0gICAgICAgIGt3YXJncy5z ZXRkZWZhdWx0KCdwb3J0X25hbWUnLCAnZ3RrJykKLSAgICAgICAgd2Via2l0LldlYktpdFBvcnQu X19pbml0X18oc2VsZiwgKiprd2FyZ3MpCisgICAgcG9ydF9uYW1lID0gImd0ayIKIAogICAgIGRl ZiBjcmVhdGVfZHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpOgogICAgICAgICByZXR1cm4gR3Rr RHJpdmVyKHNlbGYsIHdvcmtlcl9udW1iZXIpCiAKICAgICBkZWYgX3BhdGhfdG9fYXBhY2hlX2Nv bmZpZ19maWxlKHNlbGYpOgogICAgICAgICAjIEZJWE1FOiBUaGlzIG5lZWRzIHRvIGRldGVjdCB0 aGUgZGlzdHJpYnV0aW9uIGFuZCBjaGFuZ2UgY29uZmlnIGZpbGVzLgotICAgICAgICByZXR1cm4g c2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYubGF5b3V0X3Rlc3RzX2RpcigpLCAnaHR0cCcsICdj b25mJywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnYXBhY2hlMi1kZWJp YW4taHR0cGQuY29uZicpCisgICAgICAgIHJldHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2Vs Zi5sYXlvdXRfdGVzdHNfZGlyKCksICdodHRwJywgJ2NvbmYnLCAnYXBhY2hlMi1kZWJpYW4taHR0 cGQuY29uZicpCiAKICAgICBkZWYgX3BhdGhfdG9fZHJpdmVyKHNlbGYpOgogICAgICAgICByZXR1 cm4gc2VsZi5fYnVpbGRfcGF0aCgnUHJvZ3JhbXMnLCBzZWxmLmRyaXZlcl9uYW1lKCkpCiAKICAg ICBkZWYgY2hlY2tfYnVpbGQoc2VsZiwgbmVlZHNfaHR0cCk6Ci0gICAgICAgIGlmIG5vdCBzZWxm Ll9jaGVja19kcml2ZXIoKToKLSAgICAgICAgICAgIHJldHVybiBGYWxzZQotICAgICAgICByZXR1 cm4gVHJ1ZQorICAgICAgICByZXR1cm4gc2VsZi5fY2hlY2tfZHJpdmVyKCkKIAogICAgIGRlZiBf cGF0aF90b19hcGFjaGUoc2VsZik6CiAgICAgICAgIGlmIHNlbGYuX2lzX3JlZGhhdF9iYXNlZCgp OgpAQCAtOTEsOCArODIsNyBAQCBjbGFzcyBHdGtQb3J0KHdlYmtpdC5XZWJLaXRQb3J0KToKICAg ICAgICAgZWxzZToKICAgICAgICAgICAgIGNvbmZpZ19uYW1lID0gJ2FwYWNoZTItZGViaWFuLWh0 dHBkLmNvbmYnCiAKLSAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxh eW91dF90ZXN0c19kaXIoKSwgJ2h0dHAnLCAnY29uZicsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgY29uZmlnX25hbWUpCisgICAgICAgIHJldHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4o c2VsZi5sYXlvdXRfdGVzdHNfZGlyKCksICdodHRwJywgJ2NvbmYnLCBjb25maWdfbmFtZSkKIAog ICAgIGRlZiBfcGF0aF90b193ZGlmZihzZWxmKToKICAgICAgICAgaWYgc2VsZi5faXNfcmVkaGF0 X2Jhc2VkKCk6CkBAIC0xMTUsNyArMTA1LDUgQEAgY2xhc3MgR3RrUG9ydCh3ZWJraXQuV2ViS2l0 UG9ydCk6CiAgICAgICAgICAgICBpZiBvcy5wYXRoLmlzZmlsZShmdWxsX2xpYnJhcnkpOgogICAg ICAgICAgICAgICAgIHJldHVybiBmdWxsX2xpYnJhcnkKIAotICAgICAgICByZXR1cm4gTm9uZQot CiAgICAgZGVmIF9ydW50aW1lX2ZlYXR1cmVfbGlzdChzZWxmKToKICAgICAgICAgcmV0dXJuIE5v bmUKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv bWFjLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkK aW5kZXggYTY4NWMxYmRhMTUzYWZjMzEyNmE0YzVjZTcyZTZkYjg0ZTUyMTYyYi4uODU3MDIxOGZl OTEyYjMwMTJlZjgzN2VkYTFhOTY3YzljNmI4OTg5YyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWMucHkKQEAgLTQ4LDYgKzQ4LDcgQEAgZGVmIG9z X3ZlcnNpb24ob3NfdmVyc2lvbl9zdHJpbmc9Tm9uZSwgc3VwcG9ydGVkX3ZlcnNpb25zPU5vbmUp OgogICAgIHZlcnNpb25fc3RyaW5ncyA9IHsKICAgICAgICAgNTogJ2xlb3BhcmQnLAogICAgICAg ICA2OiAnc25vd2xlb3BhcmQnLAorICAgICAgICAjIEFkZCA3OiAnbGlvbicgaGVyZT8KICAgICB9 CiAgICAgYXNzZXJ0IHJlbGVhc2VfdmVyc2lvbiA+PSBtaW4odmVyc2lvbl9zdHJpbmdzLmtleXMo KSkKICAgICB2ZXJzaW9uX3N0cmluZyA9IHZlcnNpb25fc3RyaW5ncy5nZXQocmVsZWFzZV92ZXJz aW9uLCAnZnV0dXJlJykKQEAgLTU3LDcgKzU4LDggQEAgZGVmIG9zX3ZlcnNpb24ob3NfdmVyc2lv bl9zdHJpbmc9Tm9uZSwgc3VwcG9ydGVkX3ZlcnNpb25zPU5vbmUpOgogCiAKIGNsYXNzIE1hY1Bv cnQoV2ViS2l0UG9ydCk6Ci0gICAgIiIiV2ViS2l0IE1hYyBpbXBsZW1lbnRhdGlvbiBvZiB0aGUg UG9ydCBjbGFzcy4iIiIKKyAgICBwb3J0X25hbWUgPSAibWFjIgorCiAgICAgIyBGSVhNRTogJ3dr MicgcHJvYmFibHkgc2hvdWxkbid0IGJlIGEgdmVyc2lvbiwgaXQgc2hvdWxkIHByb2JhYmx5IGJl CiAgICAgIyBhIG1vZGlmaWVyLCBsaWtlICdjaHJvbWl1bS1ncHUnIGlzIHRvICdjaHJvbWl1bScu CiAgICAgU1VQUE9SVEVEX1ZFUlNJT05TID0gKCdsZW9wYXJkJywgJ3Nub3dsZW9wYXJkJywgJ2Z1 dHVyZScsICd3azInKQpAQCAtNjYsNiArNjgsNyBAQCBjbGFzcyBNYWNQb3J0KFdlYktpdFBvcnQp OgogICAgICAgICAnbGVvcGFyZCc6IFsnbWFjLWxlb3BhcmQnLCAnbWFjLXNub3dsZW9wYXJkJywg J21hYyddLAogICAgICAgICAnc25vd2xlb3BhcmQnOiBbJ21hYy1zbm93bGVvcGFyZCcsICdtYWMn XSwKICAgICAgICAgJ2Z1dHVyZSc6IFsnbWFjJ10sCisgICAgICAgICMgRklYTUU6IFRoaXMgaXNu J3QgcXVpdGUgcmlnaHQgZm9yIHdrMiwgaXQgc2hvdWxkIGluY2x1ZGUgbWFjLVZFUlNJT04gYXMg d2VsbC4KICAgICAgICAgJ3drMic6IFsnbWFjLXdrMicsICdtYWMnXSwKICAgICB9CiAKQEAgLTc2 LDggKzc5LDkgQEAgY2xhc3MgTWFjUG9ydChXZWJLaXRQb3J0KToKICAgICAgICAgICAgIHNlbGYu X3ZlcnNpb24gPSBvc192ZXJzaW9uKG9zX3ZlcnNpb25fc3RyaW5nKQogICAgICAgICAgICAgc2Vs Zi5fbmFtZSA9IHBvcnRfbmFtZSArICctJyArIHNlbGYuX3ZlcnNpb24KICAgICAgICAgZWxzZToK LSAgICAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBwb3J0X25hbWVbNDpdCi0gICAgICAgICAgICBh c3NlcnQgc2VsZi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUworICAgICAgICAg ICAgYXNzZXJ0IHBvcnRfbmFtZS5zdGFydHN3aXRoKCdtYWMnKQorICAgICAgICAgICAgc2VsZi5f dmVyc2lvbiA9IHBvcnRfbmFtZVtsZW4oJ21hYy0nKTpdCisgICAgICAgICAgICBhc3NlcnQgc2Vs Zi5fdmVyc2lvbiBpbiBzZWxmLlNVUFBPUlRFRF9WRVJTSU9OUywgIiVzIGlzIG5vdCBpbiAlcyIg JSAoc2VsZi5fdmVyc2lvbiwgc2VsZi5TVVBQT1JURURfVkVSU0lPTlMpCiAgICAgICAgIHNlbGYu X29wZXJhdGluZ19zeXN0ZW0gPSAnbWFjJwogICAgICAgICBpZiBub3QgaGFzYXR0cihzZWxmLl9v cHRpb25zLCAndGltZS1vdXQtbXMnKSBvciBzZWxmLl9vcHRpb25zLnRpbWVfb3V0X21zIGlzIE5v bmU6CiAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnRpbWVfb3V0X21zID0gMzUwMDAKQEAgLTk0 LDI0ICs5OCw5IEBAIGNsYXNzIE1hY1BvcnQoV2ViS2l0UG9ydCk6CiAgICAgZGVmIGJhc2VsaW5l X3NlYXJjaF9wYXRoKHNlbGYpOgogICAgICAgICByZXR1cm4gbWFwKHNlbGYuX3dlYmtpdF9iYXNl bGluZV9wYXRoLCBzZWxmLkZBTExCQUNLX1BBVEhTW3NlbGYuX3ZlcnNpb25dKQogCi0gICAgZGVm IHBhdGhfdG9fdGVzdF9leHBlY3RhdGlvbnNfZmlsZShzZWxmKToKLSAgICAgICAgcmV0dXJuIHNl bGYucGF0aF9mcm9tX3dlYmtpdF9iYXNlKCdMYXlvdXRUZXN0cycsICdwbGF0Zm9ybScsCi0gICAg ICAgICAgICdtYWMnLCAndGVzdF9leHBlY3RhdGlvbnMudHh0JykKLQogICAgIGRlZiBpc19jcmFz aF9yZXBvcnRlcihzZWxmLCBwcm9jZXNzX25hbWUpOgogICAgICAgICByZXR1cm4gcmUuc2VhcmNo KHInUmVwb3J0Q3Jhc2gnLCBwcm9jZXNzX25hbWUpCiAKLSAgICBkZWYgX3NraXBwZWRfZmlsZV9w YXRocyhzZWxmKToKLSAgICAgICAgIyBGSVhNRTogVGhpcyBtZXRob2Qgd2lsbCBuZWVkIHRvIGJl IG1hZGUgd29yayBmb3Igbm9uLW1hYwotICAgICAgICAjIHBsYXRmb3JtcyBhbmQgbW92ZWQgaW50 byBiYXNlLlBvcnQuCi0gICAgICAgIHNraXBwZWRfZmlsZXMgPSBbXQotICAgICAgICBpZiBzZWxm Ll9uYW1lIGluICgnbWFjLWxlb3BhcmQnLCAnbWFjLXNub3dsZW9wYXJkJyk6Ci0gICAgICAgICAg ICBza2lwcGVkX2ZpbGVzLmFwcGVuZChzZWxmLl9maWxlc3lzdGVtLmpvaW4oCi0gICAgICAgICAg ICAgICAgc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoc2VsZi5fbmFtZSksICdTa2lwcGVkJykp Ci0gICAgICAgIHNraXBwZWRfZmlsZXMuYXBwZW5kKHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxm Ll93ZWJraXRfYmFzZWxpbmVfcGF0aCgnbWFjJyksCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAnU2tpcHBlZCcpKQotICAgICAgICByZXR1cm4gc2tpcHBlZF9maWxl cwotCiAgICAgZGVmIF9idWlsZF9qYXZhX3Rlc3Rfc3VwcG9ydChzZWxmKToKICAgICAgICAgamF2 YV90ZXN0c19wYXRoID0gc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYubGF5b3V0X3Rlc3RzX2Rp cigpLCAiamF2YSIpCiAgICAgICAgIGJ1aWxkX2phdmEgPSBbIi91c3IvYmluL21ha2UiLCAiLUMi LCBqYXZhX3Rlc3RzX3BhdGhdCkBAIC0xMjQsOCArMTEzLDcgQEAgY2xhc3MgTWFjUG9ydChXZWJL aXRQb3J0KToKICAgICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX2phdmFfdGVzdF9zdXBwb3J0KCkK IAogICAgIGRlZiBfcGF0aF90b19hcGFjaGVfY29uZmlnX2ZpbGUoc2VsZik6Ci0gICAgICAgIHJl dHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5sYXlvdXRfdGVzdHNfZGlyKCksICdodHRw JywgJ2NvbmYnLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdhcGFjaGUy LWh0dHBkLmNvbmYnKQorICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYu bGF5b3V0X3Rlc3RzX2RpcigpLCAnaHR0cCcsICdjb25mJywgJ2FwYWNoZTItaHR0cGQuY29uZicp CiAKICAgICBkZWYgX3BhdGhfdG9fd2ViY29yZV9saWJyYXJ5KHNlbGYpOgogICAgICAgICByZXR1 cm4gc2VsZi5fYnVpbGRfcGF0aCgnV2ViQ29yZS5mcmFtZXdvcmsvVmVyc2lvbnMvQS9XZWJDb3Jl JykKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv bWFjX3VuaXR0ZXN0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9tYWNfdW5pdHRlc3QucHkKaW5kZXggMjhmYzg1ZTZlYTI1ZDViOTU2YTQ5YzFjZTFmMDY5NWE2 MzAwNjU4ZS4uNTZhMWM3ZDY0NjlmMDM5MTY4M2ZhZWMyOWVjZjAwODNjOGEwZWJiNiAxMDA2NDQK LS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWNfdW5pdHRl c3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9tYWNf dW5pdHRlc3QucHkKQEAgLTQwLDI0ICs0MCwyMCBAQCBjbGFzcyBNYWNUZXN0KHBvcnRfdGVzdGNh c2UuUG9ydFRlc3RDYXNlKToKICAgICAgICAgICAgIHJldHVybiBOb25lCiAgICAgICAgIHJldHVy biBtYWMuTWFjUG9ydAogCi0gICAgZGVmIGFzc2VydF9za2lwcGVkX2ZpbGVzX2Zvcl92ZXJzaW9u KHNlbGYsIHBvcnRfbmFtZSwgZXhwZWN0ZWRfcGF0aHMpOgorICAgIGRlZiBhc3NlcnRfc2tpcHBl ZF9maWxlX3NlYXJjaF9wYXRocyhzZWxmLCBwb3J0X25hbWUsIGV4cGVjdGVkX3BhdGhzKToKICAg ICAgICAgcG9ydCA9IG1hYy5NYWNQb3J0KHBvcnRfbmFtZT1wb3J0X25hbWUpCi0gICAgICAgIHNr aXBwZWRfcGF0aHMgPSBwb3J0Ll9za2lwcGVkX2ZpbGVfcGF0aHMoKQotICAgICAgICAjIEZJWE1F OiBfc2tpcHBlZF9maWxlX3BhdGhzIHNob3VsZCByZXR1cm4gV2ViS2l0LXJlbGF0aXZlIHBhdGhz LgotICAgICAgICAjIFNvIHRvIG1ha2UgaXQgdW5pdCB0ZXN0YWJsZSwgd2Ugc3RyaXAgdGhlIFdl YktpdCBkaXJlY3RvcnkgZnJvbSB0aGUgcGF0aC4KLSAgICAgICAgcmVsYXRpdmVfcGF0aHMgPSBb cGF0aFtsZW4ocG9ydC5wYXRoX2Zyb21fd2Via2l0X2Jhc2UoKSk6XSBmb3IgcGF0aCBpbiBza2lw cGVkX3BhdGhzXQotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHJlbGF0aXZlX3BhdGhzLCBleHBl Y3RlZF9wYXRocykKLQotICAgIGRlZiB0ZXN0X3NraXBwZWRfZmlsZV9wYXRocyhzZWxmKToKLSAg ICAgICAgIyBXZSBza2lwIHRoaXMgb24gd2luMzIgYmVjYXVzZSB3ZSB1c2UgJy8nIGFzIHRoZSBk aXIgc2VwYXJhdG9yIGFuZCBpdCdzCi0gICAgICAgICMgbm90IHdvcnRoIG1ha2luZyBwbGF0Zm9y bS1pbmRlcGVuZGVudC4KKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChwb3J0Ll9za2lwcGVkX2Zp bGVfc2VhcmNoX3BhdGhzKCksIGV4cGVjdGVkX3BhdGhzKQorCisgICAgZGVmIHRlc3Rfc2tpcHBl ZF9maWxlX3NlYXJjaF9wYXRocyhzZWxmKToKKyAgICAgICAgIyBGSVhNRTogVGhpcyBzaG91bGQg bm8gbG9uZ2VyIGJlIG5lY2Vzc2FyeSwgYnV0IEknbSBub3QgYnJhdmUgZW5vdWdoIHRvIHJlbW92 ZSBpdC4KICAgICAgICAgaWYgc3lzLnBsYXRmb3JtID09ICd3aW4zMic6CiAgICAgICAgICAgICBy ZXR1cm4gTm9uZQogCi0gICAgICAgIHNlbGYuYXNzZXJ0X3NraXBwZWRfZmlsZXNfZm9yX3ZlcnNp b24oJ21hYy1zbm93bGVvcGFyZCcsCi0gICAgICAgICAgICBbJy9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9tYWMtc25vd2xlb3BhcmQvU2tpcHBlZCcsICcvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL1Nr aXBwZWQnXSkKLSAgICAgICAgc2VsZi5hc3NlcnRfc2tpcHBlZF9maWxlc19mb3JfdmVyc2lvbign bWFjLWxlb3BhcmQnLAotICAgICAgICAgICAgWycvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLWxl b3BhcmQvU2tpcHBlZCcsICcvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL1NraXBwZWQnXSkKKyAg ICAgICAgc2VsZi5hc3NlcnRfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygnbWFjLXNub3dsZW9w YXJkJywgc2V0KFsnbWFjLXNub3dsZW9wYXJkJywgJ21hYyddKSkKKyAgICAgICAgc2VsZi5hc3Nl cnRfc2tpcHBlZF9maWxlX3NlYXJjaF9wYXRocygnbWFjLWxlb3BhcmQnLCBzZXQoWydtYWMtbGVv cGFyZCcsICdtYWMnXSkpCisgICAgICAgICMgV2UgY2Fubm90IHRlc3QganVzdCAibWFjIiBoZXJl IGFzIHRoZSBNYWNQb3J0IGNvbnN0cnVjdG9yIGF1dG9tYXRpY2FsbHkgZmlsbHMgaW4gdGhlIHZl cnNpb24gZnJvbSB0aGUgcnVubmluZyBPUy4KKyAgICAgICAgIyBzZWxmLmFzc2VydF9za2lwcGVk X2ZpbGVfc2VhcmNoX3BhdGhzKCdtYWMnLCBbJ21hYyddKQorCiAKICAgICBleGFtcGxlX3NraXBw ZWRfZmlsZSA9IHUiIiIKICMgPHJkYXI6Ly9wcm9ibGVtLzU2NDc5NTI+IGZhc3QvZXZlbnRzL21v dXNlb3V0LW9uLXdpbmRvdy5odG1sIG5lZWRzIG1hYyBEUlQgdG8gaXNzdWUgbW91c2Ugb3V0IGV2 ZW50cwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC9xdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvcXQucHkK aW5kZXggNjBiMGMzMjkyNzc2NTI4ZjA3ZjBkNjM0MTljYjQyNjlmZTVjNDRhMi4uNTRhYTA1MjRl NzRiYmI0ZDRkYjE3YjNkMGE2MzA4YjZhM2U0MzA2ZSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9xdC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3F0LnB5CkBAIC0zOSwxMSArMzksNyBAQCBfbG9nID0g bG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LnF0IikKIAogCiBj bGFzcyBRdFBvcnQoV2ViS2l0UG9ydCk6Ci0gICAgIiIiUXRXZWJLaXQgaW1wbGVtZW50YXRpb24g b2YgdGhlIFBvcnQgY2xhc3MuIiIiCi0KLSAgICBkZWYgX19pbml0X18oc2VsZiwgKiprd2FyZ3Mp OgotICAgICAgICBrd2FyZ3Muc2V0ZGVmYXVsdCgncG9ydF9uYW1lJywgJ3F0JykKLSAgICAgICAg V2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJncykKKyAgICBwb3J0X25hbWUgPSAicXQi CiAKICAgICBkZWYgYmFzZWxpbmVfc2VhcmNoX3BhdGgoc2VsZik6CiAgICAgICAgIHBvcnRfbmFt ZXMgPSBbXQpAQCAtNTgsOCArNTQsNyBAQCBjbGFzcyBRdFBvcnQoV2ViS2l0UG9ydCk6CiAKICAg ICBkZWYgX3BhdGhfdG9fYXBhY2hlX2NvbmZpZ19maWxlKHNlbGYpOgogICAgICAgICAjIEZJWE1F OiBUaGlzIG5lZWRzIHRvIGRldGVjdCB0aGUgZGlzdHJpYnV0aW9uIGFuZCBjaGFuZ2UgY29uZmln IGZpbGVzLgotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYubGF5b3V0 X3Rlc3RzX2RpcigpLCAnaHR0cCcsICdjb25mJywKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAnYXBhY2hlMi1kZWJpYW4taHR0cGQuY29uZicpCisgICAgICAgIHJldHVybiBz ZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5sYXlvdXRfdGVzdHNfZGlyKCksICdodHRwJywgJ2Nv bmYnLCAnYXBhY2hlMi1kZWJpYW4taHR0cGQuY29uZicpCiAKICAgICBkZWYgX2J1aWxkX2RyaXZl cihzZWxmKToKICAgICAgICAgIyBUaGUgUXQgcG9ydCBidWlsZHMgRFJUIGFzIHBhcnQgb2YgdGhl IG1haW4gYnVpbGQgc3RlcApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvcG9ydC93ZWJraXQucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L3dlYmtpdC5weQppbmRleCA3NWFhMDVhZDk2YjEyNGQ0NDczMDUyNjc2MGQ4MzA5 N2RlYmFiYjBkLi5hYzQ0N2Q3NmRiODg5NGViOGViNDgyNDBlNWFiNDJmNmY3YzI4NGRjIDEwMDY0 NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5w eQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5w eQpAQCAtMzYsMjYgKzM2LDIwIEBAIGltcG9ydCBsb2dnaW5nCiBpbXBvcnQgb3BlcmF0b3IKIGlt cG9ydCBvcwogaW1wb3J0IHJlCi1pbXBvcnQgc2lnbmFsCi1pbXBvcnQgc3lzCiBpbXBvcnQgdGlt ZQotaW1wb3J0IHdlYmJyb3dzZXIKLQogCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5uZXQuYnVpbGRi b3QgaW1wb3J0IEJ1aWxkQm90Ci1mcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0gaW1wb3J0IG9z cGF0aAogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgU2NyaXB0 RXJyb3IKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnBvcnQgaW1wb3J0IGJhc2UsIGJ1aWxk ZXJzLCBzZXJ2ZXJfcHJvY2VzcwogCi1fbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5 LmxheW91dF90ZXN0cy5wb3J0LndlYmtpdCIpCiAKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihf X2ZpbGVfXykKIAotY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgotICAgICIiIldlYktpdCBp bXBsZW1lbnRhdGlvbiBvZiB0aGUgUG9ydCBjbGFzcy4iIiIKIAorY2xhc3MgV2ViS2l0UG9ydChi YXNlLlBvcnQpOgogICAgIGRlZiBfX2luaXRfXyhzZWxmLCAqKmt3YXJncyk6CiAgICAgICAgIGJh c2UuUG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3YXJncykKLSAgICAgICAgc2VsZi5fY2FjaGVkX2Fw YWNoZV9wYXRoID0gTm9uZQorICAgICAgICBzZWxmLl9jYWNoZWRfYXBhY2hlX3BhdGggPSBOb25l ICAjIEZJWE1FOiBUaGlzIGNsYXNzIHNob3VsZCB1c2UgQG1lbW9pemVkIGluc3RlYWQuCiAKICAg ICAgICAgIyBGSVhNRTogZGlzYWJsZSBwaXhlbCB0ZXN0cyB1bnRpbCB0aGV5IGFyZSBydW4gYnkg ZGVmYXVsdCBvbiB0aGUgYnVpbGQgbWFjaGluZXMuCiAgICAgICAgIHNlbGYuc2V0X29wdGlvbl9k ZWZhdWx0KCJwaXhlbF90ZXN0cyIsIEZhbHNlKQpAQCAtNjUsMTIgKzU5LDIxIEBAIGNsYXNzIFdl YktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAgICAgICAgIHJldHVybiAiV2ViS2l0VGVzdFJ1bm5l ciIKICAgICAgICAgcmV0dXJuICJEdW1wUmVuZGVyVHJlZSIKIAorICAgICMgRklYTUU6IFRoaXMg aXMgbm90IGEgdmVyeSB1c2VmdWwgZGVmYXVsdCBpbXBsZW1lbnRhdGlvbiwgYXMgaXRzIHdyb25n IGZvciBhbnkKKyAgICAjIHBvcnQgd2hpY2ggdXNlcyB2ZXJzaW9uLXNwZWNpZmljIGZhbGxiYWNr IChlLmcuIFsnbWFjLWxlYXBhcmQnLCAnbWFjJ10pLgorICAgICMgV2Ugc2hvdWxkIHJlcGxhY2Ug dGhpcyB3aXRoIGEgc21hcnRlciBpbXBsZW1lbnRhdGlvbiBzaGFyZWQgYnkgYWxsIHBvcnRzLgog ICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxmKToKLSAgICAgICAgcmV0dXJuIFtzZWxm Ll93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWxmLl9uYW1lKV0KKyAgICAgICAgc2VhcmNoX3BhdGhz ID0gW3NlbGYubmFtZSgpXQorICAgICAgICBpZiBzZWxmLmdldF9vcHRpb24oJ3dlYmtpdF90ZXN0 X3J1bm5lcicpOgorICAgICAgICAgICAgc2VhcmNoX3BhdGhzLmluc2VydCgwLCBzZWxmLl93azJf cG9ydF9uYW1lKCkpCisgICAgICAgIHJldHVybiBzZWFyY2hfcGF0aHMKKworICAgIGRlZiBfZXhw ZWN0YXRpb25zX3NlYXJjaF9wYXRoKHNlbGYpOgorICAgICAgICAjIHRlc3RfZXhwZWN0YXRpb25z IGFyZSBhbHdheXMgaW4gbWFjLyBub3QgbWFjLWxlb3BhcmQvIGJ5IGNvbnZlbnRpb24sIGhlbmNl IHdlIHVzZSBwb3J0X25hbWUgaW5zdGVhZCBvZiBuYW1lKCkuCisgICAgICAgIHJldHVybiBzZWxm Ll93azJfcG9ydF9uYW1lKCkgaWYgc2VsZi5nZXRfb3B0aW9uKCd3ZWJraXRfdGVzdF9ydW5uZXIn KSBlbHNlIHNlbGYucG9ydF9uYW1lCiAKICAgICBkZWYgcGF0aF90b190ZXN0X2V4cGVjdGF0aW9u c19maWxlKHNlbGYpOgotICAgICAgICByZXR1cm4gc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYu X3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX25hbWUpLAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICd0ZXN0X2V4cGVjdGF0aW9ucy50eHQnKQorICAgICAgICByZXR1cm4g c2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHNlbGYuX2V4 cGVjdGF0aW9uc19zZWFyY2hfcGF0aCgpKSwgJ3Rlc3RfZXhwZWN0YXRpb25zLnR4dCcpCiAKICAg ICBkZWYgX3Jlc3VsdHNfZm9yX3BsYXRmb3JtKHNlbGYsIHBsYXRmb3JtKToKICAgICAgICAgYnVp bGRlcl9uYW1lID0gYnVpbGRlcnMuYnVpbGRlcl9uYW1lX2Zvcl9wbGF0Zm9ybShwbGF0Zm9ybSkK QEAgLTI4NCwxMiArMjg3LDI2IEBAIGNsYXNzIFdlYktpdFBvcnQoYmFzZS5Qb3J0KToKICAgICAg ICAgICAgIHRlc3RzX3RvX3NraXAuYXBwZW5kKGxpbmUpCiAgICAgICAgIHJldHVybiB0ZXN0c190 b19za2lwCiAKLSAgICBkZWYgX3NraXBwZWRfZmlsZV9wYXRocyhzZWxmKToKLSAgICAgICAgcmV0 dXJuIFtzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5fd2Via2l0X2Jhc2VsaW5lX3BhdGgoc2Vs Zi5fbmFtZSksICdTa2lwcGVkJyldCisgICAgZGVmIF93azJfcG9ydF9uYW1lKHNlbGYpOgorICAg ICAgICAjIEJ5IGN1cnJlbnQgY29udmVudGlvbiwgdGhlIFdlYktpdDIgbmFtZSBpcyBhbHdheXMg bWFjLXdrMiwgd2luLXdrMiwgbm90IG1hYy1sZW9wYXJkLXdrMiwgZXRjLgorICAgICAgICByZXR1 cm4gIiVzLXdrMiIgJSBzZWxmLnBvcnRfbmFtZQorCisgICAgZGVmIF9za2lwcGVkX2ZpbGVfc2Vh cmNoX3BhdGhzKHNlbGYpOgorICAgICAgICAjIFVubGlrZSBiYXNlbGluZV9zZWFyY2hfcGF0aCwg d2Ugb25seSB3YW50IHRvIHNlYXJjaCBbV0syLVBPUlQsIFBPUlQtVkVSU0lPTiwgUE9SVF0gbm90 IHRoZSBmdWxsIGNhc2FkZS4KKyAgICAgICAgIyBOb3RlIG9yZGVyIGRvZXNuJ3QgbWF0dGVyIHNp bmNlIHRoZSBTa2lwcGVkIGZpbGUgY29udGVudHMgYXJlIGFsbCBjb21iaW5lZC4KKyAgICAgICAg c2VhcmNoX3BhdGhzID0gc2V0KFtzZWxmLnBvcnRfbmFtZSwgc2VsZi5uYW1lKCldKQorICAgICAg ICBpZiBzZWxmLmdldF9vcHRpb24oJ3dlYmtpdF90ZXN0X3J1bm5lcicpOgorICAgICAgICAgICAg IyBRdW90aW5nIG9sZC1ydW4td2Via2l0LXRlc3RzOgorICAgICAgICAgICAgIyBCZWNhdXNlIG5l YXJseSBhbGwgb2YgdGhlIHNraXBwZWQgdGVzdHMgZm9yIFdlYktpdCAyIG9uIE1hYyBhcmUgZHVl IHRvCisgICAgICAgICAgICAjIGNyb3NzLXBsYXRmb3JtIGlzc3VlcywgdGhlIFdpbmRvd3MgYW5k IFF0IHBvcnRzIHVzZSB0aGUgTWFjIHNraXBwZWQgbGlzdAorICAgICAgICAgICAgIyBhZGRpdGlv bmFsbHkgdG8gdGhlaXIgb3duIHRvIGF2b2lkIG1haW50YWluaW5nIHNlcGFyYXRlIGxpc3RzLgor ICAgICAgICAgICAgc2VhcmNoX3BhdGhzLnVwZGF0ZShbc2VsZi5fd2syX3BvcnRfbmFtZSgpLCAi bWFjLXdrMiJdKQorICAgICAgICByZXR1cm4gc2VhcmNoX3BhdGhzCiAKICAgICBkZWYgX2V4cGVj dGF0aW9uc19mcm9tX3NraXBwZWRfZmlsZXMoc2VsZik6CiAgICAgICAgIHRlc3RzX3RvX3NraXAg PSBbXQotICAgICAgICBmb3IgZmlsZW5hbWUgaW4gc2VsZi5fc2tpcHBlZF9maWxlX3BhdGhzKCk6 CisgICAgICAgIGZvciBzZWFyY2hfcGF0aCBpbiBzZWxmLl9za2lwcGVkX2ZpbGVfc2VhcmNoX3Bh dGhzKCk6CisgICAgICAgICAgICBmaWxlbmFtZSA9IHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxm Ll93ZWJraXRfYmFzZWxpbmVfcGF0aChzZWFyY2hfcGF0aCksICJTa2lwcGVkIikKICAgICAgICAg ICAgIGlmIG5vdCBzZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhmaWxlbmFtZSk6CiAgICAgICAgICAg ICAgICAgX2xvZy53YXJuKCJGYWlsZWQgdG8gb3BlbiBTa2lwcGVkIGZpbGU6ICVzIiAlIGZpbGVu YW1lKQogICAgICAgICAgICAgICAgIGNvbnRpbnVlCkBAIC0yOTgsMTIgKzMxNSwxNCBAQCBjbGFz cyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAgIHJldHVybiB0ZXN0c190b19za2lwCiAK ICAgICBkZWYgdGVzdF9leHBlY3RhdGlvbnMoc2VsZik6Ci0gICAgICAgICMgVGhlIFdlYktpdCBt YWMgcG9ydCB1c2VzIGEgY29tYmluYXRpb24gb2YgYSB0ZXN0X2V4cGVjdGF0aW9ucyBmaWxlCi0g ICAgICAgICMgYW5kICdTa2lwcGVkJyBmaWxlcy4KKyAgICAgICAgIyBUaGlzIGFsbG93cyBwb3J0 cyB0byB1c2UgYSBjb21iaW5hdGlvbiBvZiB0ZXN0X2V4cGVjdGF0aW9ucy50eHQgZmlsZXMgYW5k IFNraXBwZWQgbGlzdHMuCisgICAgICAgIGV4cGVjdGF0aW9ucyA9IHNlbGYuX3NraXBwZWRfbGlz dF9hc19leHBlY3RhdGlvbnMoKQogICAgICAgICBleHBlY3RhdGlvbnNfcGF0aCA9IHNlbGYucGF0 aF90b190ZXN0X2V4cGVjdGF0aW9uc19maWxlKCkKLSAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVz eXN0ZW0ucmVhZF90ZXh0X2ZpbGUoZXhwZWN0YXRpb25zX3BhdGgpICsgc2VsZi5fc2tpcHMoKQor ICAgICAgICBpZiBzZWxmLl9maWxlc3lzdGVtLmV4aXN0cyhleHBlY3RhdGlvbnNfcGF0aCk6Cisg ICAgICAgICAgICBleHBlY3RhdGlvbnMgPSBzZWxmLl9maWxlc3lzdGVtLnJlYWRfdGV4dF9maWxl KGV4cGVjdGF0aW9uc19wYXRoKSArIGV4cGVjdGF0aW9ucworICAgICAgICByZXR1cm4gZXhwZWN0 YXRpb25zCiAKLSAgICBkZWYgX3NraXBzKHNlbGYpOgorICAgIGRlZiBfc2tpcHBlZF9saXN0X2Fz X2V4cGVjdGF0aW9ucyhzZWxmKToKICAgICAgICAgIyBFYWNoIFNraXBwZWQgZmlsZSBjb250YWlu cyBhIGxpc3Qgb2YgZmlsZXMKICAgICAgICAgIyBvciBkaXJlY3RvcmllcyB0byBiZSBza2lwcGVk IGR1cmluZyB0aGUgdGVzdCBydW4uIFRoZSB0b3RhbCBsaXN0CiAgICAgICAgICMgb2YgdGVzdHMg dG8gc2tpcHBlZCBpcyBnaXZlbiBieSB0aGUgY29udGVudHMgb2YgdGhlIGdlbmVyaWMKQEAgLTMx Myw4ICszMzIsNyBAQCBjbGFzcyBXZWJLaXRQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAgICMgZm9y bWF0IGV4cGVjdGVkIGJ5IHRlc3RfZXhwZWN0YXRpb25zLgogCiAgICAgICAgIHRlc3RzX3RvX3Nr aXAgPSBzZWxmLnNraXBwZWRfbGF5b3V0X3Rlc3RzKCkKLSAgICAgICAgc2tpcF9saW5lcyA9IG1h cChsYW1iZGEgdGVzdF9wYXRoOiAiQlVHX1NLSVBQRUQgU0tJUCA6ICVzID0gRkFJTCIgJQotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0X3BhdGgsIHRlc3RzX3RvX3NraXApCisg ICAgICAgIHNraXBfbGluZXMgPSBtYXAobGFtYmRhIHRlc3RfcGF0aDogIkJVR19TS0lQUEVEIFNL SVAgOiAlcyA9IEZBSUwiICUgdGVzdF9wYXRoLCB0ZXN0c190b19za2lwKQogICAgICAgICByZXR1 cm4gIlxuIi5qb2luKHNraXBfbGluZXMpCiAKICAgICBkZWYgc2tpcHBlZF9sYXlvdXRfdGVzdHMo c2VsZik6CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L3dlYmtpdF91bml0dGVzdC5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5CmluZGV4IDQxZjg1ZmFhZGEzZDBiZjc1YzI1YmNj NWViM2Q3NGQ1Njk3OTk3N2MuLmU0MjcxOGRlNTQyZjc4MjM5MTlkNDQ4MmY3OWQxMzdhODk3NzI3 NTkgMTAwNzU1Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2Via2l0X3VuaXR0ZXN0LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0X3VuaXR0ZXN0LnB5CkBAIC0zNyw2ICszNyw4IEBAIGZyb20gd2Via2l0 cHkudG9vbC5tb2NrdG9vbCBpbXBvcnQgTW9ja0V4ZWN1dGl2ZSwgTW9ja09wdGlvbnMsIE1vY2tV c2VyCiAKIAogY2xhc3MgVGVzdFdlYktpdFBvcnQoV2ViS2l0UG9ydCk6CisgICAgcG9ydF9uYW1l ID0gInRlc3R3ZWJraXRwb3J0IgorCiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIHN5bWJvbF9saXN0 PU5vbmUsIGZlYXR1cmVfbGlzdD1Ob25lLAogICAgICAgICAgICAgICAgICBleHBlY3RhdGlvbnNf ZmlsZT1Ob25lLCBza2lwc19maWxlPU5vbmUsCiAgICAgICAgICAgICAgICAgIGV4ZWN1dGl2ZT1O b25lLCBmaWxlc3lzdGVtPU5vbmUsIHVzZXI9Tm9uZSwKQEAgLTQ2LDcgKzQ4LDcgQEAgY2xhc3Mg VGVzdFdlYktpdFBvcnQoV2ViS2l0UG9ydCk6CiAgICAgICAgIGV4ZWN1dGl2ZSA9IGV4ZWN1dGl2 ZSBvciBNb2NrRXhlY3V0aXZlKHNob3VsZF9sb2c9RmFsc2UpCiAgICAgICAgIGZpbGVzeXN0ZW0g PSBmaWxlc3lzdGVtIG9yIE1vY2tGaWxlU3lzdGVtKCkKICAgICAgICAgdXNlciA9IHVzZXIgb3Ig TW9ja1VzZXIoKQotICAgICAgICBXZWJLaXRQb3J0Ll9faW5pdF9fKHNlbGYsIHBvcnRfbmFtZT0i dGVzdHdlYmtpdHBvcnQiLCBleGVjdXRpdmU9ZXhlY3V0aXZlLCBmaWxlc3lzdGVtPWZpbGVzeXN0 ZW0sIHVzZXI9TW9ja1VzZXIoKSwgKiprd2FyZ3MpCisgICAgICAgIFdlYktpdFBvcnQuX19pbml0 X18oc2VsZiwgZXhlY3V0aXZlPWV4ZWN1dGl2ZSwgZmlsZXN5c3RlbT1maWxlc3lzdGVtLCB1c2Vy PU1vY2tVc2VyKCksICoqa3dhcmdzKQogCiAgICAgZGVmIF9ydW50aW1lX2ZlYXR1cmVfbGlzdChz ZWxmKToKICAgICAgICAgcmV0dXJuIHNlbGYuZmVhdHVyZV9saXN0CkBAIC04OSw2ICs5MSwxNCBA QCBjbGFzcyBXZWJLaXRQb3J0VGVzdChwb3J0X3Rlc3RjYXNlLlBvcnRUZXN0Q2FzZSk6CiAgICAg ZGVmIHRlc3Rfc2tpcHBlZF9sYXlvdXRfdGVzdHMoc2VsZik6CiAgICAgICAgIHNlbGYuYXNzZXJ0 RXF1YWwoVGVzdFdlYktpdFBvcnQoTm9uZSwgTm9uZSkuc2tpcHBlZF9sYXlvdXRfdGVzdHMoKSwg c2V0KFsibWVkaWEiXSkpCiAKKyAgICBkZWYgdGVzdF9za2lwcGVkX2ZpbGVfc2VhcmNoX3BhdGhz KHNlbGYpOgorICAgICAgICBwb3J0ID0gVGVzdFdlYktpdFBvcnQoKQorICAgICAgICBzZWxmLmFz c2VydEVxdWFsKHBvcnQuX3NraXBwZWRfZmlsZV9zZWFyY2hfcGF0aHMoKSwgc2V0KFsndGVzdHdl YmtpdHBvcnQnXSkpCisgICAgICAgIHBvcnQuX25hbWUgPSAidGVzdHdlYmtpdHBvcnQtdmVyc2lv biIKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChwb3J0Ll9za2lwcGVkX2ZpbGVfc2VhcmNoX3Bh dGhzKCksIHNldChbJ3Rlc3R3ZWJraXRwb3J0JywgJ3Rlc3R3ZWJraXRwb3J0LXZlcnNpb24nXSkp CisgICAgICAgIHBvcnQuX29wdGlvbnMgPSBNb2NrT3B0aW9ucyh3ZWJraXRfdGVzdF9ydW5uZXI9 VHJ1ZSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChwb3J0Ll9za2lwcGVkX2ZpbGVfc2VhcmNo X3BhdGhzKCksIHNldChbJ3Rlc3R3ZWJraXRwb3J0JywgJ3Rlc3R3ZWJraXRwb3J0LXZlcnNpb24n LCAndGVzdHdlYmtpdHBvcnQtd2syJywgJ21hYy13azInXSkpCisKICAgICBkZWYgdGVzdF90ZXN0 X2V4cGVjdGF0aW9ucyhzZWxmKToKICAgICAgICAgIyBDaGVjayB0aGF0IHdlIHJlYWQgYm90aCB0 aGUgZXhwZWN0YXRpb25zIGZpbGUgYW5kIGFueXRoaW5nIGluIGEKICAgICAgICAgIyBTa2lwcGVk IGZpbGUsIGFuZCB0aGF0IHdlIGluY2x1ZGUgdGhlIGZlYXR1cmUgYW5kIHBsYXRmb3JtIGNoZWNr cy4KZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2luLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93aW4ucHkK aW5kZXggYzU3NTM3ODNkZGI4ZjVmYjgyZmFlOTE2NjBjNDNiYmI5Y2IzZjczNi4uYzg3Y2E5OTZm YTE1YWEwZDI0NDBlMjRmMjczNjhkNmZhZmUwNDM3MyAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93aW4ucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC93aW4ucHkKQEAgLTMyLDIzICszMiwyMSBAQCBpbXBv cnQgbG9nZ2luZwogCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5wb3J0LndlYmtpdCBpbXBv cnQgV2ViS2l0UG9ydAogCi1fbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91 dF90ZXN0cy5wb3J0LndpbiIpCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19maWxlX18pCiAK IAogY2xhc3MgV2luUG9ydChXZWJLaXRQb3J0KToKLSAgICAiIiJXZWJLaXQgV2luIGltcGxlbWVu dGF0aW9uIG9mIHRoZSBQb3J0IGNsYXNzLiIiIgorICAgIHBvcnRfbmFtZSA9ICJ3aW4iCiAKLSAg ICBkZWYgX19pbml0X18oc2VsZiwgcG9ydF9uYW1lPU5vbmUsICoqa3dhcmdzKToKLSAgICAgICAg cG9ydF9uYW1lID0gcG9ydF9uYW1lIG9yICd3aW4nCi0gICAgICAgIFdlYktpdFBvcnQuX19pbml0 X18oc2VsZiwgcG9ydF9uYW1lPXBvcnRfbmFtZSwgKiprd2FyZ3MpCisgICAgZGVmIF9faW5pdF9f KHNlbGYsICoqa3dhcmdzKToKKyAgICAgICAgV2ViS2l0UG9ydC5fX2luaXRfXyhzZWxmLCAqKmt3 YXJncykKICAgICAgICAgc2VsZi5fdmVyc2lvbiA9ICd3aW43JwogICAgICAgICBzZWxmLl9vcGVy YXRpbmdfc3lzdGVtID0gJ3dpbicKIAogICAgIGRlZiBiYXNlbGluZV9zZWFyY2hfcGF0aChzZWxm KToKICAgICAgICAgIyBCYXNlZCBvbiBjb2RlIGZyb20gb2xkLXJ1bi13ZWJraXQtdGVzdHMgZXhw ZWN0ZWREaXJlY3RvcnlGb3JUZXN0KCkKLSAgICAgICAgcG9ydF9uYW1lcyA9IFsid2luIiwgIm1h Yy1zbm93bGVvcGFyZCIsICJtYWMiXQotICAgICAgICByZXR1cm4gbWFwKHNlbGYuX3dlYmtpdF9i YXNlbGluZV9wYXRoLCBwb3J0X25hbWVzKQorICAgICAgICBzZWFyY2hfcGF0aHMgPSBbIndpbiIs ICJtYWMtc25vd2xlb3BhcmQiLCAibWFjIl0KKyAgICAgICAgcmV0dXJuIG1hcChzZWxmLl93ZWJr aXRfYmFzZWxpbmVfcGF0aCwgc2VhcmNoX3BhdGhzKQogCiAgICAgZGVmIF9wYXRoX3RvX2FwYWNo ZV9jb25maWdfZmlsZShzZWxmKToKLSAgICAgICAgcmV0dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9p bihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ2h0dHAnLCAnY29uZicsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgJ2N5Z3dpbi1odHRwZC5jb25mJykKKyAgICAgICAgcmV0 dXJuIHNlbGYuX2ZpbGVzeXN0ZW0uam9pbihzZWxmLmxheW91dF90ZXN0c19kaXIoKSwgJ2h0dHAn LCAnY29uZicsICdjeWd3aW4taHR0cGQuY29uZicpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcmViYXNlbGluZXNlcnZlcl91bml0dGVzdC5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lc2VydmVyX3VuaXR0 ZXN0LnB5CmluZGV4IDU3ZGEwZjg3NjM0YmYzODRjZTMwMzc3MjUyNGI5MTA3OTk0ZTI4M2EuLjQx OTZiYmU1ZjZhYjJiY2Y1MzRmODVlNmQ3ODdjODExNmE4Mjg1ZTMgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5lc2VydmVyX3VuaXR0ZXN0 LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9yZWJhc2VsaW5l c2VydmVyX3VuaXR0ZXN0LnB5CkBAIC0yOTEsNiArMjkxLDcgQEAgZGVmIGdldF90ZXN0X2NvbmZp Zyh0ZXN0X2ZpbGVzPVtdLCByZXN1bHRfZmlsZXM9W10pOgogICAgICAgICBtb2NrX2ZpbGVzeXN0 ZW0uZmlsZXNbZmlsZV9wYXRoXSA9ICcnCiAKICAgICBjbGFzcyBUZXN0TWFjUG9ydChXZWJLaXRQ b3J0KToKKyAgICAgICAgcG9ydF9uYW1lID0gJ3Rlc3RtYWNwb3J0JwogICAgICAgICBkZWYgX19p bml0X18oc2VsZik6CiAgICAgICAgICAgICAjIEZJWE1FOiBUaGlzIHNob3VsZCB1c2UgTW9ja0V4 ZWN1dGl2ZSBhbmQgTW9ja1VzZXIgYXMgd2VsbC4KICAgICAgICAgICAgIFdlYktpdFBvcnQuX19p bml0X18oc2VsZiwgZmlsZXN5c3RlbT1tb2NrX2ZpbGVzeXN0ZW0pCg==