164792 2016-11-15 14:04:51 -0800 [Linux] run-benchmark should be able to execute the benchmarks with more browsers 2019-06-09 08:51:53 -0700 1 1 1 Unclassified WebKit Tools / Tests WebKit Nightly Build Unspecified Unspecified UNCONFIRMED P2 Normal --- 164813 165173 0 clopez clopez ap bugs-noreply commit-queue dbates dewei_zhu glenn lforschler mcatanzaro ngockhanhlam87 ossy rniwa saam oldest_to_newest 1251621 0 clopez 2016-11-15 14:04:51 -0800 Currently on Linux to use the run-benchmark script you have to pass --platform gtk and the only browser available is minibrowser. I intend to: * Rename platform gtk to linux, because I feel it looks more correct to run "--platform linux --browser firefox" than "--platform gtk --browser firefox" (for example) * re-factorize the code and create the required classes for running the following browsers on platform linux: minibrowser-gtk, chrome (chromium), firefox and epiphany. 1251757 1 294912 clopez 2016-11-15 19:07:46 -0800 Created attachment 294912 Patch 1251759 2 commit-queue 2016-11-15 19:10:08 -0800 Attachment 294912 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:85: [LinuxBrowserDriver.close_browsers] Instance of 'Popen' has no 'kill' member [pylint/E1101] [5] Total errors found: 1 in 10 files If any of these errors are false positives, please file a bug against check-webkit-style. 1251772 3 clopez 2016-11-15 19:19:42 -0800 (In reply to comment #2) > Attachment 294912 [details] did not pass style-queue: > > > ERROR: > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver. > py:85: [LinuxBrowserDriver.close_browsers] Instance of 'Popen' has no > 'kill' member [pylint/E1101] [5] > Total errors found: 1 in 10 files > > > If any of these errors are false positives, please file a bug against > check-webkit-style. Filed: https://bugs.webkit.org/show_bug.cgi?id=164813 1253599 4 clopez 2016-11-24 09:03:00 -0800 ping reviewers? 1253607 5 294912 mcatanzaro 2016-11-24 12:11:42 -0800 Comment on attachment 294912 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=294912&action=review > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:35 > +try: > + import psutil > +except ImportError: > + pass I see you print a warning down below, but I'd do so here too. > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:87 > + _log.warning('python psutil not found, cant check for ' > + 'still-alive browser childs to kill.') cant -> can't childs -> child processes (or "children" but that's less clear here) > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:119 > + from gi.repository import Gtk > + screen = Gtk.Window().get_screen() > + return screen.get_monitor_geometry(screen.get_primary_monitor()) These functions don't exist in GTK+ 4. Can you rewrite it to avoid deprecations? That will make somebody's life easier in the distant future when nothing else in WebKit still depends on GTK+ 3. :) gdk_screen_get_primary_monitor has been deprecated since version 3.22 and should not be used in newly-written code. Use gdk_display_get_primary_monitor() instead gdk_screen_get_monitor_geometry has been deprecated since version 3.22 and should not be used in newly-written code. Use gdk_monitor_get_geometry() instead You'll have to test for version 3.22 as the replacement functions are brand new. If it's inconvenient for you, you don't have to; it's not a blocker, just a nice thing to do for whomever has to port this in the future. Could be you or me. :p 1254131 6 294912 dewei_zhu 2016-11-28 17:39:33 -0800 Comment on attachment 294912 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=294912&action=review > Tools/ChangeLog:18 > + This depends on psutil, so this will only be done if psutil is installed. This is a nice feature for testing some changes to run-benchmark without losing opening tabs in the browser. However, when testing the performance, it would be better to just run one browser instance to avoid some noise. Furthermore, ideally, "close_browsers" should be consistent between different platforms. It would be nicer to make it optional and can be specified by arguments. Let me know what you think. > Tools/Scripts/webkitpy/benchmark_runner/benchmark_runner.py:-110 > - self._browser_driver.close_browsers() We should not remove this line as we want to relaunch browser between each iteration. 1254133 7 dewei_zhu 2016-11-28 17:41:35 -0800 (In reply to comment #6) > Comment on attachment 294912 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=294912&action=review > > > Tools/ChangeLog:18 > > + This depends on psutil, so this will only be done if psutil is installed. > > This is a nice feature for testing some changes to run-benchmark without > losing opening tabs in the browser. > However, when testing the performance, it would be better to just run one > browser instance to avoid some noise. Furthermore, ideally, "close_browsers" > should be consistent between different platforms. It would be nicer to make > it optional and can be specified by arguments. > Let me know what you think. > > > Tools/Scripts/webkitpy/benchmark_runner/benchmark_runner.py:-110 > > - self._browser_driver.close_browsers() > > We should not remove this line as we want to relaunch browser between each > iteration. Ignore this comment. As we call close_browsers() in _run_one_test(). 1254135 8 294912 dewei_zhu 2016-11-28 17:42:36 -0800 Comment on attachment 294912 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=294912&action=review >> Tools/Scripts/webkitpy/benchmark_runner/benchmark_runner.py:-110 >> - self._browser_driver.close_browsers() > > We should not remove this line as we want to relaunch browser between each iteration. Ignore this comment. As we've caledl close_browsers() in _run_one_test already. 1254164 9 clopez 2016-11-28 19:03:44 -0800 (In reply to comment #6) > Comment on attachment 294912 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=294912&action=review > > > Tools/ChangeLog:18 > > + This depends on psutil, so this will only be done if psutil is installed. > > This is a nice feature for testing some changes to run-benchmark without > losing opening tabs in the browser. > However, when testing the performance, it would be better to just run one > browser instance to avoid some noise. Furthermore, ideally, "close_browsers" > should be consistent between different platforms. It would be nicer to make > it optional and can be specified by arguments. > Let me know what you think. > Currently (before this patch) a "killall $browsername" command is executed, which causes all process with name "$browsername" to be terminated. This is undesired, specially when the user is testing. If I want to test the script run-benchmark with chrome it won't make me happy that when it ends it kills my chrome browser session. So what this patch changes is: * The browsers executed by run-benchmark are started always on a new window, with a temporal profile and a temporal HOME. * The pid of the browser process executed is tracked, so when close_browsers() is executed only that pid is kill. * It after sending the kill signal to that pid, there are still alive children process, then those are killed also to ensure that not unwanted left-over browser process are left. So the idea is that now run-benchmark don't messes with the user browser process. All browser process started by the script are executed independently of the user ones, and are closed without interfering on the browser process not directly started by the script. 1254179 10 294912 dewei_zhu 2016-11-28 19:55:49 -0800 Comment on attachment 294912 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=294912&action=review >>>> Tools/ChangeLog:18 >>>> + This depends on psutil, so this will only be done if psutil is installed. >>> >>> This is a nice feature for testing some changes to run-benchmark without losing opening tabs in the browser. >>> However, when testing the performance, it would be better to just run one browser instance to avoid some noise. Furthermore, ideally, "close_browsers" should be consistent between different platforms. It would be nicer to make it optional and can be specified by arguments. >>> Let me know what you think. >> >> Ignore this comment. As we call close_browsers() in _run_one_test(). > > Currently (before this patch) a "killall $browsername" command is executed, which causes all process with name "$browsername" to be terminated. > > This is undesired, specially when the user is testing. If I want to test the script run-benchmark with chrome it won't make me happy that when it ends it kills my chrome browser session. > > So what this patch changes is: > > * The browsers executed by run-benchmark are started always on a new window, with a temporal profile and a temporal HOME. > * The pid of the browser process executed is tracked, so when close_browsers() is executed only that pid is kill. > * It after sending the kill signal to that pid, there are still alive children process, then those are killed also to ensure that not unwanted left-over browser process are left. > > So the idea is that now run-benchmark don't messes with the user browser process. All browser process started by the script are executed independently of the user ones, and are closed without interfering on the browser process not directly started by the script. Yes, I understand the pain of losing opened tabs/sessions in the browser. As you know, there are 2 use cases for this script: 1. Developing features for run-benchmark script. As you mentioned, killing all chrome is not a desired behavior. During development, we do not actually care about the scores of benchmarks and it is fine to keep the existing browser process running. 2. Testing performance of benchmarks. In this scenario, we care about the final benchmark score and want to get rid of potential impact introduced by running another browser process. As the second scenario is the major purpose of this script, personally, I would like to kill all browsers by default. However, I agree with you that it is undesired for developing purpose. So I would recommend to make "killing testing browser process only" as an optional argument. And we can turn on this feature by passing argument like '--keep-existing-browser' (or you can come up with more descriptive argument name). 1254194 11 clopez 2016-11-28 20:48:35 -0800 (In reply to comment #5) > Comment on attachment 294912 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=294912&action=review > > > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:35 > > +try: > > + import psutil > > +except ImportError: > > + pass > > I see you print a warning down below, but I'd do so here too. > This is intended because the way run-benchmark currently works. It loads all the main classes to check the platforms and browsers defined. Printing the warning when the file is loaded would cause unwanted noise on other platforms. > > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:87 > > + _log.warning('python psutil not found, cant check for ' > > + 'still-alive browser childs to kill.') > > cant -> can't > > childs -> child processes (or "children" but that's less clear here) > > > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:119 > > + from gi.repository import Gtk > > + screen = Gtk.Window().get_screen() > > + return screen.get_monitor_geometry(screen.get_primary_monitor()) > > These functions don't exist in GTK+ 4. Can you rewrite it to avoid > deprecations? That will make somebody's life easier in the distant future > when nothing else in WebKit still depends on GTK+ 3. :) > > has been deprecated since version 3.22 and > should not be used in newly-written code. > Use gdk_display_get_primary_monitor() instead > > gdk_screen_get_monitor_geometry has been deprecated since version 3.22 and > should not be used in newly-written code. > Use gdk_monitor_get_geometry() instead > > You'll have to test for version 3.22 as the replacement functions are brand > new. If it's inconvenient for you, you don't have to; it's not a blocker, > just a nice thing to do for whomever has to port this in the future. Could > be you or me. :p Does this fix the warnings for you? --- a/Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py +++ b/Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py @@ -114,6 +114,18 @@ class LinuxBrowserDriver(BrowserDriver): # trying to import the Gtk module on the global scope of this # file to avoid ImportError errors on other platforms. # Python imports are cached and only run once, so this should be ok. - from gi.repository import Gtk - screen = Gtk.Window().get_screen() - return screen.get_monitor_geometry(screen.get_primary_monitor()) + import gi + try: + gi.require_version('Gtk', '3.0') + gi.require_version('Gdk', '3.0') + except ValueError: + gi.require_version('Gtk', '4.0') + gi.require_version('Gdk', '4.0') + from gi.repository import Gtk, Gdk + if Gtk.get_major_version() == 3 and Gtk.get_minor_version() < 22: + screen = Gtk.Window().get_screen() + return screen.get_monitor_geometry(screen.get_primary_monitor()) + else: + display = Gdk.Display.get_default() + monitor = display.get_primary_monitor() + return monitor.get_geometry() 1254197 12 clopez 2016-11-28 21:06:06 -0800 (In reply to comment #10) > 2. Testing performance of benchmarks. In this scenario, we care about the > final benchmark score and want to get rid of potential impact introduced by > running another browser process. > As the second scenario is the major purpose of this script, personally, I > would like to kill all browsers by default. > However, I agree with you that it is undesired for developing purpose. So I > would recommend to make "killing testing browser process only" as an > optional argument. And we can turn on this feature by passing argument like > '--keep-existing-browser' (or you can come up with more descriptive argument > name). I agree with the idea that when generating performance-related data the machine should not be doing other thing that running the tests. However in this scenario is not only important to kill browsers by default, but to ensure that no other process are running. I don't think this script can reasonably guarantee that. Even if we run "killall chrome" when running chrome tests, there still can be a firefox browser open, or any other process using the CPU. I think is the admin/user of the bot/machine the one that should take care of ensuring this happens rather than relying on a simple killall. But I'm ok with having a switch to make this behaviour conditional. Maybe the switch should default to not doing a killall?, that way developers testing this script don't get their browsers killed by mistake. And I can ensure the gtk+ perf bot runs with the switch enabled by setting the required arguments on BuildSlaveSupport/build.webkit.org-config/master.cfg. what do you think? 1254215 13 294912 dbates 2016-11-28 22:44:45 -0800 Comment on attachment 294912 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=294912&action=review I did not review this patch for correctness. I noticed some very minor issues. > Tools/ChangeLog:11 > + It add also drivers for chrome (chromium), firefox, epiphany and minibrowser-gtk (previously minibrowser). Nit: chrome => Chrome chromium => Chromium firefox => Firefox epiphany => Epiphany minibrowser => MiniBrowser (These are proper names). > Tools/ChangeLog:17 > + We also check for the browser childs and we kill them if they are still alive after the browser has been killed. browser childs? > Tools/ChangeLog:21 > + (RunBenchmarkTests.start): The platform is now autodetected and the minibrowser driver is renamed to minibrowser-gtk. Nit: minibrowser => MiniBrowser > Tools/ChangeLog:23 > + (BenchmarkRunner._run_benchmark): Fix a bug: close_browsers was called twice. Its already called inside BenchmarkRunner._run_one_test Nit: Two colons (:) on the same line :(. Missing a period at the end of this sentence. > Tools/ChangeLog:52 > + (load_subclasses): The loading of subclasses was still (even after r196979) sensible to the order in which the modules are loaded. sensitive? > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:52 > + raise ValueError('Cant find executable for browser %s. Seached list: %s' > + % (self.browser_name, self.process_search_list)) This is OK as-is. From my understanding we prefer to use String.format() instead of the % operator to build up formatted string as the former is compatible with Python 3 and the latter is not. And we seem to hope to move to Python 3 one day... > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:73 > + _log.info('Killing browser %s with pid %d and cmd: %s' > + % (self.browser_name, self._browser_process.pid, > + ' '.join(main_browser_process.cmdline()).strip() > + or main_browser_process.name())) Ditto. > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:80 > + _log.info('Killing still alive %s child with pid %d and cmd: %s' > + % (self.browser_name, browser_child.pid, > + ' '.join(browser_child.cmdline()).strip() > + or browser_child.name())) Ditto. > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:84 > + _log.info('Killing browser %s with pid %d' > + % (self.browser_name, self._browser_process.pid)) Ditto. > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:97 > + _log.info('Executing: %s' % (' '.join(exec_args))) Ditto. > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:102 > + def _get_first_executable_path_from_list(self, searchlist): Nit: searchlist => search_list (We separate words in variable/function/class names with underscores). > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_epiphany_driver.py:36 > + '--profile=%s' % (self._temp_profiledir), Is it necessary to pass the option name and value as one argument. I mean, we are using subprocess to execute this command without the shell. So, can we write this as two arguments similar to what we did in LinuxFirefoxDriver: '--profile', self._temp_profiledir? If not, from my understanding we prefer to use String.format() instead of the % operator to build up formatted string as the former is compatible with Python 3 and the latter is not. And we seem to hope to move to Python 3 one day... > Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_minibrowsergtk_driver.py:38 > + self._browser_arguments.append('--geometry=%sx%s' % (self._screen_size().width, self._screen_size().height)) This is OK as-is. From my understanding we prefer to use String.format() instead of the % operator to build up formatted string as the former is compatible with Python 3 and the latter is not. And we seem to hope to move to Python 3 one day... > Tools/Scripts/webkitpy/benchmark_runner/run_benchmark.py:17 > +def getplatform(): Maybe a better name for this function would be default_platform? > Tools/Scripts/webkitpy/benchmark_runner/run_benchmark.py:23 > +def getdefaultbrowser(): Maybe a better name for this function would be default_browser? 1254248 14 mcatanzaro 2016-11-29 05:49:53 -0800 (In reply to comment #11) > Does this fix the warnings for you? > > --- > a/Tools/Scripts/webkitpy/benchmark_runner/browser_driver/ > linux_browser_driver.py > +++ > b/Tools/Scripts/webkitpy/benchmark_runner/browser_driver/ > linux_browser_driver.py > @@ -114,6 +114,18 @@ class LinuxBrowserDriver(BrowserDriver): > # trying to import the Gtk module on the global scope of this > # file to avoid ImportError errors on other platforms. > # Python imports are cached and only run once, so this should be ok. > - from gi.repository import Gtk > - screen = Gtk.Window().get_screen() > - return screen.get_monitor_geometry(screen.get_primary_monitor()) > + import gi > + try: > + gi.require_version('Gtk', '3.0') > + gi.require_version('Gdk', '3.0') > + except ValueError: > + gi.require_version('Gtk', '4.0') > + gi.require_version('Gdk', '4.0') > + from gi.repository import Gtk, Gdk > + if Gtk.get_major_version() == 3 and Gtk.get_minor_version() < 22: > + screen = Gtk.Window().get_screen() > + return screen.get_monitor_geometry(screen.get_primary_monitor()) > + else: > + display = Gdk.Display.get_default() > + monitor = display.get_primary_monitor() > + return monitor.get_geometry() I didn't actually test. I wouldn't use the try/except for gi.require_version as we haven't actually tested with GTK+ 4, but otherwise it looks sane. 1254249 15 mcatanzaro 2016-11-29 05:54:46 -0800 (In reply to comment #13) > This is OK as-is. From my understanding we prefer to use String.format() > instead of the % operator to build up formatted string as the former is > compatible with Python 3 and the latter is not. And we seem to hope to move > to Python 3 one day... Seems to work just fine: #!/usr/bin/python3 print('I have %d apples and %d oranges' % (2, 12)) 1254253 16 clopez 2016-11-29 06:12:32 -0800 (In reply to comment #14) > (In reply to comment #11) > > Does this fix the warnings for you? > > > > --- > > a/Tools/Scripts/webkitpy/benchmark_runner/browser_driver/ > > linux_browser_driver.py > > +++ > > b/Tools/Scripts/webkitpy/benchmark_runner/browser_driver/ > > linux_browser_driver.py > > @@ -114,6 +114,18 @@ class LinuxBrowserDriver(BrowserDriver): > > # trying to import the Gtk module on the global scope of this > > # file to avoid ImportError errors on other platforms. > > # Python imports are cached and only run once, so this should be ok. > > - from gi.repository import Gtk > > - screen = Gtk.Window().get_screen() > > - return screen.get_monitor_geometry(screen.get_primary_monitor()) > > + import gi > > + try: > > + gi.require_version('Gtk', '3.0') > > + gi.require_version('Gdk', '3.0') > > + except ValueError: > > + gi.require_version('Gtk', '4.0') > > + gi.require_version('Gdk', '4.0') > > + from gi.repository import Gtk, Gdk > > + if Gtk.get_major_version() == 3 and Gtk.get_minor_version() < 22: > > + screen = Gtk.Window().get_screen() > > + return screen.get_monitor_geometry(screen.get_primary_monitor()) > > + else: > > + display = Gdk.Display.get_default() > > + monitor = display.get_primary_monitor() > > + return monitor.get_geometry() > > I didn't actually test. I wouldn't use the try/except for gi.require_version > as we haven't actually tested with GTK+ 4, but otherwise it looks sane. Well, I actually tested it on a fedora 25 chroot and the only warning it printed was because not doing a gi.require_version() before importing Gtk or Gdk. So if the goal is to avoid warnings, I don't see how I can do it without calling gi.require_version() before trying the import. 1254259 17 mcatanzaro 2016-11-29 07:04:49 -0800 It's fine as-is, I just don't see much value in providing compatibility with both GTK+ 3 and GTK+ 4 at the same time in this little script when just GTK+ 3 will do. I don't mean to get rid of gi.require_version entirely, but to unconditionally require 3.0. 1254386 18 clopez 2016-11-29 12:09:16 -0800 (In reply to comment #15) > (In reply to comment #13) > > This is OK as-is. From my understanding we prefer to use String.format() > > instead of the % operator to build up formatted string as the former is > > compatible with Python 3 and the latter is not. And we seem to hope to move > > to Python 3 one day... > > Seems to work just fine: > > #!/usr/bin/python3 > > print('I have %d apples and %d oranges' % (2, 12)) (In reply to comment #15) > (In reply to comment #13) > > This is OK as-is. From my understanding we prefer to use String.format() > > instead of the % operator to build up formatted string as the former is > > compatible with Python 3 and the latter is not. And we seem to hope to move > > to Python 3 one day... > > Seems to work just fine: > > #!/usr/bin/python3 > > print('I have %d apples and %d oranges' % (2, 12)) It seems the % operator for string formatting was meant to be deprecated with python 3 but that never happened in the end. There is PEP3101 discouraging its usage, but nothing more than that. It seems last python 3 even has a new string format option (interpolated strings), so the result is that there are 3 ways of formatting strings. One that only works on python >= 3.6 (interpolated strings), and two ways that work with any version of python: the % operator and string.format. I personally find String.format() unnecessarily verbose. In any case I would change the format strings on this patch as asked by Daniel (i guess it will make at least the code style more consistent) 1254388 19 295618 clopez 2016-11-29 12:15:31 -0800 Created attachment 295618 Patch Patch for landing addressing comments. 1254390 20 clopez 2016-11-29 12:17:19 -0800 (In reply to comment #12) > (In reply to comment #10) > > 2. Testing performance of benchmarks. In this scenario, we care about the > > final benchmark score and want to get rid of potential impact introduced by > > running another browser process. > > As the second scenario is the major purpose of this script, personally, I > > would like to kill all browsers by default. > > However, I agree with you that it is undesired for developing purpose. So I > > would recommend to make "killing testing browser process only" as an > > optional argument. And we can turn on this feature by passing argument like > > '--keep-existing-browser' (or you can come up with more descriptive argument > > name). > > I agree with the idea that when generating performance-related data the > machine should not be doing other thing that running the tests. > > However in this scenario is not only important to kill browsers by default, > but to ensure that no other process are running. I don't think this script > can reasonably guarantee that. Even if we run "killall chrome" when running > chrome tests, there still can be a firefox browser open, or any other > process using the CPU. I think is the admin/user of the bot/machine the one > that should take care of ensuring this happens rather than relying on a > simple killall. > > But I'm ok with having a switch to make this behaviour conditional. > > Maybe the switch should default to not doing a killall?, that way developers > testing this script don't get their browsers killed by mistake. > And I can ensure the gtk+ perf bot runs with the switch enabled by setting > the required arguments on > BuildSlaveSupport/build.webkit.org-config/master.cfg. > > what do you think? Regarding this suggestion I will open a new bug after landing this patch. It has to touch also the osx_browser_driver, so better do it on a different bug. 1254391 21 commit-queue 2016-11-29 12:18:13 -0800 Attachment 295618 did not pass style-queue: ERROR: Tools/Scripts/webkitpy/benchmark_runner/browser_driver/linux_browser_driver.py:83: [LinuxBrowserDriver.close_browsers] Instance of 'Popen' has no 'kill' member [pylint/E1101] [5] Total errors found: 1 in 10 files If any of these errors are false positives, please file a bug against check-webkit-style. 1254395 22 dewei_zhu 2016-11-29 12:27:27 -0800 (In reply to comment #12) > (In reply to comment #10) > > 2. Testing performance of benchmarks. In this scenario, we care about the > > final benchmark score and want to get rid of potential impact introduced by > > running another browser process. > > As the second scenario is the major purpose of this script, personally, I > > would like to kill all browsers by default. > > However, I agree with you that it is undesired for developing purpose. So I > > would recommend to make "killing testing browser process only" as an > > optional argument. And we can turn on this feature by passing argument like > > '--keep-existing-browser' (or you can come up with more descriptive argument > > name). > > I agree with the idea that when generating performance-related data the > machine should not be doing other thing that running the tests. > > However in this scenario is not only important to kill browsers by default, > but to ensure that no other process are running. I don't think this script > can reasonably guarantee that. Even if we run "killall chrome" when running > chrome tests, there still can be a firefox browser open, or any other > process using the CPU. I think is the admin/user of the bot/machine the one > that should take care of ensuring this happens rather than relying on a > simple killall. > > But I'm ok with having a switch to make this behaviour conditional. > > Maybe the switch should default to not doing a killall?, that way developers > testing this script don't get their browsers killed by mistake. > And I can ensure the gtk+ perf bot runs with the switch enabled by setting > the required arguments on > BuildSlaveSupport/build.webkit.org-config/master.cfg. > > what do you think? We could try, but my major concern is changing the default behavior seems risky. As it may potentially break things rely on this script. If we make "killall" as default, we don't need to worry about that. Furthermore, as running this script requires several arguments already, it wouldn't be too much pain to turn on an extra switch. 1254462 23 295618 commit-queue 2016-11-29 14:16:11 -0800 Comment on attachment 295618 Patch Clearing flags on attachment: 295618 Committed r209090: <http://trac.webkit.org/changeset/209090> 1254463 24 commit-queue 2016-11-29 14:16:17 -0800 All reviewed patches have been landed. Closing bug. 1254560 25 clopez 2016-11-29 16:24:58 -0800 (In reply to comment #22) > (In reply to comment #12) > > (In reply to comment #10) > > > 2. Testing performance of benchmarks. In this scenario, we care about the > > > final benchmark score and want to get rid of potential impact introduced by > > > running another browser process. > > > As the second scenario is the major purpose of this script, personally, I > > > would like to kill all browsers by default. > > > However, I agree with you that it is undesired for developing purpose. So I > > > would recommend to make "killing testing browser process only" as an > > > optional argument. And we can turn on this feature by passing argument like > > > '--keep-existing-browser' (or you can come up with more descriptive argument > > > name). > > > > I agree with the idea that when generating performance-related data the > > machine should not be doing other thing that running the tests. > > > > However in this scenario is not only important to kill browsers by default, > > but to ensure that no other process are running. I don't think this script > > can reasonably guarantee that. Even if we run "killall chrome" when running > > chrome tests, there still can be a firefox browser open, or any other > > process using the CPU. I think is the admin/user of the bot/machine the one > > that should take care of ensuring this happens rather than relying on a > > simple killall. > > > > But I'm ok with having a switch to make this behaviour conditional. > > > > Maybe the switch should default to not doing a killall?, that way developers > > testing this script don't get their browsers killed by mistake. > > And I can ensure the gtk+ perf bot runs with the switch enabled by setting > > the required arguments on > > BuildSlaveSupport/build.webkit.org-config/master.cfg. > > > > what do you think? > > We could try, but my major concern is changing the default behavior seems > risky. As it may potentially break things rely on this script. > If we make "killall" as default, we don't need to worry about that. > Furthermore, as running this script requires several arguments already, it > wouldn't be too much pain to turn on an extra switch. Yes, I think this are sensible arguments. Breaking current behaviour without a good argument is usually a bad idea. And you are right that users of this script should have no trouble by passing an extra argument to avoid the killall. I have opened bug 165173 for fixing this. 294912 2016-11-15 19:07:46 -0800 2016-11-29 12:15:22 -0800 Patch bug-164792-20161116040742.patch text/plain 31116 clopez U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4NzQ4CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZDBmMTMyNzI4ODU2ZGZjZTNjNjQyYjYyZTEyZDNmYWY5 OTE0OWZhOC4uMjVjZGRlNTMxODBkNTFlOTg2Yjc4NTFhNjkxNzBmMTkyMzQwY2VmOCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU4 IEBACisyMDE2LTExLTE1ICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2Fs aWEuY29tPgorCisgICAgICAgIFtMaW51eF0gcnVuLWJlbmNobWFyayBzaG91bGQgYmUgYWJsZSB0 byBleGVjdXRlIHRoZSBiZW5jaG1hcmtzIHdpdGggbW9yZSBicm93c2Vycy4KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NDc5MgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcmVtb3ZlcyB0aGUgR1RL QnJvd3NlckRyaXZlciAoYW5kIHRoZSBwbGF0Zm9ybSAnZ3RrJykgZnJvbSB0aGUgcnVuLWJlbmNo bWFyayBzY3JpcHQsCisgICAgICAgIGFuZCBhZGRzIGEgbmV3IExpbnV4QnJvd3NlckRyaXZlciB3 aXRoIGEgcGxhdGZvcm0gJ2xpbnV4Jy4KKworICAgICAgICBJdCBhZGQgYWxzbyBkcml2ZXJzIGZv ciBjaHJvbWUgKGNocm9taXVtKSwgZmlyZWZveCwgZXBpcGhhbnkgYW5kIG1pbmlicm93c2VyLWd0 ayAocHJldmlvdXNseSBtaW5pYnJvd3NlcikuCisKKyAgICAgICAgVGhlIGRldGVjdGlvbiBvZiB0 aGUgcGxhdGZvcm0gaXMgbm93IGRvbmUgYXV0b21hdGljYWxseSwgc28gaXQgaXMgbm90IGxvbmdl ciBuZWVkZWQgdG8gcGFzcyBhICItLXBsYXRmb3JtIiBwYXJhbWV0ZXIuCisKKyAgICAgICAgVGhl IHRyYWNraW5nIG9mIHRoZSBicm93c2VyIHByb2Nlc3MgaXMgbm93IG1vcmUgcm9idXN0LCB3ZSB0 cmFjayB0aGUgcGlkIG9mIHRoZSBicm93c2VyIHByb2Nlc3MgYW5kIHdlIG9ubHkgdHJ5IHRvCisg ICAgICAgIGtpbGwgdGhlIG9uZXMgdGhhdCB3ZXJlIGV4ZWN1dGVkIGJ5IHRoaXMgc2NyaXB0LCBp bnN0ZWFkIG9mIGRvaW5nIGEgJ2tpbGxhbGwgJGJyb3dzZXInIChsaWtlIGJlZm9yZSkuCisgICAg ICAgIFdlIGFsc28gY2hlY2sgZm9yIHRoZSBicm93c2VyIGNoaWxkcyBhbmQgd2Uga2lsbCB0aGVt IGlmIHRoZXkgYXJlIHN0aWxsIGFsaXZlIGFmdGVyIHRoZSBicm93c2VyIGhhcyBiZWVuIGtpbGxl ZC4KKyAgICAgICAgVGhpcyBkZXBlbmRzIG9uIHBzdXRpbCwgc28gdGhpcyB3aWxsIG9ubHkgYmUg ZG9uZSBpZiBwc3V0aWwgaXMgaW5zdGFsbGVkLgorCisgICAgICAgICogQnVpbGRTbGF2ZVN1cHBv cnQvYnVpbGQud2Via2l0Lm9yZy1jb25maWcvbWFzdGVyLmNmZzoKKyAgICAgICAgKFJ1bkJlbmNo bWFya1Rlc3RzLnN0YXJ0KTogVGhlIHBsYXRmb3JtIGlzIG5vdyBhdXRvZGV0ZWN0ZWQgYW5kIHRo ZSBtaW5pYnJvd3NlciBkcml2ZXIgaXMgcmVuYW1lZCB0byBtaW5pYnJvd3Nlci1ndGsuCisgICAg ICAgICogU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2JlbmNobWFya19ydW5uZXIu cHk6CisgICAgICAgIChCZW5jaG1hcmtSdW5uZXIuX3J1bl9iZW5jaG1hcmspOiBGaXggYSBidWc6 IGNsb3NlX2Jyb3dzZXJzIHdhcyBjYWxsZWQgdHdpY2UuIEl0cyBhbHJlYWR5IGNhbGxlZCBpbnNp ZGUgQmVuY2htYXJrUnVubmVyLl9ydW5fb25lX3Rlc3QKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfYnJvd3Nlcl9kcml2ZXIu cHk6IEFkZGVkLgorICAgICAgICAoTGludXhCcm93c2VyRHJpdmVyKTogSW1wbGVtZW50IGJhc2Ug Y2xhc3MgdGhhdCBoYXMgYWxsIHRoZSBuZWVkZWQgZnVuY3Rpb25hbGl0eSBmb3IgZHJpdmluZyB0 aGUgYnJvd3NlcnMuCisgICAgICAgIChMaW51eEJyb3dzZXJEcml2ZXIuX19pbml0X18pOgorICAg ICAgICAoTGludXhCcm93c2VyRHJpdmVyLnByZXBhcmVfZW52KToKKyAgICAgICAgKExpbnV4QnJv d3NlckRyaXZlci5yZXN0b3JlX2Vudik6CisgICAgICAgIChMaW51eEJyb3dzZXJEcml2ZXIuY2xv c2VfYnJvd3NlcnMpOiBNYWRlIHRoZSBkZXBlbmRlbmN5IG9uIHBzdXRpbCBvcHRpb25hbCAoYmVj YXVzZSBpdCB3YXMgbGlzdGVkIGFzIHN1Y2ggb24gdGhlIFJFQURNRSBmaWxlIDxUb29scy9TY3Jp cHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvUkVBRE1FLm1kPikKKyAgICAgICAgKExpbnV4 QnJvd3NlckRyaXZlci5sYXVuY2hfdXJsKToKKyAgICAgICAgKExpbnV4QnJvd3NlckRyaXZlci5f Z2V0X2ZpcnN0X2V4ZWN1dGFibGVfcGF0aF9mcm9tX2xpc3QpOgorICAgICAgICAoTGludXhCcm93 c2VyRHJpdmVyLl9zY3JlZW5fc2l6ZSk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9iZW5j aG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2xpbnV4X2Nocm9tZV9kcml2ZXIucHk6IENvcGll ZCBmcm9tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2Ry aXZlci9ndGtfbWluaWJyb3dzZXJfZHJpdmVyLnB5LgorICAgICAgICAoTGludXhDaHJvbWVEcml2 ZXIpOgorICAgICAgICAoTGludXhDaHJvbWVEcml2ZXIubGF1bmNoX3VybCk6CisgICAgICAgICog U2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2xpbnV4X2Vw aXBoYW55X2RyaXZlci5weTogUmVuYW1lZCBmcm9tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVu Y2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9ndGtfYnJvd3Nlcl9kcml2ZXIucHkuCisgICAg ICAgIChFcGlwaGFueUJyb3dzZXJEcml2ZXIpOgorICAgICAgICAoRXBpcGhhbnlCcm93c2VyRHJp dmVyLmxhdW5jaF91cmwpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1 bm5lci9icm93c2VyX2RyaXZlci9saW51eF9maXJlZm94X2RyaXZlci5weTogQ29waWVkIGZyb20g VG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2d0 a19taW5pYnJvd3Nlcl9kcml2ZXIucHkuCisgICAgICAgIChMaW51eEZpcmVmb3hEcml2ZXIpOgor ICAgICAgICAoTGludXhGaXJlZm94RHJpdmVyLmxhdW5jaF91cmwpOgorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9taW5pYnJv d3Nlcmd0a19kcml2ZXIucHk6IFJlbmFtZWQgZnJvbSBUb29scy9TY3JpcHRzL3dlYmtpdHB5L2Jl bmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX21pbmlicm93c2VyX2RyaXZlci5weS4K KyAgICAgICAgKEdUS01pbmlCcm93c2VyRHJpdmVyKToKKyAgICAgICAgKEdUS01pbmlCcm93c2Vy RHJpdmVyLmxhdW5jaF91cmwpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJr X3J1bm5lci9odHRwX3NlcnZlcl9kcml2ZXIvc2ltcGxlX2h0dHBfc2VydmVyX2RyaXZlci5weToK KyAgICAgICAgKFNpbXBsZUhUVFBTZXJ2ZXJEcml2ZXIpOgorICAgICAgICAqIFNjcmlwdHMvd2Vi a2l0cHkvYmVuY2htYXJrX3J1bm5lci9ydW5fYmVuY2htYXJrLnB5OgorICAgICAgICAoZ2V0cGxh dGZvcm0pOgorICAgICAgICAoZ2V0ZGVmYXVsdGJyb3dzZXIpOgorICAgICAgICAocGFyc2VfYXJn cyk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL3V0aWxzLnB5 OgorICAgICAgICAobG9hZF9zdWJjbGFzc2VzKTogVGhlIGxvYWRpbmcgb2Ygc3ViY2xhc3NlcyB3 YXMgc3RpbGwgKGV2ZW4gYWZ0ZXIgcjE5Njk3OSkgc2Vuc2libGUgdG8gdGhlIG9yZGVyIGluIHdo aWNoIHRoZSBtb2R1bGVzIGFyZSBsb2FkZWQuCisgICAgICAgIFdlIGhhdmUgdG8gZW5zdXJlIHRo YXQgdGhlIGZpbGVzIGNvbnRhaW5pbmcgc3ViY2xhc3NlcyBvZiB0aGUgYmFzZV9jbGFzc19maWxl IGFyZSBsb2FkZWQgYWZ0ZXIgdGhlIGJhc2VfY2xhc3NfZmlsZSwKKyAgICAgICAgd2UgY2FuIGRv IHRoYXQgYnkgbWF0Y2hpbmcgYWdhaW5zdCB0aGUgYmFzZV9jbGFzc19maWxlIHBhdHRlcm4gd2hl biB0aGUgbGlzdCBpcyBjcmVhdGVkLgorCiAyMDE2LTExLTE0ICBNYXJrIExhbSAgPG1hcmsubGFt QGFwcGxlLmNvbT4KIAogICAgICAgICBFbmhhbmNlIHJ1bi1qc2Mtc3RyZXNzLXRlc3Qgc2NyaXB0 IHRvIGFsbG93IG9wdGlvbmFsIHRlc3Qgc3BlY2lmaWMgb3B0aW9ucyB0byBiZSBhZGRlZCBmb3Ig YWxsIHRlc3QgcnVuIGNvbmZpZ3VyYXRpb25zLgpkaWZmIC0tZ2l0IGEvVG9vbHMvQnVpbGRTbGF2 ZVN1cHBvcnQvYnVpbGQud2Via2l0Lm9yZy1jb25maWcvbWFzdGVyLmNmZyBiL1Rvb2xzL0J1aWxk U2xhdmVTdXBwb3J0L2J1aWxkLndlYmtpdC5vcmctY29uZmlnL21hc3Rlci5jZmcKaW5kZXggZTQ0 MjYxMzdjNjU2YzdjNjhlMzA5MzEzYzY0OTU5ZjA2NzEzNTc2Ni4uNjAwMzE4ZTVkZmQ5Y2NkMDUy ZWQ3ZWU0ZjY2MTFmMTBkMWVlMTk3OSAxMDA2NDQKLS0tIGEvVG9vbHMvQnVpbGRTbGF2ZVN1cHBv cnQvYnVpbGQud2Via2l0Lm9yZy1jb25maWcvbWFzdGVyLmNmZworKysgYi9Ub29scy9CdWlsZFNs YXZlU3VwcG9ydC9idWlsZC53ZWJraXQub3JnLWNvbmZpZy9tYXN0ZXIuY2ZnCkBAIC03MDEsNyAr NzAxLDcgQEAgY2xhc3MgUnVuQmVuY2htYXJrVGVzdHMoc2hlbGwuVGVzdCk6CiAgICAgZGVmIHN0 YXJ0KHNlbGYpOgogICAgICAgICBwbGF0Zm9ybSA9IHNlbGYuZ2V0UHJvcGVydHkoInBsYXRmb3Jt IikKICAgICAgICAgaWYgcGxhdGZvcm0gPT0gImd0ayI6Ci0gICAgICAgICAgICBzZWxmLmNvbW1h bmQgKz0gWyItLXBsYXRmb3JtIiwgImd0ayIsICItLWJyb3dzZXIiLCAibWluaWJyb3dzZXIiXQor ICAgICAgICAgICAgc2VsZi5jb21tYW5kICs9IFsiLS1icm93c2VyIiwgIm1pbmlicm93c2VyLWd0 ayJdCiAgICAgICAgIHNlbGYuc2V0Q29tbWFuZChzZWxmLmNvbW1hbmQpCiAgICAgICAgIHJldHVy biBzaGVsbC5UZXN0LnN0YXJ0KHNlbGYpCiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvYmVuY2htYXJrX3J1bm5lci9iZW5jaG1hcmtfcnVubmVyLnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2JlbmNobWFya19ydW5uZXIucHkKaW5kZXggMjVi M2JhNDQ2NDNlNDc5OWNlOTQ2MjczZjlkOWE1ZjJhYmYzMDM3Yi4uMjM3Mzg5YzI0ZGMxMzlmNmM2 MDZkMWVkYmIyY2Y3MmM1YzU5NjIxYiAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9iZW5jaG1hcmtfcnVubmVyL2JlbmNobWFya19ydW5uZXIucHkKKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2JlbmNobWFya19ydW5uZXIucHkKQEAgLTEwNyw3 ICsxMDcsNiBAQCBjbGFzcyBCZW5jaG1hcmtSdW5uZXIob2JqZWN0KToKIAogICAgICAgICAgICAg ZmluYWxseToKICAgICAgICAgICAgICAgICBzZWxmLl9icm93c2VyX2RyaXZlci5yZXN0b3JlX2Vu digpCi0gICAgICAgICAgICAgICAgc2VsZi5fYnJvd3Nlcl9kcml2ZXIuY2xvc2VfYnJvd3NlcnMo KQogCiAgICAgICAgICAgICBfbG9nLmluZm8oJ0VuZCB0aGUgaXRlcmF0aW9uIHtjdXJyZW50X2l0 ZXJhdGlvbn0gb2Yge2l0ZXJhdGlvbnN9IGZvciBjdXJyZW50IGJlbmNobWFyaycuZm9ybWF0KGN1 cnJlbnRfaXRlcmF0aW9uPWl0ZXJhdGlvbiwgaXRlcmF0aW9ucz1jb3VudCkpCiAKZGlmZiAtLWdp dCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZl ci9ndGtfYnJvd3Nlcl9kcml2ZXIucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFy a19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX2Jyb3dzZXJfZHJpdmVyLnB5CmRlbGV0ZWQgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwYjA4ZWE2YThkMTNhZjkxNGJiMGEwODE2NjNjODZlMTZjOWRk OTYzLi4wMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwCi0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9ndGtfYnJv d3Nlcl9kcml2ZXIucHkKKysrIC9kZXYvbnVsbApAQCAtMSw2NiArMCwwIEBACi0jIENvcHlyaWdo dCAoQykgMjAxNiBJZ2FsaWEgUy5MLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIwotIyBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKLSMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zIGFyZQotIyBtZXQ6Ci0jCi0jICAgICAqIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0jIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSMK LSMgICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZQotIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCi0jIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKLSMgZGlzdHJpYnV0aW9uLgotIwotIyBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09O VFJJQlVUT1JTCi0jICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UCi0jIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgotIyBBIFBBUlRJQ1VMQVIgUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAotIyBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwKLSMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVAotIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKLSMgREFUQSwgT1IgUFJPRklU UzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCi0j IFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQKLSMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCi0jIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0KLWltcG9ydCBsb2dn aW5nCi1pbXBvcnQgc3VicHJvY2VzcwotZnJvbSBicm93c2VyX2RyaXZlciBpbXBvcnQgQnJvd3Nl ckRyaXZlcgotCi1fbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCi0KLQotY2xhc3Mg R1RLQnJvd3NlckRyaXZlcihCcm93c2VyRHJpdmVyKToKLSAgICBwcm9jZXNzX25hbWUgPSBOb25l Ci0gICAgcGxhdGZvcm0gPSAnZ3RrJwotCi0gICAgZGVmIHByZXBhcmVfZW52KHNlbGYsIGRldmlj ZV9pZCk6Ci0gICAgICAgIHNlbGYuY2xvc2VfYnJvd3NlcnMoKQotCi0gICAgZGVmIHJlc3RvcmVf ZW52KHNlbGYpOgotICAgICAgICBwYXNzCi0KLSAgICBkZWYgY2xvc2VfYnJvd3NlcnMoc2VsZik6 Ci0gICAgICAgIHNlbGYuX3Rlcm1pbmF0ZV9wcm9jZXNzZXMoc2VsZi5wcm9jZXNzX25hbWUpCi0K LSAgICBAY2xhc3NtZXRob2QKLSAgICBkZWYgX2xhdW5jaF9wcm9jZXNzKGNscywgYXJncywgZW52 PU5vbmUpOgotICAgICAgICBwcm9jZXNzID0gc3VicHJvY2Vzcy5Qb3BlbihhcmdzKQotICAgICAg ICByZXR1cm4gcHJvY2VzcwotCi0gICAgQGNsYXNzbWV0aG9kCi0gICAgZGVmIF90ZXJtaW5hdGVf cHJvY2Vzc2VzKGNscywgcHJvY2Vzc19uYW1lKToKLSAgICAgICAgX2xvZy5pbmZvKCdDbG9zaW5n IGFsbCBwcm9jZXNzZXMgd2l0aCBuYW1lICVzJyAlIHByb2Nlc3NfbmFtZSkKLSAgICAgICAgc3Vi cHJvY2Vzcy5jYWxsKFsnL3Vzci9iaW4va2lsbGFsbCcsIHByb2Nlc3NfbmFtZV0pCi0KLSAgICBA Y2xhc3NtZXRob2QKLSAgICBkZWYgX3NjcmVlbl9zaXplKGNscyk6Ci0gICAgICAgICMgbG9hZF9z dWJjbGFzc2VzKCkgZnJvbSBfX2luaXRfXy5weSB3aWxsIGxvYWQgdGhpcyBmaWxlIHRvCi0gICAg ICAgICMgY2hlY2sgdGhlIHBsYXRmb3JtIGRlZmluZWQuIERvIGhlcmUgYSBsYXp5IGltcG9ydCBp bnN0ZWFkIG9mCi0gICAgICAgICMgdHJ5aW5nIHRvIGltcG9ydCB0aGUgR3RrIG1vZHVsZSBvbiB0 aGUgZ2xvYmFsIHNjb3BlIG9mIHRoaXMKLSAgICAgICAgIyBmaWxlIHRvIGF2b2lkIEltcG9ydEVy cm9yIGVycm9ycyBvbiBvdGhlciBwbGF0Zm9ybXMuCi0gICAgICAgICMgUHl0aG9uIGltcG9ydHMg YXJlIGNhY2hlZCBhbmQgb25seSBydW4gb25jZSwgc28gdGhpcyBzaG91bGQgYmUgb2suCi0gICAg ICAgIGZyb20gZ2kucmVwb3NpdG9yeSBpbXBvcnQgR3RrCi0gICAgICAgIHNjcmVlbiA9IEd0ay5X aW5kb3coKS5nZXRfc2NyZWVuKCkKLSAgICAgICAgcmV0dXJuIHNjcmVlbi5nZXRfbW9uaXRvcl9n ZW9tZXRyeShzY3JlZW4uZ2V0X3ByaW1hcnlfbW9uaXRvcigpKQpkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2d0a19taW5p YnJvd3Nlcl9kcml2ZXIucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5u ZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX21pbmlicm93c2VyX2RyaXZlci5weQpkZWxldGVkIGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggOThlNmM5ZTIzNTZlMmM5NTExNzY1MzQ2OGFmNTE2NjFiMjkzOGUw OS4uMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX21pbmli cm93c2VyX2RyaXZlci5weQorKysgL2Rldi9udWxsCkBAIC0xLDUzICswLDAgQEAKLSMgQ29weXJp Z2h0IChDKSAyMDE2IElnYWxpYSBTLkwuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0jCi0jIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAotIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMgYXJlCi0jIG1ldDoKLSMKLSMgICAgICogUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKLSMgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgot IwotIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlCi0jIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKLSMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQotIyBkaXN0cmlidXRpb24uCi0jCi0j IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBD T05UUklCVVRPUlMKLSMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKLSMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCi0jIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCi0j IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAotIyBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCi0jIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAotIyBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkK LSMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAotIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKLSMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLQotaW1wb3J0IGxv Z2dpbmcKLWltcG9ydCBzeXMKLWZyb20gZ3RrX2Jyb3dzZXJfZHJpdmVyIGltcG9ydCBHVEtCcm93 c2VyRHJpdmVyCi0KLV9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKLQotCi1jbGFz cyBHVEtNaW5pQnJvd3NlckRyaXZlcihHVEtCcm93c2VyRHJpdmVyKToKLSAgICBwcm9jZXNzX25h bWUgPSAnTWluaUJyb3dzZXInCi0gICAgYnJvd3Nlcl9uYW1lID0gJ21pbmlicm93c2VyJwotCi0g ICAgZGVmIHByZXBhcmVfZW52KHNlbGYsIGRldmljZV9pZCk6Ci0gICAgICAgIHNlbGYuX21pbmli cm93c2VyX3Byb2Nlc3MgPSBOb25lCi0gICAgICAgIHN1cGVyKEdUS01pbmlCcm93c2VyRHJpdmVy LCBzZWxmKS5wcmVwYXJlX2VudihkZXZpY2VfaWQpCi0KLSAgICBkZWYgbGF1bmNoX3VybChzZWxm LCB1cmwsIG9wdGlvbnMsIGJyb3dzZXJfYnVpbGRfcGF0aCk6Ci0gICAgICAgIGFyZ3MgPSBbJ1Rv b2xzL1NjcmlwdHMvcnVuLW1pbmlicm93c2VyJywgJy0tZ3RrJ10KLSAgICAgICAgYXJncy5hcHBl bmQoIi0tZ2VvbWV0cnk9JXN4JXMiICUgKHNlbGYuX3NjcmVlbl9zaXplKCkud2lkdGgsIHNlbGYu X3NjcmVlbl9zaXplKCkuaGVpZ2h0KSkKLSAgICAgICAgYXJncy5hcHBlbmQodXJsKQotICAgICAg ICBfbG9nLmluZm8oJ0xhdW5jaGluZyBNaW5pYnJvd3NlciB3aXRoIHVybDogJXMnICUgdXJsKQot ICAgICAgICBzZWxmLl9taW5pYnJvd3Nlcl9wcm9jZXNzID0gR1RLQnJvd3NlckRyaXZlci5fbGF1 bmNoX3Byb2Nlc3MoYXJncykKLQotICAgIGRlZiBjbG9zZV9icm93c2VycyhzZWxmKToKLSAgICAg ICAgc3VwZXIoR1RLTWluaUJyb3dzZXJEcml2ZXIsIHNlbGYpLmNsb3NlX2Jyb3dzZXJzKCkKLSAg ICAgICAgaWYgc2VsZi5fbWluaWJyb3dzZXJfcHJvY2VzcyBhbmQgc2VsZi5fbWluaWJyb3dzZXJf cHJvY2Vzcy5yZXR1cm5jb2RlOgotICAgICAgICAgICAgX2xvZy5lcnJvcignTWluaUJyb3dzZXIg Y3Jhc2hlZCB3aXRoIGV4aXRjb2RlICVkJyAlIHNlbGYuX21pbmlicm93c2VyX3Byb2Nlc3MucmV0 dXJuY29kZSkKLSAgICAgICAgICAgIHN5cy5leGl0KDEpCmRpZmYgLS1naXQgYS9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfYnJvd3Nl cl9kcml2ZXIucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJv d3Nlcl9kcml2ZXIvbGludXhfYnJvd3Nlcl9kcml2ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTdiNmZmNjc0 NjZlMWQxNmYyNTcxNWI0MWI0Y2YxM2ZiZWM2M2MwYgotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9i cm93c2VyX2RyaXZlci5weQpAQCAtMCwwICsxLDExOSBAQAorIyBDb3B5cmlnaHQgKEMpIDIwMTYg SWdhbGlhIFMuTC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjCisjICAgICAqIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMg Y29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor IyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCitpbXBvcnQgb3MKK2ltcG9ydCBzeXMK K2ltcG9ydCB0ZW1wZmlsZQoraW1wb3J0IGxvZ2dpbmcKK2ltcG9ydCBzdWJwcm9jZXNzCit0cnk6 CisgICAgaW1wb3J0IHBzdXRpbAorZXhjZXB0IEltcG9ydEVycm9yOgorICAgIHBhc3MKK2Zyb20g d2Via2l0cHkuYmVuY2htYXJrX3J1bm5lci51dGlscyBpbXBvcnQgZm9yY2VfcmVtb3ZlCitmcm9t IGJyb3dzZXJfZHJpdmVyIGltcG9ydCBCcm93c2VyRHJpdmVyCisKKworX2xvZyA9IGxvZ2dpbmcu Z2V0TG9nZ2VyKF9fbmFtZV9fKQorCisKK2NsYXNzIExpbnV4QnJvd3NlckRyaXZlcihCcm93c2Vy RHJpdmVyKToKKyAgICBicm93c2VyX25hbWUgPSBOb25lCisgICAgcHJvY2Vzc19zZWFyY2hfbGlz dCA9IFtdCisgICAgcGxhdGZvcm0gPSAnbGludXgnCisKKyAgICBkZWYgX19pbml0X18oc2VsZik6 CisgICAgICAgIHNlbGYucHJvY2Vzc19uYW1lID0gc2VsZi5fZ2V0X2ZpcnN0X2V4ZWN1dGFibGVf cGF0aF9mcm9tX2xpc3Qoc2VsZi5wcm9jZXNzX3NlYXJjaF9saXN0KQorICAgICAgICBpZiBzZWxm LnByb2Nlc3NfbmFtZSBpcyBOb25lOgorICAgICAgICAgICAgcmFpc2UgVmFsdWVFcnJvcignQ2Fu dCBmaW5kIGV4ZWN1dGFibGUgZm9yIGJyb3dzZXIgJXMuIFNlYWNoZWQgbGlzdDogJXMnCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAlIChzZWxmLmJyb3dzZXJfbmFtZSwgc2VsZi5wcm9j ZXNzX3NlYXJjaF9saXN0KSkKKworICAgIGRlZiBwcmVwYXJlX2VudihzZWxmLCBkZXZpY2VfaWQp OgorICAgICAgICBzZWxmLl9icm93c2VyX3Byb2Nlc3MgPSBOb25lCisgICAgICAgIHNlbGYuX2Jy b3dzZXJfYXJndW1lbnRzID0gTm9uZQorICAgICAgICBzZWxmLl90ZW1wX3Byb2ZpbGVkaXIgPSB0 ZW1wZmlsZS5ta2R0ZW1wKCkKKyAgICAgICAgc2VsZi5fdGVzdF9lbnZpcm9uID0gZGljdChvcy5l bnZpcm9uKQorICAgICAgICBzZWxmLl90ZXN0X2Vudmlyb25bJ0hPTUUnXSA9IHNlbGYuX3RlbXBf cHJvZmlsZWRpcgorCisgICAgZGVmIHJlc3RvcmVfZW52KHNlbGYpOgorICAgICAgICBmb3JjZV9y ZW1vdmUoc2VsZi5fdGVtcF9wcm9maWxlZGlyKQorCisgICAgZGVmIGNsb3NlX2Jyb3dzZXJzKHNl bGYpOgorICAgICAgICBpZiBzZWxmLl9icm93c2VyX3Byb2Nlc3M6CisgICAgICAgICAgICBpZiBz ZWxmLl9icm93c2VyX3Byb2Nlc3MucG9sbCgpIGlzIE5vbmU6ICAjIHN0aWxsIHJ1bm5pbmcKKyAg ICAgICAgICAgICAgICBpZiAncHN1dGlsJyBpbiBzeXMubW9kdWxlczoKKyAgICAgICAgICAgICAg ICAgICAgbWFpbl9icm93c2VyX3Byb2Nlc3MgPSBwc3V0aWwuUHJvY2VzcyhzZWxmLl9icm93c2Vy X3Byb2Nlc3MucGlkKQorICAgICAgICAgICAgICAgICAgICBicm93c2VyX2NoaWxkcmVuID0gbWFp bl9icm93c2VyX3Byb2Nlc3MuY2hpbGRyZW4ocmVjdXJzaXZlPVRydWUpCisgICAgICAgICAgICAg ICAgICAgIF9sb2cuaW5mbygnS2lsbGluZyBicm93c2VyICVzIHdpdGggcGlkICVkIGFuZCBjbWQ6 ICVzJworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICUgKHNlbGYuYnJvd3Nlcl9uYW1l LCBzZWxmLl9icm93c2VyX3Byb2Nlc3MucGlkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICcgJy5qb2luKG1haW5fYnJvd3Nlcl9wcm9jZXNzLmNtZGxpbmUoKSkuc3RyaXAoKQor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG9yIG1haW5fYnJvd3Nlcl9wcm9jZXNz Lm5hbWUoKSkpCisgICAgICAgICAgICAgICAgICAgIG1haW5fYnJvd3Nlcl9wcm9jZXNzLmtpbGwo KQorICAgICAgICAgICAgICAgICAgICBmb3IgYnJvd3Nlcl9jaGlsZCBpbiBicm93c2VyX2NoaWxk cmVuOgorICAgICAgICAgICAgICAgICAgICAgICAgaWYgYnJvd3Nlcl9jaGlsZC5pc19ydW5uaW5n KCk6CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgX2xvZy5pbmZvKCdLaWxsaW5nIHN0aWxs IGFsaXZlICVzIGNoaWxkIHdpdGggcGlkICVkIGFuZCBjbWQ6ICVzJworICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgJSAoc2VsZi5icm93c2VyX25hbWUsIGJyb3dzZXJfY2hp bGQucGlkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJyAnLmpv aW4oYnJvd3Nlcl9jaGlsZC5jbWRsaW5lKCkpLnN0cmlwKCkKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG9yIGJyb3dzZXJfY2hpbGQubmFtZSgpKSkKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICBicm93c2VyX2NoaWxkLmtpbGwoKQorICAgICAgICAgICAgICAg IGVsc2U6CisgICAgICAgICAgICAgICAgICAgIF9sb2cuaW5mbygnS2lsbGluZyBicm93c2VyICVz IHdpdGggcGlkICVkJworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICUgKHNlbGYuYnJv d3Nlcl9uYW1lLCBzZWxmLl9icm93c2VyX3Byb2Nlc3MucGlkKSkKKyAgICAgICAgICAgICAgICAg ICAgc2VsZi5fYnJvd3Nlcl9wcm9jZXNzLmtpbGwoKQorICAgICAgICAgICAgICAgICAgICBfbG9n Lndhcm5pbmcoJ3B5dGhvbiBwc3V0aWwgbm90IGZvdW5kLCBjYW50IGNoZWNrIGZvciAnCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnc3RpbGwtYWxpdmUgYnJvd3NlciBjaGlsZHMg dG8ga2lsbC4nKQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICBfbG9nLmVycm9y KCdCcm93c2VyICVzIHdpdGggcGlkICVkIGVuZGVkIHByZW1hdHVyZWx5IHdpdGggcmV0dXJuIGNv ZGUgJXMuJworICAgICAgICAgICAgICAgICAgICAgICAgICAgICUgKHNlbGYuYnJvd3Nlcl9uYW1l LCBzZWxmLl9icm93c2VyX3Byb2Nlc3MucGlkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHNlbGYuX2Jyb3dzZXJfcHJvY2Vzcy5yZXR1cm5jb2RlKSkKKworICAgIGRlZiBsYXVuY2hf dXJsKHNlbGYsIHVybCwgb3B0aW9ucywgYnJvd3Nlcl9idWlsZF9wYXRoKToKKyAgICAgICAgaWYg bm90IHNlbGYuX2Jyb3dzZXJfYXJndW1lbnRzOgorICAgICAgICAgICAgc2VsZi5fYnJvd3Nlcl9h cmd1bWVudHMgPSBbdXJsXQorICAgICAgICBleGVjX2FyZ3MgPSBbc2VsZi5wcm9jZXNzX25hbWVd ICsgc2VsZi5fYnJvd3Nlcl9hcmd1bWVudHMKKyAgICAgICAgX2xvZy5pbmZvKCdFeGVjdXRpbmc6 ICVzJyAlICgnICcuam9pbihleGVjX2FyZ3MpKSkKKyAgICAgICAgc2VsZi5fYnJvd3Nlcl9wcm9j ZXNzID0gc3VicHJvY2Vzcy5Qb3BlbihleGVjX2FyZ3MsIGVudj1zZWxmLl90ZXN0X2Vudmlyb24s CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Rkb3V0 PXN1YnByb2Nlc3MuUElQRSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBzdGRlcnI9c3VicHJvY2Vzcy5TVERPVVQpCisKKyAgICBkZWYgX2dldF9maXJz dF9leGVjdXRhYmxlX3BhdGhfZnJvbV9saXN0KHNlbGYsIHNlYXJjaGxpc3QpOgorICAgICAgICBz ZWFyY2hwYXRoID0gW29zLnBhdGguY3VyZGlyXSArIG9zLmVudmlyb25bJ1BBVEgnXS5zcGxpdChv cy5wYXRoc2VwKQorICAgICAgICBmb3IgcHJvZ3JhbSBpbiBzZWFyY2hsaXN0OgorICAgICAgICAg ICAgZm9yIHBhdGggaW4gc2VhcmNocGF0aDoKKyAgICAgICAgICAgICAgICBmdWxscGF0aCA9IG9z LnBhdGguYWJzcGF0aChvcy5wYXRoLmpvaW4ocGF0aCwgcHJvZ3JhbSkpCisgICAgICAgICAgICAg ICAgaWYgIG9zLnBhdGguaXNmaWxlKGZ1bGxwYXRoKSBhbmQgb3MuYWNjZXNzKGZ1bGxwYXRoLCBv cy5YX09LKToKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZ1bGxwYXRoCisgICAgICAgIHJl dHVybiBOb25lCisKKyAgICBkZWYgX3NjcmVlbl9zaXplKHNlbGYpOgorICAgICAgICAjIGxvYWRf c3ViY2xhc3NlcygpIGZyb20gX19pbml0X18ucHkgd2lsbCBsb2FkIHRoaXMgZmlsZSB0bworICAg ICAgICAjIGNoZWNrIHRoZSBwbGF0Zm9ybSBkZWZpbmVkLiBEbyBoZXJlIGEgbGF6eSBpbXBvcnQg aW5zdGVhZCBvZgorICAgICAgICAjIHRyeWluZyB0byBpbXBvcnQgdGhlIEd0ayBtb2R1bGUgb24g dGhlIGdsb2JhbCBzY29wZSBvZiB0aGlzCisgICAgICAgICMgZmlsZSB0byBhdm9pZCBJbXBvcnRF cnJvciBlcnJvcnMgb24gb3RoZXIgcGxhdGZvcm1zLgorICAgICAgICAjIFB5dGhvbiBpbXBvcnRz IGFyZSBjYWNoZWQgYW5kIG9ubHkgcnVuIG9uY2UsIHNvIHRoaXMgc2hvdWxkIGJlIG9rLgorICAg ICAgICBmcm9tIGdpLnJlcG9zaXRvcnkgaW1wb3J0IEd0aworICAgICAgICBzY3JlZW4gPSBHdGsu V2luZG93KCkuZ2V0X3NjcmVlbigpCisgICAgICAgIHJldHVybiBzY3JlZW4uZ2V0X21vbml0b3Jf Z2VvbWV0cnkoc2NyZWVuLmdldF9wcmltYXJ5X21vbml0b3IoKSkKZGlmZiAtLWdpdCBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9j aHJvbWVfZHJpdmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVy L2Jyb3dzZXJfZHJpdmVyL2xpbnV4X2Nocm9tZV9kcml2ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNzFjMTcy NzAyYWQ1MWZjNDc0ZWYwYzU3ZjExNGFmMmM2MWVjOWQzZQotLS0gL2Rldi9udWxsCisrKyBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51 eF9jaHJvbWVfZHJpdmVyLnB5CkBAIC0wLDAgKzEsMzcgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE2 IElnYWxpYSBTLkwuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMgYXJlCisjIG1ldDoKKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIworIyAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisj IGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIKKyMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZQorIyBkaXN0cmlidXRpb24uCisjCisjIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMK KyMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorIyBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworZnJvbSBsaW51eF9icm93c2VyX2Ry aXZlciBpbXBvcnQgTGludXhCcm93c2VyRHJpdmVyCisKKworY2xhc3MgTGludXhDaHJvbWVEcml2 ZXIoTGludXhCcm93c2VyRHJpdmVyKToKKyAgICBicm93c2VyX25hbWUgPSAnY2hyb21lJworICAg IHByb2Nlc3Nfc2VhcmNoX2xpc3QgPSBbJ2Nocm9taXVtJywgJ2Nocm9taXVtLWJyb3dzZXInLCAn Y2hyb21lJ10KKworICAgIGRlZiBsYXVuY2hfdXJsKHNlbGYsIHVybCwgb3B0aW9ucywgYnJvd3Nl cl9idWlsZF9wYXRoKToKKyAgICAgICAgc2VsZi5fYnJvd3Nlcl9hcmd1bWVudHMgPSBbJy0tdGVt cC1wcm9maWxlJywgJy0tc3RhcnQtbWF4aW1pemVkJywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgJy0taG9tZXBhZ2UnLCB1cmxdCisgICAgICAgIHN1cGVyKExpbnV4Q2hyb21l RHJpdmVyLCBzZWxmKS5sYXVuY2hfdXJsKHVybCwgb3B0aW9ucywgYnJvd3Nlcl9idWlsZF9wYXRo KQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jy b3dzZXJfZHJpdmVyL2xpbnV4X2VwaXBoYW55X2RyaXZlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9lcGlwaGFueV9kcml2 ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMTY2MWMyZDY2Y2IzZGJlNDYwM2EyNGM2MDYxMzM5MDBkOTNkNGZh MQotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1 bm5lci9icm93c2VyX2RyaXZlci9saW51eF9lcGlwaGFueV9kcml2ZXIucHkKQEAgLTAsMCArMSwz OCBAQAorIyBDb3B5cmlnaHQgKEMpIDIwMTYgSWdhbGlhIFMuTC4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3Ry aWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hU IEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMg QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI RSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisj IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorCitmcm9tIGxpbnV4X2Jyb3dzZXJfZHJpdmVyIGltcG9ydCBMaW51eEJyb3dzZXJEcml2ZXIK KworCitjbGFzcyBFcGlwaGFueUJyb3dzZXJEcml2ZXIoTGludXhCcm93c2VyRHJpdmVyKToKKyAg ICBicm93c2VyX25hbWUgPSAnZXBpcGhhbnknCisgICAgcHJvY2Vzc19zZWFyY2hfbGlzdCA9IFsn ZXBpcGhhbnknLCAnZXBpcGhhbnktYnJvd3NlciddCisKKyAgICBkZWYgbGF1bmNoX3VybChzZWxm LCB1cmwsIG9wdGlvbnMsIGJyb3dzZXJfYnVpbGRfcGF0aCk6CisgICAgICAgIHNlbGYuX2Jyb3dz ZXJfYXJndW1lbnRzID0gWyctLW5ldy13aW5kb3cnLCAnLXAnLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAnLS1wcm9maWxlPSVzJyAlIChzZWxmLl90ZW1wX3Byb2ZpbGVkaXIp LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1cmxdCisgICAgICAgIHN1cGVy KEVwaXBoYW55QnJvd3NlckRyaXZlciwgc2VsZikubGF1bmNoX3VybCh1cmwsIG9wdGlvbnMsIGJy b3dzZXJfYnVpbGRfcGF0aCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVu Y2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9maXJlZm94X2RyaXZlci5weSBiL1Rv b2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51 eF9maXJlZm94X2RyaXZlci5weQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zYzVlYjQ5ZDhkMjhhOTA3NTQ2MmEwODIz ZmU3MDgzOGQyZjUwNWQ0Ci0tLSAvZGV2L251bGwKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2xpbnV4X2ZpcmVmb3hfZHJpdmVyLnB5 CkBAIC0wLDAgKzEsMzkgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisjIG1ldDoK KyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNvcHlyaWdodCBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyMg aW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZQorIyBkaXN0cmlidXRpb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg VEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyMgIkFTIElTIiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElN SVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorIyBTUEVDSUFMLCBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisjIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UK KyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKworZnJvbSBsaW51eF9icm93c2VyX2RyaXZlciBpbXBvcnQgTGludXhC cm93c2VyRHJpdmVyCisKKworY2xhc3MgTGludXhGaXJlZm94RHJpdmVyKExpbnV4QnJvd3NlckRy aXZlcik6CisgICAgYnJvd3Nlcl9uYW1lID0gJ2ZpcmVmb3gnCisgICAgcHJvY2Vzc19zZWFyY2hf bGlzdCA9IFsnZmlyZWZveCddCisKKyAgICBkZWYgbGF1bmNoX3VybChzZWxmLCB1cmwsIG9wdGlv bnMsIGJyb3dzZXJfYnVpbGRfcGF0aCk6CisgICAgICAgIHNlbGYuX2Jyb3dzZXJfYXJndW1lbnRz ID0gWyctbmV3LWluc3RhbmNlJywgJy1wcm9maWxlJywgc2VsZi5fdGVtcF9wcm9maWxlZGlyLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnLXdpZHRoJywgc3RyKHNlbGYuX3Nj cmVlbl9zaXplKCkud2lkdGgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAn LWhlaWdodCcsIHN0cihzZWxmLl9zY3JlZW5fc2l6ZSgpLmhlaWdodCksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHVybF0KKyAgICAgICAgc3VwZXIoTGludXhGaXJlZm94RHJp dmVyLCBzZWxmKS5sYXVuY2hfdXJsKHVybCwgb3B0aW9ucywgYnJvd3Nlcl9idWlsZF9wYXRoKQpk aWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dz ZXJfZHJpdmVyL2xpbnV4X21pbmlicm93c2VyZ3RrX2RyaXZlci5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9taW5pYnJvd3Nl cmd0a19kcml2ZXIucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjVjYTMyYjFiYjNhOTBjYWMzNmE5MWNmNDAyYTEw ZWZiYjA1YTJjYgotLS0gL2Rldi9udWxsCisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVu Y2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9taW5pYnJvd3Nlcmd0a19kcml2ZXIu cHkKQEAgLTAsMCArMSw0MCBAQAorIyBDb3B5cmlnaHQgKEMpIDIwMTYgSWdhbGlhIFMuTC4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMgbWV0 OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLgorCitmcm9tIGxpbnV4X2Jyb3dzZXJfZHJpdmVyIGltcG9ydCBMaW51 eEJyb3dzZXJEcml2ZXIKKworCitjbGFzcyBHVEtNaW5pQnJvd3NlckRyaXZlcihMaW51eEJyb3dz ZXJEcml2ZXIpOgorICAgIGJyb3dzZXJfbmFtZSA9ICdtaW5pYnJvd3Nlci1ndGsnCisgICAgcHJv Y2Vzc19zZWFyY2hfbGlzdCA9IFsnVG9vbHMvU2NyaXB0cy9ydW4tbWluaWJyb3dzZXInLCAnTWlu aUJyb3dzZXInXQorCisgICAgZGVmIGxhdW5jaF91cmwoc2VsZiwgdXJsLCBvcHRpb25zLCBicm93 c2VyX2J1aWxkX3BhdGgpOgorICAgICAgICBzZWxmLl9icm93c2VyX2FyZ3VtZW50cyA9IFtdCisg ICAgICAgIGlmIHNlbGYucHJvY2Vzc19uYW1lLmVuZHN3aXRoKCdydW4tbWluaWJyb3dzZXInKToK KyAgICAgICAgICAgIHNlbGYuX2Jyb3dzZXJfYXJndW1lbnRzLmFwcGVuZCgnLS1ndGsnKQorICAg ICAgICBzZWxmLl9icm93c2VyX2FyZ3VtZW50cy5hcHBlbmQoJy0tZ2VvbWV0cnk9JXN4JXMnICUg KHNlbGYuX3NjcmVlbl9zaXplKCkud2lkdGgsIHNlbGYuX3NjcmVlbl9zaXplKCkuaGVpZ2h0KSkK KyAgICAgICAgc2VsZi5fYnJvd3Nlcl9hcmd1bWVudHMuYXBwZW5kKHVybCkKKyAgICAgICAgc3Vw ZXIoR1RLTWluaUJyb3dzZXJEcml2ZXIsIHNlbGYpLmxhdW5jaF91cmwodXJsLCBvcHRpb25zLCBi cm93c2VyX2J1aWxkX3BhdGgpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2Jl bmNobWFya19ydW5uZXIvaHR0cF9zZXJ2ZXJfZHJpdmVyL3NpbXBsZV9odHRwX3NlcnZlcl9kcml2 ZXIucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvaHR0cF9zZXJ2 ZXJfZHJpdmVyL3NpbXBsZV9odHRwX3NlcnZlcl9kcml2ZXIucHkKaW5kZXggMjZkODhmZDM5Y2I3 N2E2MjBjN2MyMDZiMzM3MWMzMzA2NGY3ZWI0YS4uN2Y4NzhmNzkyYjJmNjE1ZTI1MjFiNmQzZWRm YzM3ZjNiNzRjNGI4YSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1h cmtfcnVubmVyL2h0dHBfc2VydmVyX2RyaXZlci9zaW1wbGVfaHR0cF9zZXJ2ZXJfZHJpdmVyLnB5 CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9odHRwX3NlcnZl cl9kcml2ZXIvc2ltcGxlX2h0dHBfc2VydmVyX2RyaXZlci5weQpAQCAtMTksNyArMTksNyBAQCBj bGFzcyBTaW1wbGVIVFRQU2VydmVyRHJpdmVyKEhUVFBTZXJ2ZXJEcml2ZXIpOgogICAgICIiIlRo aXMgY2xhc3MgZGVwZW5kcyBvbiB1bml4IGVudmlyb25tZW50LCBuZWVkIHRvIGJlIG1vZGlmaWVk IHRvIGFjaGlldmUgY3Jvc3NwbGF0Zm9ybSBjb21wYWJpbGl0eQogICAgICIiIgogCi0gICAgcGxh dGZvcm1zID0gWydvc3gnLCAnZ3RrJ10KKyAgICBwbGF0Zm9ybXMgPSBbJ29zeCcsICdsaW51eCdd CiAKICAgICBkZWYgX19pbml0X18oc2VsZik6CiAgICAgICAgIHNlbGYuX3NlcnZlcl9wcm9jZXNz ID0gTm9uZQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVu bmVyL3J1bl9iZW5jaG1hcmsucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19y dW5uZXIvcnVuX2JlbmNobWFyay5weQppbmRleCA2YTM1ODA1MmExOWNiZjY3ODY4NDgzNTg0NTZk ZTgxZWUyZjAxNmJkLi45MjVkNmFjOGNhZTc1MjNiZjk3MDM1NDdjYWUxMDA3MmFjZTVlODQ0IDEw MDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvcnVuX2Jl bmNobWFyay5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIv cnVuX2JlbmNobWFyay5weQpAQCAtNSw2ICs1LDcgQEAgaW1wb3J0IGpzb24KIGltcG9ydCBsb2dn aW5nCiBpbXBvcnQgcGxhdGZvcm0KIGltcG9ydCBvcworaW1wb3J0IHN5cwogCiBmcm9tIGJlbmNo bWFya19ydW5uZXIgaW1wb3J0IEJlbmNobWFya1J1bm5lcgogZnJvbSBicm93c2VyX2RyaXZlci5i cm93c2VyX2RyaXZlcl9mYWN0b3J5IGltcG9ydCBCcm93c2VyRHJpdmVyRmFjdG9yeQpAQCAtMTMs MTMgKzE0LDI0IEBAIGZyb20gYnJvd3Nlcl9kcml2ZXIuYnJvd3Nlcl9kcml2ZXJfZmFjdG9yeSBp bXBvcnQgQnJvd3NlckRyaXZlckZhY3RvcnkKIF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihfX25h bWVfXykKIAogCitkZWYgZ2V0cGxhdGZvcm0oKToKKyAgICBpZiBzeXMucGxhdGZvcm0uc3RhcnRz d2l0aCgnbGludXgnKToKKyAgICAgICAgcmV0dXJuICdsaW51eCcKKyAgICByZXR1cm4gJ29zeCcK KworCitkZWYgZ2V0ZGVmYXVsdGJyb3dzZXIoKToKKyAgICBpZiBzeXMucGxhdGZvcm0uc3RhcnRz d2l0aCgnbGludXgnKToKKyAgICAgICAgcmV0dXJuICdtaW5pYnJvd3Nlci1ndGsnCisgICAgcmV0 dXJuICdzYWZhcmknCisKKwogZGVmIHBhcnNlX2FyZ3MoKToKICAgICBwYXJzZXIgPSBhcmdwYXJz ZS5Bcmd1bWVudFBhcnNlcihkZXNjcmlwdGlvbj0nQXV0b21hdGUgdGhlIGJyb3dzZXIgYmFzZWQg cGVyZm9ybWFuY2UgYmVuY2htYXJrcycpCiAgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1vdXRw dXQtZmlsZScsIGRlc3Q9J291dHB1dCcsIGRlZmF1bHQ9Tm9uZSkKICAgICBwYXJzZXIuYWRkX2Fy Z3VtZW50KCctLWJ1aWxkLWRpcmVjdG9yeScsIGRlc3Q9J2J1aWxkRGlyJywgaGVscD0nUGF0aCB0 byB0aGUgYnJvd3NlciBleGVjdXRhYmxlLiBlLmcuIFdlYktpdEJ1aWxkL1JlbGVhc2UvJykKLSAg ICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLXBsYXRmb3JtJywgZGVzdD0ncGxhdGZvcm0nLCBkZWZh dWx0PSdvc3gnLCBjaG9pY2VzPUJyb3dzZXJEcml2ZXJGYWN0b3J5LmF2YWlsYWJsZV9wbGF0Zm9y bXMoKSkKLSAgICAjIEZJWE1FOiBTaG91bGQgd2UgYWRkIGNocm9tZSBhcyBhbiBvcHRpb24/IFdl bGwsIGNocm9tZSB1c2VzIHdlYmtpdCBpbiBpT1MuCi0gICAgcGFyc2VyLmFkZF9hcmd1bWVudCgn LS1icm93c2VyJywgZGVzdD0nYnJvd3NlcicsIGRlZmF1bHQ9J3NhZmFyaScsIGNob2ljZXM9QnJv d3NlckRyaXZlckZhY3RvcnkuYXZhaWxhYmxlX2Jyb3dzZXJzKCkpCisgICAgcGFyc2VyLmFkZF9h cmd1bWVudCgnLS1wbGF0Zm9ybScsIGRlc3Q9J3BsYXRmb3JtJywgZGVmYXVsdD1nZXRwbGF0Zm9y bSgpLCBjaG9pY2VzPUJyb3dzZXJEcml2ZXJGYWN0b3J5LmF2YWlsYWJsZV9wbGF0Zm9ybXMoKSkK KyAgICBwYXJzZXIuYWRkX2FyZ3VtZW50KCctLWJyb3dzZXInLCBkZXN0PSdicm93c2VyJywgZGVm YXVsdD1nZXRkZWZhdWx0YnJvd3NlcigpLCBjaG9pY2VzPUJyb3dzZXJEcml2ZXJGYWN0b3J5LmF2 YWlsYWJsZV9icm93c2VycygpKQogICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tZGVidWcnLCBh Y3Rpb249J3N0b3JlX3RydWUnKQogICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tbG9jYWwtY29w eScsIGRlc3Q9J2xvY2FsQ29weScsIGhlbHA9J1BhdGggdG8gYSBsb2NhbCBjb3B5IG9mIHRoZSBi ZW5jaG1hcmsuIGUuZy4gUGVyZm9ybWFuY2VUZXN0cy9TdW5TcGlkZXIvJykKICAgICBwYXJzZXIu YWRkX2FyZ3VtZW50KCctLWNvdW50JywgZGVzdD0nY291bnRPdmVycmlkZScsIHR5cGU9aW50LCBo ZWxwPSdOdW1iZXIgb2YgdGltZXMgdG8gcnVuIHRoZSBiZW5jaG1hcmsuIGUuZy4gNScpCmRpZmYg LS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvdXRpbHMucHkg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvdXRpbHMucHkKaW5kZXgg ZDYyOGYyYmEyYzM0OTFmZGYzYWFkZWIxZWU2NzljMDVjYjJjMzE5ZC4uNGY5MmEwZmVjNmY2YjQx OTJkYmNiMWIyMDJlNTBkNWUwZGEzMDExZCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9iZW5jaG1hcmtfcnVubmVyL3V0aWxzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvYmVuY2htYXJrX3J1bm5lci91dGlscy5weQpAQCAtMTksNyArMTksOCBAQCBkZWYgaXNfc3Vi Y2xhc3MoY2hpbGQsIHBhcmVudF9uYW1lKToKIAogCiBkZWYgbG9hZF9zdWJjbGFzc2VzKGRpcm5h bWUsIGJhc2VfY2xhc3NfbmFtZSwgYmFzZV9jbGFzc19maWxlLCBsb2FkZXIpOgotICAgIGZpbGVs aXN0ID0gW2Jhc2VfY2xhc3NfZmlsZV0gKyBbZiBmb3IgZiBpbiBvcy5saXN0ZGlyKGRpcm5hbWUp IGlmIGYuZW5kc3dpdGgoJy5weScpIGFuZCBmIG5vdCBpbiBbJ19faW5pdF9fLnB5JywgYmFzZV9j bGFzc19maWxlXV0KKyAgICBmaWxlbGlzdCA9IFtiYXNlX2NsYXNzX2ZpbGVdICsgW2YgZm9yIGYg aW4gb3MubGlzdGRpcihkaXJuYW1lKSBpZiBmLmVuZHN3aXRoKCdfJyArIGJhc2VfY2xhc3NfZmls ZSldCisgICAgZmlsZWxpc3QgKz0gW2YgZm9yIGYgaW4gb3MubGlzdGRpcihkaXJuYW1lKSBpZiBm LmVuZHN3aXRoKCcucHknKSBhbmQgZiBub3QgaW4gWydfX2luaXRfXy5weSddICsgZmlsZWxpc3Rd CiAgICAgZm9yIGZpbGVuYW1lIGluIGZpbGVsaXN0OgogICAgICAgICBtb2R1bGVfbmFtZSA9IG9z LnBhdGguc3BsaXRleHQoZmlsZW5hbWUpWzBdCiAgICAgICAgIG1vZHVsZSA9IGltcC5sb2FkX3Nv dXJjZShtb2R1bGVfbmFtZSwgb3MucGF0aC5qb2luKGRpcm5hbWUsIGZpbGVuYW1lKSkK 295618 2016-11-29 12:15:31 -0800 2016-11-29 14:16:11 -0800 Patch bug-164792-20161129211504.patch text/plain 31800 clopez U3VidmVyc2lvbiBSZXZpc2lvbjogMjA5MDc1CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggY2ZiMGE1NTlmZTU5OGEyMWJkZjc3NTI5YTRiODNkOWNi ZjUyZmZlNC4uNmIyZTE1ZjliMTAwMzkwZGFmMTViMTYzNzFlMTc4NWU5ODIwMGMyOCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDU4 IEBACisyMDE2LTExLTE1ICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJleiAgPGNsb3BlekBpZ2Fs aWEuY29tPgorCisgICAgICAgIFtMaW51eF0gcnVuLWJlbmNobWFyayBzaG91bGQgYmUgYWJsZSB0 byBleGVjdXRlIHRoZSBiZW5jaG1hcmtzIHdpdGggbW9yZSBicm93c2Vycy4KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE2NDc5MgorCisgICAgICAgIFJl dmlld2VkIGJ5IE1pY2hhZWwgQ2F0YW56YXJvLgorCisgICAgICAgIFRoaXMgcmVtb3ZlcyB0aGUg R1RLQnJvd3NlckRyaXZlciAoYW5kIHRoZSBwbGF0Zm9ybSAnZ3RrJykgZnJvbSB0aGUgcnVuLWJl bmNobWFyayBzY3JpcHQsCisgICAgICAgIGFuZCBhZGRzIGEgbmV3IExpbnV4QnJvd3NlckRyaXZl ciB3aXRoIGEgcGxhdGZvcm0gJ2xpbnV4Jy4KKworICAgICAgICBJdCBhZGQgYWxzbyBkcml2ZXJz IGZvciBDaHJvbWUgKENocm9taXVtKSwgRmlyZWZveCwgRXBpcGhhbnkgYW5kIE1pbmlCcm93c2Vy LUdUSyAocHJldmlvdXNseSBNaW5pQnJvd3NlcikuCisKKyAgICAgICAgVGhlIGRldGVjdGlvbiBv ZiB0aGUgcGxhdGZvcm0gaXMgbm93IGRvbmUgYXV0b21hdGljYWxseSwgc28gaXQgaXMgbm90IGxv bmdlciBuZWVkZWQgdG8gcGFzcyBhICItLXBsYXRmb3JtIiBwYXJhbWV0ZXIuCisKKyAgICAgICAg VGhlIHRyYWNraW5nIG9mIHRoZSBicm93c2VyIHByb2Nlc3MgaXMgbm93IG1vcmUgcm9idXN0LCB3 ZSB0cmFjayB0aGUgcGlkIG9mIHRoZSBicm93c2VyIHByb2Nlc3MgYW5kIHdlIG9ubHkgdHJ5IHRv CisgICAgICAgIGtpbGwgdGhlIG9uZXMgdGhhdCB3ZXJlIGV4ZWN1dGVkIGJ5IHRoaXMgc2NyaXB0 LCBpbnN0ZWFkIG9mIGRvaW5nIGEgJ2tpbGxhbGwgJGJyb3dzZXInIChsaWtlIGJlZm9yZSkuCisg ICAgICAgIFdlIGFsc28gY2hlY2sgZm9yIGJyb3dzZXIgcHJvY2VzcyBjaGlsZHMgYW5kIHdlIGtp bGwgdGhlbSBpZiB0aGV5IGFyZSBzdGlsbCBhbGl2ZSBhZnRlciB0aGUgbWFpbiBicm93c2VyIHBy b2Nlc3MgaGFzIGJlZW4ga2lsbGVkLgorICAgICAgICBUaGlzIGRlcGVuZHMgb24gcHN1dGlsLCBz byB0aGlzIHdpbGwgb25seSBiZSBkb25lIGlmIHBzdXRpbCBpcyBpbnN0YWxsZWQuCisKKyAgICAg ICAgKiBCdWlsZFNsYXZlU3VwcG9ydC9idWlsZC53ZWJraXQub3JnLWNvbmZpZy9tYXN0ZXIuY2Zn OgorICAgICAgICAoUnVuQmVuY2htYXJrVGVzdHMuc3RhcnQpOiBUaGUgcGxhdGZvcm0gaXMgbm93 IGF1dG9kZXRlY3RlZCBhbmQgdGhlIE1pbmlCcm93c2VyIGRyaXZlciBpcyByZW5hbWVkIHRvIE1p bmlCcm93c2VyLUdUSy4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5u ZXIvYmVuY2htYXJrX3J1bm5lci5weToKKyAgICAgICAgKEJlbmNobWFya1J1bm5lci5fcnVuX2Jl bmNobWFyayk6IEZpeCBhIGJ1ZyB0aGF0IGNhdXNlZCBjbG9zZV9icm93c2VycyB0byBiZSBjYWxs ZWQgdHdpY2UuIEl0cyBhbHJlYWR5IGNhbGxlZCBpbnNpZGUgQmVuY2htYXJrUnVubmVyLl9ydW5f b25lX3Rlc3QuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jy b3dzZXJfZHJpdmVyL2xpbnV4X2Jyb3dzZXJfZHJpdmVyLnB5OiBBZGRlZC4KKyAgICAgICAgKExp bnV4QnJvd3NlckRyaXZlcik6IEltcGxlbWVudCBiYXNlIGNsYXNzIHRoYXQgaGFzIGFsbCB0aGUg bmVlZGVkIGZ1bmN0aW9uYWxpdHkgZm9yIGRyaXZpbmcgdGhlIGJyb3dzZXJzLgorICAgICAgICAo TGludXhCcm93c2VyRHJpdmVyLl9faW5pdF9fKToKKyAgICAgICAgKExpbnV4QnJvd3NlckRyaXZl ci5wcmVwYXJlX2Vudik6CisgICAgICAgIChMaW51eEJyb3dzZXJEcml2ZXIucmVzdG9yZV9lbnYp OgorICAgICAgICAoTGludXhCcm93c2VyRHJpdmVyLmNsb3NlX2Jyb3dzZXJzKTogTWFkZSB0aGUg ZGVwZW5kZW5jeSBvbiBwc3V0aWwgb3B0aW9uYWwgKGJlY2F1c2UgaXQgd2FzIGxpc3RlZCBhcyBz dWNoIG9uIHRoZSBSRUFETUUgZmlsZSA8VG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtf cnVubmVyL1JFQURNRS5tZD4pCisgICAgICAgIChMaW51eEJyb3dzZXJEcml2ZXIubGF1bmNoX3Vy bCk6CisgICAgICAgIChMaW51eEJyb3dzZXJEcml2ZXIuX2dldF9maXJzdF9leGVjdXRhYmxlX3Bh dGhfZnJvbV9saXN0KToKKyAgICAgICAgKExpbnV4QnJvd3NlckRyaXZlci5fc2NyZWVuX3NpemUp OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2Ry aXZlci9saW51eF9jaHJvbWVfZHJpdmVyLnB5OiBDb3BpZWQgZnJvbSBUb29scy9TY3JpcHRzL3dl YmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX21pbmlicm93c2VyX2Ry aXZlci5weS4KKyAgICAgICAgKExpbnV4Q2hyb21lRHJpdmVyKToKKyAgICAgICAgKExpbnV4Q2hy b21lRHJpdmVyLmxhdW5jaF91cmwpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvYmVuY2ht YXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9lcGlwaGFueV9kcml2ZXIucHk6IFJlbmFt ZWQgZnJvbSBUb29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9k cml2ZXIvZ3RrX2Jyb3dzZXJfZHJpdmVyLnB5LgorICAgICAgICAoRXBpcGhhbnlCcm93c2VyRHJp dmVyKToKKyAgICAgICAgKEVwaXBoYW55QnJvd3NlckRyaXZlci5sYXVuY2hfdXJsKToKKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGlu dXhfZmlyZWZveF9kcml2ZXIucHk6IENvcGllZCBmcm9tIFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv YmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9ndGtfbWluaWJyb3dzZXJfZHJpdmVyLnB5 LgorICAgICAgICAoTGludXhGaXJlZm94RHJpdmVyKToKKyAgICAgICAgKExpbnV4RmlyZWZveERy aXZlci5sYXVuY2hfdXJsKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19y dW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfbWluaWJyb3dzZXJndGtfZHJpdmVyLnB5OiBSZW5h bWVkIGZyb20gVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJf ZHJpdmVyL2d0a19taW5pYnJvd3Nlcl9kcml2ZXIucHkuCisgICAgICAgIChHVEtNaW5pQnJvd3Nl ckRyaXZlcik6CisgICAgICAgIChHVEtNaW5pQnJvd3NlckRyaXZlci5sYXVuY2hfdXJsKToKKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvaHR0cF9zZXJ2ZXJfZHJp dmVyL3NpbXBsZV9odHRwX3NlcnZlcl9kcml2ZXIucHk6CisgICAgICAgIChTaW1wbGVIVFRQU2Vy dmVyRHJpdmVyKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIv cnVuX2JlbmNobWFyay5weToKKyAgICAgICAgKGdldHBsYXRmb3JtKToKKyAgICAgICAgKGdldGRl ZmF1bHRicm93c2VyKToKKyAgICAgICAgKHBhcnNlX2FyZ3MpOgorICAgICAgICAqIFNjcmlwdHMv d2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci91dGlscy5weToKKyAgICAgICAgKGxvYWRfc3ViY2xh c3Nlcyk6IFRoZSBsb2FkaW5nIG9mIHN1YmNsYXNzZXMgd2FzIHN0aWxsIChldmVuIGFmdGVyIHIx OTY5NzkpIHNlbnNpdGl2ZSB0byB0aGUgb3JkZXIgaW4gd2hpY2ggdGhlIG1vZHVsZXMgYXJlIGxv YWRlZC4KKyAgICAgICAgV2UgaGF2ZSB0byBlbnN1cmUgdGhhdCB0aGUgZmlsZXMgY29udGFpbmlu ZyBzdWJjbGFzc2VzIG9mIHRoZSBiYXNlX2NsYXNzX2ZpbGUgYXJlIGxvYWRlZCBhZnRlciB0aGUg YmFzZV9jbGFzc19maWxlLAorICAgICAgICB3ZSBjYW4gZG8gdGhhdCBieSBtYXRjaGluZyBhZ2Fp bnN0IHRoZSBiYXNlX2NsYXNzX2ZpbGUgcGF0dGVybiB3aGVuIHRoZSBsaXN0IGlzIGNyZWF0ZWQu CisKIDIwMTYtMTEtMjkgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5jb20+CiAK ICAgICAgICAgaW50ZXJzZWN0aW9uLW9ic2VydmVyLWVudHJ5LWludGVyZmFjZS5odG1sIHRlc3Qg ZmFpbHMgb24gdGhlIGJvdHMKZGlmZiAtLWdpdCBhL1Rvb2xzL0J1aWxkU2xhdmVTdXBwb3J0L2J1 aWxkLndlYmtpdC5vcmctY29uZmlnL21hc3Rlci5jZmcgYi9Ub29scy9CdWlsZFNsYXZlU3VwcG9y dC9idWlsZC53ZWJraXQub3JnLWNvbmZpZy9tYXN0ZXIuY2ZnCmluZGV4IGU0NDI2MTM3YzY1NmM3 YzY4ZTMwOTMxM2M2NDk1OWYwNjcxMzU3NjYuLjYwMDMxOGU1ZGZkOWNjZDA1MmVkN2VlNGY2NjEx ZjEwZDFlZTE5NzkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0J1aWxkU2xhdmVTdXBwb3J0L2J1aWxkLndl YmtpdC5vcmctY29uZmlnL21hc3Rlci5jZmcKKysrIGIvVG9vbHMvQnVpbGRTbGF2ZVN1cHBvcnQv YnVpbGQud2Via2l0Lm9yZy1jb25maWcvbWFzdGVyLmNmZwpAQCAtNzAxLDcgKzcwMSw3IEBAIGNs YXNzIFJ1bkJlbmNobWFya1Rlc3RzKHNoZWxsLlRlc3QpOgogICAgIGRlZiBzdGFydChzZWxmKToK ICAgICAgICAgcGxhdGZvcm0gPSBzZWxmLmdldFByb3BlcnR5KCJwbGF0Zm9ybSIpCiAgICAgICAg IGlmIHBsYXRmb3JtID09ICJndGsiOgotICAgICAgICAgICAgc2VsZi5jb21tYW5kICs9IFsiLS1w bGF0Zm9ybSIsICJndGsiLCAiLS1icm93c2VyIiwgIm1pbmlicm93c2VyIl0KKyAgICAgICAgICAg IHNlbGYuY29tbWFuZCArPSBbIi0tYnJvd3NlciIsICJtaW5pYnJvd3Nlci1ndGsiXQogICAgICAg ICBzZWxmLnNldENvbW1hbmQoc2VsZi5jb21tYW5kKQogICAgICAgICByZXR1cm4gc2hlbGwuVGVz dC5zdGFydChzZWxmKQogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNo bWFya19ydW5uZXIvYmVuY2htYXJrX3J1bm5lci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv YmVuY2htYXJrX3J1bm5lci9iZW5jaG1hcmtfcnVubmVyLnB5CmluZGV4IDI1YjNiYTQ0NjQzZTQ3 OTljZTk0NjI3M2Y5ZDlhNWYyYWJmMzAzN2IuLjIzNzM4OWMyNGRjMTM5ZjZjNjA2ZDFlZGJiMmNm NzJjNWM1OTYyMWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJr X3J1bm5lci9iZW5jaG1hcmtfcnVubmVyLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv YmVuY2htYXJrX3J1bm5lci9iZW5jaG1hcmtfcnVubmVyLnB5CkBAIC0xMDcsNyArMTA3LDYgQEAg Y2xhc3MgQmVuY2htYXJrUnVubmVyKG9iamVjdCk6CiAKICAgICAgICAgICAgIGZpbmFsbHk6CiAg ICAgICAgICAgICAgICAgc2VsZi5fYnJvd3Nlcl9kcml2ZXIucmVzdG9yZV9lbnYoKQotICAgICAg ICAgICAgICAgIHNlbGYuX2Jyb3dzZXJfZHJpdmVyLmNsb3NlX2Jyb3dzZXJzKCkKIAogICAgICAg ICAgICAgX2xvZy5pbmZvKCdFbmQgdGhlIGl0ZXJhdGlvbiB7Y3VycmVudF9pdGVyYXRpb259IG9m IHtpdGVyYXRpb25zfSBmb3IgY3VycmVudCBiZW5jaG1hcmsnLmZvcm1hdChjdXJyZW50X2l0ZXJh dGlvbj1pdGVyYXRpb24sIGl0ZXJhdGlvbnM9Y291bnQpKQogCmRpZmYgLS1naXQgYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX2Jyb3dz ZXJfZHJpdmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jy b3dzZXJfZHJpdmVyL2d0a19icm93c2VyX2RyaXZlci5weQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMGIwOGVhNmE4ZDEzYWY5MTRiYjBhMDgxNjYzYzg2ZTE2YzlkZDk2My4uMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAotLS0gYS9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvZ3RrX2Jyb3dzZXJfZHJpdmVy LnB5CisrKyAvZGV2L251bGwKQEAgLTEsNjYgKzAsMCBAQAotIyBDb3B5cmlnaHQgKEMpIDIwMTYg SWdhbGlhIFMuTC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMKLSMgUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0jIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucyBhcmUKLSMgbWV0OgotIwotIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotIyBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCi0jCi0jICAgICAqIFJl ZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKLSMg Y29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lcgotIyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCi0jIGRpc3RyaWJ1dGlvbi4KLSMKLSMgVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwot IyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVAotIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKLSMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKLSMgT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws Ci0jIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKLSMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCi0jIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQotIyBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU Ci0jIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQotIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotCi1pbXBvcnQgbG9nZ2luZwotaW1wb3J0 IHN1YnByb2Nlc3MKLWZyb20gYnJvd3Nlcl9kcml2ZXIgaW1wb3J0IEJyb3dzZXJEcml2ZXIKLQot X2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9fKQotCi0KLWNsYXNzIEdUS0Jyb3dzZXJE cml2ZXIoQnJvd3NlckRyaXZlcik6Ci0gICAgcHJvY2Vzc19uYW1lID0gTm9uZQotICAgIHBsYXRm b3JtID0gJ2d0aycKLQotICAgIGRlZiBwcmVwYXJlX2VudihzZWxmLCBkZXZpY2VfaWQpOgotICAg ICAgICBzZWxmLmNsb3NlX2Jyb3dzZXJzKCkKLQotICAgIGRlZiByZXN0b3JlX2VudihzZWxmKToK LSAgICAgICAgcGFzcwotCi0gICAgZGVmIGNsb3NlX2Jyb3dzZXJzKHNlbGYpOgotICAgICAgICBz ZWxmLl90ZXJtaW5hdGVfcHJvY2Vzc2VzKHNlbGYucHJvY2Vzc19uYW1lKQotCi0gICAgQGNsYXNz bWV0aG9kCi0gICAgZGVmIF9sYXVuY2hfcHJvY2VzcyhjbHMsIGFyZ3MsIGVudj1Ob25lKToKLSAg ICAgICAgcHJvY2VzcyA9IHN1YnByb2Nlc3MuUG9wZW4oYXJncykKLSAgICAgICAgcmV0dXJuIHBy b2Nlc3MKLQotICAgIEBjbGFzc21ldGhvZAotICAgIGRlZiBfdGVybWluYXRlX3Byb2Nlc3Nlcyhj bHMsIHByb2Nlc3NfbmFtZSk6Ci0gICAgICAgIF9sb2cuaW5mbygnQ2xvc2luZyBhbGwgcHJvY2Vz c2VzIHdpdGggbmFtZSAlcycgJSBwcm9jZXNzX25hbWUpCi0gICAgICAgIHN1YnByb2Nlc3MuY2Fs bChbJy91c3IvYmluL2tpbGxhbGwnLCBwcm9jZXNzX25hbWVdKQotCi0gICAgQGNsYXNzbWV0aG9k Ci0gICAgZGVmIF9zY3JlZW5fc2l6ZShjbHMpOgotICAgICAgICAjIGxvYWRfc3ViY2xhc3Nlcygp IGZyb20gX19pbml0X18ucHkgd2lsbCBsb2FkIHRoaXMgZmlsZSB0bwotICAgICAgICAjIGNoZWNr IHRoZSBwbGF0Zm9ybSBkZWZpbmVkLiBEbyBoZXJlIGEgbGF6eSBpbXBvcnQgaW5zdGVhZCBvZgot ICAgICAgICAjIHRyeWluZyB0byBpbXBvcnQgdGhlIEd0ayBtb2R1bGUgb24gdGhlIGdsb2JhbCBz Y29wZSBvZiB0aGlzCi0gICAgICAgICMgZmlsZSB0byBhdm9pZCBJbXBvcnRFcnJvciBlcnJvcnMg b24gb3RoZXIgcGxhdGZvcm1zLgotICAgICAgICAjIFB5dGhvbiBpbXBvcnRzIGFyZSBjYWNoZWQg YW5kIG9ubHkgcnVuIG9uY2UsIHNvIHRoaXMgc2hvdWxkIGJlIG9rLgotICAgICAgICBmcm9tIGdp LnJlcG9zaXRvcnkgaW1wb3J0IEd0awotICAgICAgICBzY3JlZW4gPSBHdGsuV2luZG93KCkuZ2V0 X3NjcmVlbigpCi0gICAgICAgIHJldHVybiBzY3JlZW4uZ2V0X21vbml0b3JfZ2VvbWV0cnkoc2Ny ZWVuLmdldF9wcmltYXJ5X21vbml0b3IoKSkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9ndGtfbWluaWJyb3dzZXJfZHJp dmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJf ZHJpdmVyL2d0a19taW5pYnJvd3Nlcl9kcml2ZXIucHkKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDk4ZTZjOWUyMzU2ZTJjOTUxMTc2NTM0NjhhZjUxNjYxYjI5MzhlMDkuLjAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2d0a19taW5pYnJvd3Nlcl9kcml2 ZXIucHkKKysrIC9kZXYvbnVsbApAQCAtMSw1MyArMCwwIEBACi0jIENvcHlyaWdodCAoQykgMjAx NiBJZ2FsaWEgUy5MLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIwotIyBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKLSMgbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zIGFyZQotIyBtZXQ6Ci0jCi0jICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Ci0jIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSMKLSMgICAgICog UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQot IyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyCi0jIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKLSMgZGlzdHJpYnV0aW9uLgotIwotIyBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT Ci0jICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UCi0jIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgotIyBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAotIyBPV05FUiBPUiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwKLSMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAotIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKLSMgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCi0jIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKLSMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFCi0jIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCi0KLWltcG9ydCBsb2dnaW5nCi1pbXBv cnQgc3lzCi1mcm9tIGd0a19icm93c2VyX2RyaXZlciBpbXBvcnQgR1RLQnJvd3NlckRyaXZlcgot Ci1fbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCi0KLQotY2xhc3MgR1RLTWluaUJy b3dzZXJEcml2ZXIoR1RLQnJvd3NlckRyaXZlcik6Ci0gICAgcHJvY2Vzc19uYW1lID0gJ01pbmlC cm93c2VyJwotICAgIGJyb3dzZXJfbmFtZSA9ICdtaW5pYnJvd3NlcicKLQotICAgIGRlZiBwcmVw YXJlX2VudihzZWxmLCBkZXZpY2VfaWQpOgotICAgICAgICBzZWxmLl9taW5pYnJvd3Nlcl9wcm9j ZXNzID0gTm9uZQotICAgICAgICBzdXBlcihHVEtNaW5pQnJvd3NlckRyaXZlciwgc2VsZikucHJl cGFyZV9lbnYoZGV2aWNlX2lkKQotCi0gICAgZGVmIGxhdW5jaF91cmwoc2VsZiwgdXJsLCBvcHRp b25zLCBicm93c2VyX2J1aWxkX3BhdGgpOgotICAgICAgICBhcmdzID0gWydUb29scy9TY3JpcHRz L3J1bi1taW5pYnJvd3NlcicsICctLWd0ayddCi0gICAgICAgIGFyZ3MuYXBwZW5kKCItLWdlb21l dHJ5PSVzeCVzIiAlIChzZWxmLl9zY3JlZW5fc2l6ZSgpLndpZHRoLCBzZWxmLl9zY3JlZW5fc2l6 ZSgpLmhlaWdodCkpCi0gICAgICAgIGFyZ3MuYXBwZW5kKHVybCkKLSAgICAgICAgX2xvZy5pbmZv KCdMYXVuY2hpbmcgTWluaWJyb3dzZXIgd2l0aCB1cmw6ICVzJyAlIHVybCkKLSAgICAgICAgc2Vs Zi5fbWluaWJyb3dzZXJfcHJvY2VzcyA9IEdUS0Jyb3dzZXJEcml2ZXIuX2xhdW5jaF9wcm9jZXNz KGFyZ3MpCi0KLSAgICBkZWYgY2xvc2VfYnJvd3NlcnMoc2VsZik6Ci0gICAgICAgIHN1cGVyKEdU S01pbmlCcm93c2VyRHJpdmVyLCBzZWxmKS5jbG9zZV9icm93c2VycygpCi0gICAgICAgIGlmIHNl bGYuX21pbmlicm93c2VyX3Byb2Nlc3MgYW5kIHNlbGYuX21pbmlicm93c2VyX3Byb2Nlc3MucmV0 dXJuY29kZToKLSAgICAgICAgICAgIF9sb2cuZXJyb3IoJ01pbmlCcm93c2VyIGNyYXNoZWQgd2l0 aCBleGl0Y29kZSAlZCcgJSBzZWxmLl9taW5pYnJvd3Nlcl9wcm9jZXNzLnJldHVybmNvZGUpCi0g ICAgICAgICAgICBzeXMuZXhpdCgxKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2xpbnV4X2Jyb3dzZXJfZHJpdmVyLnB5 IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVy L2xpbnV4X2Jyb3dzZXJfZHJpdmVyLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjM4NGU1YTZhOTc5NDE2YTNlNDI3 ZGEzNzFkMDg5MDI2YjA1YmFiMzcKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfYnJvd3Nlcl9kcml2 ZXIucHkKQEAgLTAsMCArMSwxMjUgQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisj IG1ldDoKKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNvcHlyaWdodCBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZQorIyBkaXN0cmlidXRpb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyMgIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorIyBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U CisjIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKworaW1wb3J0IG9zCitpbXBvcnQgc3lzCitpbXBvcnQgdGVt cGZpbGUKK2ltcG9ydCBsb2dnaW5nCitpbXBvcnQgc3VicHJvY2VzcwordHJ5OgorICAgIGltcG9y dCBwc3V0aWwKK2V4Y2VwdCBJbXBvcnRFcnJvcjoKKyAgICBwYXNzCitmcm9tIHdlYmtpdHB5LmJl bmNobWFya19ydW5uZXIudXRpbHMgaW1wb3J0IGZvcmNlX3JlbW92ZQorZnJvbSBicm93c2VyX2Ry aXZlciBpbXBvcnQgQnJvd3NlckRyaXZlcgorCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihf X25hbWVfXykKKworCitjbGFzcyBMaW51eEJyb3dzZXJEcml2ZXIoQnJvd3NlckRyaXZlcik6Cisg ICAgYnJvd3Nlcl9uYW1lID0gTm9uZQorICAgIHByb2Nlc3Nfc2VhcmNoX2xpc3QgPSBbXQorICAg IHBsYXRmb3JtID0gJ2xpbnV4JworCisgICAgZGVmIF9faW5pdF9fKHNlbGYpOgorICAgICAgICBz ZWxmLnByb2Nlc3NfbmFtZSA9IHNlbGYuX2dldF9maXJzdF9leGVjdXRhYmxlX3BhdGhfZnJvbV9s aXN0KHNlbGYucHJvY2Vzc19zZWFyY2hfbGlzdCkKKyAgICAgICAgaWYgc2VsZi5wcm9jZXNzX25h bWUgaXMgTm9uZToKKyAgICAgICAgICAgIHJhaXNlIFZhbHVlRXJyb3IoJ0NhbnQgZmluZCBleGVj dXRhYmxlIGZvciBicm93c2VyIHticm93c2VyX25hbWV9LiBTZWFyY2hlZCBsaXN0OiB7YnJvd3Nl cl9wcm9jZXNzX2xpc3R9Jy5mb3JtYXQoCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBi cm93c2VyX25hbWU9c2VsZi5icm93c2VyX25hbWUsIGJyb3dzZXJfcHJvY2Vzc19saXN0PXNlbGYu cHJvY2Vzc19zZWFyY2hfbGlzdCkpCisKKyAgICBkZWYgcHJlcGFyZV9lbnYoc2VsZiwgZGV2aWNl X2lkKToKKyAgICAgICAgc2VsZi5fYnJvd3Nlcl9wcm9jZXNzID0gTm9uZQorICAgICAgICBzZWxm Ll9icm93c2VyX2FyZ3VtZW50cyA9IE5vbmUKKyAgICAgICAgc2VsZi5fdGVtcF9wcm9maWxlZGly ID0gdGVtcGZpbGUubWtkdGVtcCgpCisgICAgICAgIHNlbGYuX3Rlc3RfZW52aXJvbiA9IGRpY3Qo b3MuZW52aXJvbikKKyAgICAgICAgc2VsZi5fdGVzdF9lbnZpcm9uWydIT01FJ10gPSBzZWxmLl90 ZW1wX3Byb2ZpbGVkaXIKKworICAgIGRlZiByZXN0b3JlX2VudihzZWxmKToKKyAgICAgICAgZm9y Y2VfcmVtb3ZlKHNlbGYuX3RlbXBfcHJvZmlsZWRpcikKKworICAgIGRlZiBjbG9zZV9icm93c2Vy cyhzZWxmKToKKyAgICAgICAgaWYgc2VsZi5fYnJvd3Nlcl9wcm9jZXNzOgorICAgICAgICAgICAg aWYgc2VsZi5fYnJvd3Nlcl9wcm9jZXNzLnBvbGwoKSBpcyBOb25lOiAgIyBzdGlsbCBydW5uaW5n CisgICAgICAgICAgICAgICAgaWYgJ3BzdXRpbCcgaW4gc3lzLm1vZHVsZXM6CisgICAgICAgICAg ICAgICAgICAgIG1haW5fYnJvd3Nlcl9wcm9jZXNzID0gcHN1dGlsLlByb2Nlc3Moc2VsZi5fYnJv d3Nlcl9wcm9jZXNzLnBpZCkKKyAgICAgICAgICAgICAgICAgICAgYnJvd3Nlcl9jaGlsZHJlbiA9 IG1haW5fYnJvd3Nlcl9wcm9jZXNzLmNoaWxkcmVuKHJlY3Vyc2l2ZT1UcnVlKQorICAgICAgICAg ICAgICAgICAgICBfbG9nLmluZm8oJ0tpbGxpbmcgYnJvd3NlciB7YnJvd3Nlcl9uYW1lfSB3aXRo IHBpZCB7YnJvd3Nlcl9waWR9IGFuZCBjbWQ6IHticm93c2VyX2NtZH0nLmZvcm1hdCgKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBicm93c2VyX25hbWU9c2VsZi5icm93c2VyX25hbWUs IGJyb3dzZXJfcGlkPXNlbGYuX2Jyb3dzZXJfcHJvY2Vzcy5waWQsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgYnJvd3Nlcl9jbWQ9JyAnLmpvaW4obWFpbl9icm93c2VyX3Byb2Nlc3Mu Y21kbGluZSgpKS5zdHJpcCgpIG9yIG1haW5fYnJvd3Nlcl9wcm9jZXNzLm5hbWUoKSkpCisgICAg ICAgICAgICAgICAgICAgIG1haW5fYnJvd3Nlcl9wcm9jZXNzLmtpbGwoKQorICAgICAgICAgICAg ICAgICAgICBmb3IgYnJvd3Nlcl9jaGlsZCBpbiBicm93c2VyX2NoaWxkcmVuOgorICAgICAgICAg ICAgICAgICAgICAgICAgaWYgYnJvd3Nlcl9jaGlsZC5pc19ydW5uaW5nKCk6CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgX2xvZy5pbmZvKCdLaWxsaW5nIHN0aWxsIGFsaXZlIHticm93c2Vy X25hbWV9IGNoaWxkIHdpdGggcGlkIHticm93c2VyX3BpZH0gYW5kIGNtZDoge2Jyb3dzZXJfY21k fScuZm9ybWF0KAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJvd3Nl cl9uYW1lPXNlbGYuYnJvd3Nlcl9uYW1lLCBicm93c2VyX3BpZD1icm93c2VyX2NoaWxkLnBpZCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyb3dzZXJfY21kPScgJy5q b2luKGJyb3dzZXJfY2hpbGQuY21kbGluZSgpKS5zdHJpcCgpIG9yIGJyb3dzZXJfY2hpbGQubmFt ZSgpKSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBicm93c2VyX2NoaWxkLmtpbGwoKQor ICAgICAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgICAgIF9sb2cuaW5mbygnS2ls bGluZyBicm93c2VyIHticm93c2VyX25hbWV9IHdpdGggcGlkIHticm93c2VyX3BpZH0nLmZvcm1h dCgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBicm93c2VyX25hbWU9c2VsZi5icm93 c2VyX25hbWUsIGJyb3dzZXJfcGlkPXNlbGYuX2Jyb3dzZXJfcHJvY2Vzcy5waWQpKQorICAgICAg ICAgICAgICAgICAgICBzZWxmLl9icm93c2VyX3Byb2Nlc3Mua2lsbCgpCisgICAgICAgICAgICAg ICAgICAgIF9sb2cud2FybmluZygncHl0aG9uIHBzdXRpbCBub3QgZm91bmQsIGNhbnQgY2hlY2sg Zm9yICcKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdzdGlsbC1hbGl2ZSBicm93 c2VyIGNoaWxkcyB0byBraWxsLicpCisgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAg IF9sb2cuZXJyb3IoJ0Jyb3dzZXIge2Jyb3dzZXJfbmFtZX0gd2l0aCBwaWQge2Jyb3dzZXJfcGlk fSBlbmRlZCBwcmVtYXR1cmVseSB3aXRoIHJldHVybiBjb2RlIHticm93c2VyX3JldGNvZGV9Licu Zm9ybWF0KAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyb3dzZXJfbmFtZT1zZWxmLmJy b3dzZXJfbmFtZSwgYnJvd3Nlcl9waWQ9c2VsZi5fYnJvd3Nlcl9wcm9jZXNzLnBpZCwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICBicm93c2VyX3JldGNvZGU9c2VsZi5fYnJvd3Nlcl9wcm9j ZXNzLnJldHVybmNvZGUpKQorCisgICAgZGVmIGxhdW5jaF91cmwoc2VsZiwgdXJsLCBvcHRpb25z LCBicm93c2VyX2J1aWxkX3BhdGgpOgorICAgICAgICBpZiBub3Qgc2VsZi5fYnJvd3Nlcl9hcmd1 bWVudHM6CisgICAgICAgICAgICBzZWxmLl9icm93c2VyX2FyZ3VtZW50cyA9IFt1cmxdCisgICAg ICAgIGV4ZWNfYXJncyA9IFtzZWxmLnByb2Nlc3NfbmFtZV0gKyBzZWxmLl9icm93c2VyX2FyZ3Vt ZW50cworICAgICAgICBfbG9nLmluZm8oJ0V4ZWN1dGluZzoge2Jyb3dzZXJfY21kbGluZX0nLmZv cm1hdChicm93c2VyX2NtZGxpbmU9JyAnLmpvaW4oZXhlY19hcmdzKSkpCisgICAgICAgIHNlbGYu X2Jyb3dzZXJfcHJvY2VzcyA9IHN1YnByb2Nlc3MuUG9wZW4oZXhlY19hcmdzLCBlbnY9c2VsZi5f dGVzdF9lbnZpcm9uLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0ZG91dD1zdWJwcm9jZXNzLlBJUEUsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RkZXJyPXN1YnByb2Nlc3MuU1RET1VUKQorCisgICAg ZGVmIF9nZXRfZmlyc3RfZXhlY3V0YWJsZV9wYXRoX2Zyb21fbGlzdChzZWxmLCBzZWFyY2hsaXN0 KToKKyAgICAgICAgc2VhcmNocGF0aCA9IFtvcy5wYXRoLmN1cmRpcl0gKyBvcy5lbnZpcm9uWydQ QVRIJ10uc3BsaXQob3MucGF0aHNlcCkKKyAgICAgICAgZm9yIHByb2dyYW0gaW4gc2VhcmNobGlz dDoKKyAgICAgICAgICAgIGZvciBwYXRoIGluIHNlYXJjaHBhdGg6CisgICAgICAgICAgICAgICAg ZnVsbHBhdGggPSBvcy5wYXRoLmFic3BhdGgob3MucGF0aC5qb2luKHBhdGgsIHByb2dyYW0pKQor ICAgICAgICAgICAgICAgIGlmICBvcy5wYXRoLmlzZmlsZShmdWxscGF0aCkgYW5kIG9zLmFjY2Vz cyhmdWxscGF0aCwgb3MuWF9PSyk6CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmdWxscGF0 aAorICAgICAgICByZXR1cm4gTm9uZQorCisgICAgZGVmIF9zY3JlZW5fc2l6ZShzZWxmKToKKyAg ICAgICAgIyBsb2FkX3N1YmNsYXNzZXMoKSBmcm9tIF9faW5pdF9fLnB5IHdpbGwgbG9hZCB0aGlz IGZpbGUgdG8KKyAgICAgICAgIyBjaGVjayB0aGUgcGxhdGZvcm0gZGVmaW5lZC4gRG8gaGVyZSBh IGxhenkgaW1wb3J0IGluc3RlYWQgb2YKKyAgICAgICAgIyB0cnlpbmcgdG8gaW1wb3J0IHRoZSBH dGsgbW9kdWxlIG9uIHRoZSBnbG9iYWwgc2NvcGUgb2YgdGhpcworICAgICAgICAjIGZpbGUgdG8g YXZvaWQgSW1wb3J0RXJyb3IgZXJyb3JzIG9uIG90aGVyIHBsYXRmb3Jtcy4KKyAgICAgICAgIyBQ eXRob24gaW1wb3J0cyBhcmUgY2FjaGVkIGFuZCBvbmx5IHJ1biBvbmNlLCBzbyB0aGlzIHNob3Vs ZCBiZSBvay4KKyAgICAgICAgaW1wb3J0IGdpCisgICAgICAgIGdpLnJlcXVpcmVfdmVyc2lvbign R3RrJywgJzMuMCcpCisgICAgICAgIGdpLnJlcXVpcmVfdmVyc2lvbignR2RrJywgJzMuMCcpCisg ICAgICAgIGZyb20gZ2kucmVwb3NpdG9yeSBpbXBvcnQgR3RrLCBHZGsKKyAgICAgICAgaWYgR3Rr LmdldF9tYWpvcl92ZXJzaW9uKCkgPT0gMyBhbmQgR3RrLmdldF9taW5vcl92ZXJzaW9uKCkgPCAy MjoKKyAgICAgICAgICAgIHNjcmVlbiA9IEd0ay5XaW5kb3coKS5nZXRfc2NyZWVuKCkKKyAgICAg ICAgICAgIHJldHVybiBzY3JlZW4uZ2V0X21vbml0b3JfZ2VvbWV0cnkoc2NyZWVuLmdldF9wcmlt YXJ5X21vbml0b3IoKSkKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIGRpc3BsYXkgPSBHZGsu RGlzcGxheS5nZXRfZGVmYXVsdCgpCisgICAgICAgICAgICBtb25pdG9yID0gZGlzcGxheS5nZXRf cHJpbWFyeV9tb25pdG9yKCkKKyAgICAgICAgICAgIHJldHVybiBtb25pdG9yLmdldF9nZW9tZXRy eSgpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIv YnJvd3Nlcl9kcml2ZXIvbGludXhfY2hyb21lX2RyaXZlci5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9jaHJvbWVfZHJpdmVy LnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjcxYzE3MjcwMmFkNTFmYzQ3NGVmMGM1N2YxMTRhZjJjNjFlYzlkM2UK LS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5u ZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfY2hyb21lX2RyaXZlci5weQpAQCAtMCwwICsxLDM3IEBA CisjIENvcHlyaWdodCAoQykgMjAxNiBJZ2FsaWEgUy5MLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor IworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorIyBtZXQ6CisjCisjICAgICAqIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisjIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZQorIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisjIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyMgZGlzdHJpYnV0 aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9M REVSUyBBTkQgQ09OVFJJQlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP UFlSSUdIVAorIyBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisjIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisK K2Zyb20gbGludXhfYnJvd3Nlcl9kcml2ZXIgaW1wb3J0IExpbnV4QnJvd3NlckRyaXZlcgorCisK K2NsYXNzIExpbnV4Q2hyb21lRHJpdmVyKExpbnV4QnJvd3NlckRyaXZlcik6CisgICAgYnJvd3Nl cl9uYW1lID0gJ2Nocm9tZScKKyAgICBwcm9jZXNzX3NlYXJjaF9saXN0ID0gWydjaHJvbWl1bScs ICdjaHJvbWl1bS1icm93c2VyJywgJ2Nocm9tZSddCisKKyAgICBkZWYgbGF1bmNoX3VybChzZWxm LCB1cmwsIG9wdGlvbnMsIGJyb3dzZXJfYnVpbGRfcGF0aCk6CisgICAgICAgIHNlbGYuX2Jyb3dz ZXJfYXJndW1lbnRzID0gWyctLXRlbXAtcHJvZmlsZScsICctLXN0YXJ0LW1heGltaXplZCcsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICctLWhvbWVwYWdlJywgdXJsXQorICAg ICAgICBzdXBlcihMaW51eENocm9tZURyaXZlciwgc2VsZikubGF1bmNoX3VybCh1cmwsIG9wdGlv bnMsIGJyb3dzZXJfYnVpbGRfcGF0aCkKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvYmVuY2htYXJrX3J1bm5lci9icm93c2VyX2RyaXZlci9saW51eF9lcGlwaGFueV9kcml2ZXIu cHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2 ZXIvbGludXhfZXBpcGhhbnlfZHJpdmVyLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNiOTY1MjYxMjE2MjAwN2Qw ZDgyMjRjODQzZWVkOTVmYjc3Y2Y2OGUKLS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfZXBpcGhhbnlf ZHJpdmVyLnB5CkBAIC0wLDAgKzEsMzggQEAKKyMgQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBT LkwuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJl CisjIG1ldDoKKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIworIyAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNvcHlyaWdo dCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIKKyMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZQorIyBkaXN0cmlidXRpb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyMgIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorIyBTUEVD SUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQg Tk9UCisjIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworZnJvbSBsaW51eF9icm93c2VyX2RyaXZlciBpbXBv cnQgTGludXhCcm93c2VyRHJpdmVyCisKKworY2xhc3MgRXBpcGhhbnlCcm93c2VyRHJpdmVyKExp bnV4QnJvd3NlckRyaXZlcik6CisgICAgYnJvd3Nlcl9uYW1lID0gJ2VwaXBoYW55JworICAgIHBy b2Nlc3Nfc2VhcmNoX2xpc3QgPSBbJ2VwaXBoYW55JywgJ2VwaXBoYW55LWJyb3dzZXInXQorCisg ICAgZGVmIGxhdW5jaF91cmwoc2VsZiwgdXJsLCBvcHRpb25zLCBicm93c2VyX2J1aWxkX3BhdGgp OgorICAgICAgICBzZWxmLl9icm93c2VyX2FyZ3VtZW50cyA9IFsnLS1uZXctd2luZG93JywgJy1w JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJy0tcHJvZmlsZT17cHJvZmls ZX0nLmZvcm1hdChwcm9maWxlPXNlbGYuX3RlbXBfcHJvZmlsZWRpciksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHVybF0KKyAgICAgICAgc3VwZXIoRXBpcGhhbnlCcm93c2Vy RHJpdmVyLCBzZWxmKS5sYXVuY2hfdXJsKHVybCwgb3B0aW9ucywgYnJvd3Nlcl9idWlsZF9wYXRo KQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jy b3dzZXJfZHJpdmVyL2xpbnV4X2ZpcmVmb3hfZHJpdmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9iZW5jaG1hcmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2xpbnV4X2ZpcmVmb3hfZHJpdmVy LnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjNjNWViNDlkOGQyOGE5MDc1NDYyYTA4MjNmZTcwODM4ZDJmNTA1ZDQK LS0tIC9kZXYvbnVsbAorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5u ZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhfZmlyZWZveF9kcml2ZXIucHkKQEAgLTAsMCArMSwzOSBA QAorIyBDb3B5cmlnaHQgKEMpIDIwMTYgSWdhbGlhIFMuTC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3RyaWJ1 dGlvbi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhP TERFUlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQ QVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBD T1BZUklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor Citmcm9tIGxpbnV4X2Jyb3dzZXJfZHJpdmVyIGltcG9ydCBMaW51eEJyb3dzZXJEcml2ZXIKKwor CitjbGFzcyBMaW51eEZpcmVmb3hEcml2ZXIoTGludXhCcm93c2VyRHJpdmVyKToKKyAgICBicm93 c2VyX25hbWUgPSAnZmlyZWZveCcKKyAgICBwcm9jZXNzX3NlYXJjaF9saXN0ID0gWydmaXJlZm94 J10KKworICAgIGRlZiBsYXVuY2hfdXJsKHNlbGYsIHVybCwgb3B0aW9ucywgYnJvd3Nlcl9idWls ZF9wYXRoKToKKyAgICAgICAgc2VsZi5fYnJvd3Nlcl9hcmd1bWVudHMgPSBbJy1uZXctaW5zdGFu Y2UnLCAnLXByb2ZpbGUnLCBzZWxmLl90ZW1wX3Byb2ZpbGVkaXIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICctd2lkdGgnLCBzdHIoc2VsZi5fc2NyZWVuX3NpemUoKS53aWR0 aCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICctaGVpZ2h0Jywgc3RyKHNl bGYuX3NjcmVlbl9zaXplKCkuaGVpZ2h0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdXJsXQorICAgICAgICBzdXBlcihMaW51eEZpcmVmb3hEcml2ZXIsIHNlbGYpLmxhdW5j aF91cmwodXJsLCBvcHRpb25zLCBicm93c2VyX2J1aWxkX3BhdGgpCmRpZmYgLS1naXQgYS9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvYnJvd3Nlcl9kcml2ZXIvbGludXhf bWluaWJyb3dzZXJndGtfZHJpdmVyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1h cmtfcnVubmVyL2Jyb3dzZXJfZHJpdmVyL2xpbnV4X21pbmlicm93c2VyZ3RrX2RyaXZlci5weQpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lZGM5N2M1ZDA4OGU3MGI1ZGM2OTEwOWU4ZTM3ZjhmZTA2OWY2MjRhCi0tLSAv ZGV2L251bGwKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL2Jy b3dzZXJfZHJpdmVyL2xpbnV4X21pbmlicm93c2VyZ3RrX2RyaXZlci5weQpAQCAtMCwwICsxLDQw IEBACisjIENvcHlyaWdodCAoQykgMjAxNiBJZ2FsaWEgUy5MLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorIworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorIyBtZXQ6CisjCisjICAgICAqIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisjIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisjIGluIHRoZSBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyMgZGlzdHJp YnV0aW9uLgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQg SE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBB IFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhF IENPUFlSSUdIVAorIyBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMg REFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZCisjIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisKK2Zyb20gbGludXhfYnJvd3Nlcl9kcml2ZXIgaW1wb3J0IExpbnV4QnJvd3NlckRyaXZlcgor CisKK2NsYXNzIEdUS01pbmlCcm93c2VyRHJpdmVyKExpbnV4QnJvd3NlckRyaXZlcik6CisgICAg YnJvd3Nlcl9uYW1lID0gJ21pbmlicm93c2VyLWd0aycKKyAgICBwcm9jZXNzX3NlYXJjaF9saXN0 ID0gWydUb29scy9TY3JpcHRzL3J1bi1taW5pYnJvd3NlcicsICdNaW5pQnJvd3NlciddCisKKyAg ICBkZWYgbGF1bmNoX3VybChzZWxmLCB1cmwsIG9wdGlvbnMsIGJyb3dzZXJfYnVpbGRfcGF0aCk6 CisgICAgICAgIHNlbGYuX2Jyb3dzZXJfYXJndW1lbnRzID0gW10KKyAgICAgICAgaWYgc2VsZi5w cm9jZXNzX25hbWUuZW5kc3dpdGgoJ3J1bi1taW5pYnJvd3NlcicpOgorICAgICAgICAgICAgc2Vs Zi5fYnJvd3Nlcl9hcmd1bWVudHMuYXBwZW5kKCctLWd0aycpCisgICAgICAgIHNlbGYuX2Jyb3dz ZXJfYXJndW1lbnRzLmFwcGVuZCgnLS1nZW9tZXRyeT17d314e2h9Jy5mb3JtYXQodz1zZWxmLl9z Y3JlZW5fc2l6ZSgpLndpZHRoLCBoPXNlbGYuX3NjcmVlbl9zaXplKCkuaGVpZ2h0KSkKKyAgICAg ICAgc2VsZi5fYnJvd3Nlcl9hcmd1bWVudHMuYXBwZW5kKHVybCkKKyAgICAgICAgc3VwZXIoR1RL TWluaUJyb3dzZXJEcml2ZXIsIHNlbGYpLmxhdW5jaF91cmwodXJsLCBvcHRpb25zLCBicm93c2Vy X2J1aWxkX3BhdGgpCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFy a19ydW5uZXIvaHR0cF9zZXJ2ZXJfZHJpdmVyL3NpbXBsZV9odHRwX3NlcnZlcl9kcml2ZXIucHkg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvaHR0cF9zZXJ2ZXJfZHJp dmVyL3NpbXBsZV9odHRwX3NlcnZlcl9kcml2ZXIucHkKaW5kZXggMjZkODhmZDM5Y2I3N2E2MjBj N2MyMDZiMzM3MWMzMzA2NGY3ZWI0YS4uN2Y4NzhmNzkyYjJmNjE1ZTI1MjFiNmQzZWRmYzM3ZjNi NzRjNGI4YSAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVu bmVyL2h0dHBfc2VydmVyX2RyaXZlci9zaW1wbGVfaHR0cF9zZXJ2ZXJfZHJpdmVyLnB5CisrKyBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvYmVuY2htYXJrX3J1bm5lci9odHRwX3NlcnZlcl9kcml2 ZXIvc2ltcGxlX2h0dHBfc2VydmVyX2RyaXZlci5weQpAQCAtMTksNyArMTksNyBAQCBjbGFzcyBT aW1wbGVIVFRQU2VydmVyRHJpdmVyKEhUVFBTZXJ2ZXJEcml2ZXIpOgogICAgICIiIlRoaXMgY2xh c3MgZGVwZW5kcyBvbiB1bml4IGVudmlyb25tZW50LCBuZWVkIHRvIGJlIG1vZGlmaWVkIHRvIGFj aGlldmUgY3Jvc3NwbGF0Zm9ybSBjb21wYWJpbGl0eQogICAgICIiIgogCi0gICAgcGxhdGZvcm1z ID0gWydvc3gnLCAnZ3RrJ10KKyAgICBwbGF0Zm9ybXMgPSBbJ29zeCcsICdsaW51eCddCiAKICAg ICBkZWYgX19pbml0X18oc2VsZik6CiAgICAgICAgIHNlbGYuX3NlcnZlcl9wcm9jZXNzID0gTm9u ZQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9iZW5jaG1hcmtfcnVubmVyL3J1 bl9iZW5jaG1hcmsucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIv cnVuX2JlbmNobWFyay5weQppbmRleCA2YTM1ODA1MmExOWNiZjY3ODY4NDgzNTg0NTZkZTgxZWUy ZjAxNmJkLi43ZjZiODA4NmQ2MmRlNWFlMmVjYmE0ZTI2NjUwYmY1MTQ1NWU3ZWUzIDEwMDc1NQot LS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvcnVuX2JlbmNobWFy ay5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvcnVuX2Jl bmNobWFyay5weQpAQCAtNSw2ICs1LDcgQEAgaW1wb3J0IGpzb24KIGltcG9ydCBsb2dnaW5nCiBp bXBvcnQgcGxhdGZvcm0KIGltcG9ydCBvcworaW1wb3J0IHN5cwogCiBmcm9tIGJlbmNobWFya19y dW5uZXIgaW1wb3J0IEJlbmNobWFya1J1bm5lcgogZnJvbSBicm93c2VyX2RyaXZlci5icm93c2Vy X2RyaXZlcl9mYWN0b3J5IGltcG9ydCBCcm93c2VyRHJpdmVyRmFjdG9yeQpAQCAtMTMsMTMgKzE0 LDI0IEBAIGZyb20gYnJvd3Nlcl9kcml2ZXIuYnJvd3Nlcl9kcml2ZXJfZmFjdG9yeSBpbXBvcnQg QnJvd3NlckRyaXZlckZhY3RvcnkKIF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykK IAogCitkZWYgZGVmYXVsdF9wbGF0Zm9ybSgpOgorICAgIGlmIHN5cy5wbGF0Zm9ybS5zdGFydHN3 aXRoKCdsaW51eCcpOgorICAgICAgICByZXR1cm4gJ2xpbnV4JworICAgIHJldHVybiAnb3N4Jwor CisKK2RlZiBkZWZhdWx0X2Jyb3dzZXIoKToKKyAgICBpZiBzeXMucGxhdGZvcm0uc3RhcnRzd2l0 aCgnbGludXgnKToKKyAgICAgICAgcmV0dXJuICdtaW5pYnJvd3Nlci1ndGsnCisgICAgcmV0dXJu ICdzYWZhcmknCisKKwogZGVmIHBhcnNlX2FyZ3MoKToKICAgICBwYXJzZXIgPSBhcmdwYXJzZS5B cmd1bWVudFBhcnNlcihkZXNjcmlwdGlvbj0nQXV0b21hdGUgdGhlIGJyb3dzZXIgYmFzZWQgcGVy Zm9ybWFuY2UgYmVuY2htYXJrcycpCiAgICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1vdXRwdXQt ZmlsZScsIGRlc3Q9J291dHB1dCcsIGRlZmF1bHQ9Tm9uZSkKICAgICBwYXJzZXIuYWRkX2FyZ3Vt ZW50KCctLWJ1aWxkLWRpcmVjdG9yeScsIGRlc3Q9J2J1aWxkRGlyJywgaGVscD0nUGF0aCB0byB0 aGUgYnJvd3NlciBleGVjdXRhYmxlLiBlLmcuIFdlYktpdEJ1aWxkL1JlbGVhc2UvJykKLSAgICBw YXJzZXIuYWRkX2FyZ3VtZW50KCctLXBsYXRmb3JtJywgZGVzdD0ncGxhdGZvcm0nLCBkZWZhdWx0 PSdvc3gnLCBjaG9pY2VzPUJyb3dzZXJEcml2ZXJGYWN0b3J5LmF2YWlsYWJsZV9wbGF0Zm9ybXMo KSkKLSAgICAjIEZJWE1FOiBTaG91bGQgd2UgYWRkIGNocm9tZSBhcyBhbiBvcHRpb24/IFdlbGws IGNocm9tZSB1c2VzIHdlYmtpdCBpbiBpT1MuCi0gICAgcGFyc2VyLmFkZF9hcmd1bWVudCgnLS1i cm93c2VyJywgZGVzdD0nYnJvd3NlcicsIGRlZmF1bHQ9J3NhZmFyaScsIGNob2ljZXM9QnJvd3Nl ckRyaXZlckZhY3RvcnkuYXZhaWxhYmxlX2Jyb3dzZXJzKCkpCisgICAgcGFyc2VyLmFkZF9hcmd1 bWVudCgnLS1wbGF0Zm9ybScsIGRlc3Q9J3BsYXRmb3JtJywgZGVmYXVsdD1kZWZhdWx0X3BsYXRm b3JtKCksIGNob2ljZXM9QnJvd3NlckRyaXZlckZhY3RvcnkuYXZhaWxhYmxlX3BsYXRmb3Jtcygp KQorICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tYnJvd3NlcicsIGRlc3Q9J2Jyb3dzZXInLCBk ZWZhdWx0PWRlZmF1bHRfYnJvd3NlcigpLCBjaG9pY2VzPUJyb3dzZXJEcml2ZXJGYWN0b3J5LmF2 YWlsYWJsZV9icm93c2VycygpKQogICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tZGVidWcnLCBh Y3Rpb249J3N0b3JlX3RydWUnKQogICAgIHBhcnNlci5hZGRfYXJndW1lbnQoJy0tbG9jYWwtY29w eScsIGRlc3Q9J2xvY2FsQ29weScsIGhlbHA9J1BhdGggdG8gYSBsb2NhbCBjb3B5IG9mIHRoZSBi ZW5jaG1hcmsuIGUuZy4gUGVyZm9ybWFuY2VUZXN0cy9TdW5TcGlkZXIvJykKICAgICBwYXJzZXIu YWRkX2FyZ3VtZW50KCctLWNvdW50JywgZGVzdD0nY291bnRPdmVycmlkZScsIHR5cGU9aW50LCBo ZWxwPSdOdW1iZXIgb2YgdGltZXMgdG8gcnVuIHRoZSBiZW5jaG1hcmsuIGUuZy4gNScpCmRpZmYg LS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvdXRpbHMucHkg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2JlbmNobWFya19ydW5uZXIvdXRpbHMucHkKaW5kZXgg ZDYyOGYyYmEyYzM0OTFmZGYzYWFkZWIxZWU2NzljMDVjYjJjMzE5ZC4uNGY5MmEwZmVjNmY2YjQx OTJkYmNiMWIyMDJlNTBkNWUwZGEzMDExZCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9iZW5jaG1hcmtfcnVubmVyL3V0aWxzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvYmVuY2htYXJrX3J1bm5lci91dGlscy5weQpAQCAtMTksNyArMTksOCBAQCBkZWYgaXNfc3Vi Y2xhc3MoY2hpbGQsIHBhcmVudF9uYW1lKToKIAogCiBkZWYgbG9hZF9zdWJjbGFzc2VzKGRpcm5h bWUsIGJhc2VfY2xhc3NfbmFtZSwgYmFzZV9jbGFzc19maWxlLCBsb2FkZXIpOgotICAgIGZpbGVs aXN0ID0gW2Jhc2VfY2xhc3NfZmlsZV0gKyBbZiBmb3IgZiBpbiBvcy5saXN0ZGlyKGRpcm5hbWUp IGlmIGYuZW5kc3dpdGgoJy5weScpIGFuZCBmIG5vdCBpbiBbJ19faW5pdF9fLnB5JywgYmFzZV9j bGFzc19maWxlXV0KKyAgICBmaWxlbGlzdCA9IFtiYXNlX2NsYXNzX2ZpbGVdICsgW2YgZm9yIGYg aW4gb3MubGlzdGRpcihkaXJuYW1lKSBpZiBmLmVuZHN3aXRoKCdfJyArIGJhc2VfY2xhc3NfZmls ZSldCisgICAgZmlsZWxpc3QgKz0gW2YgZm9yIGYgaW4gb3MubGlzdGRpcihkaXJuYW1lKSBpZiBm LmVuZHN3aXRoKCcucHknKSBhbmQgZiBub3QgaW4gWydfX2luaXRfXy5weSddICsgZmlsZWxpc3Rd CiAgICAgZm9yIGZpbGVuYW1lIGluIGZpbGVsaXN0OgogICAgICAgICBtb2R1bGVfbmFtZSA9IG9z LnBhdGguc3BsaXRleHQoZmlsZW5hbWUpWzBdCiAgICAgICAgIG1vZHVsZSA9IGltcC5sb2FkX3Nv dXJjZShtb2R1bGVfbmFtZSwgb3MucGF0aC5qb2luKGRpcm5hbWUsIGZpbGVuYW1lKSkK