140476 2015-01-14 16:22:27 -0800 Create iOS-EWS client queue 2015-01-22 20:00:16 -0800 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 140473 140585 140637 140787 1 jake.nielsen.webkit jake.nielsen.webkit ap bfulgham commit-queue dbates ddkilzer glenn oldest_to_newest 1061391 0 jake.nielsen.webkit 2015-01-14 16:22:27 -0800 Create iOS-EWS client queue. 1061392 1 244658 jake.nielsen.webkit 2015-01-14 16:23:29 -0800 Created attachment 244658 Potential patch (needs testing!) 1061437 2 jake.nielsen.webkit 2015-01-14 17:59:03 -0800 It's aliiiive! https://webkit-queues.appspot.com/queue-status/ios-ews 1061498 3 244658 ap 2015-01-14 23:58:42 -0800 Comment on attachment 244658 Potential patch (needs testing!) View in context: https://bugs.webkit.org/attachment.cgi?id=244658&action=review > Tools/EWSTools/start-queue-mac.sh:47 > + (cd $WEBKIT_HOME; sudo ./Tools/Scripts/configure-xcode-for-ios-development) Does this need to be done on every start, or is once per machine enough? Sudoing a script from a script makes me nervous for some reason. > Tools/Scripts/webkitpy/common/config/ports.py:147 > + def run_javascriptcore_tests_command(self): > + return None > + > + def run_webkit_unit_tests_command(self): > + return None > + > + def run_webkit_tests_command(self): > + return None > + > + def run_python_unittests_command(self): > + return None > + > + def run_perl_unittests_command(self): > + return None > + > + def run_bindings_tests_command(self): > + return None I don't know if we need any of this. Shouldn't we just configure EWS in such a way that it doesn't attempt to run tests? I don't know how it's done, but Windows, Gtk and Efl EWS bots all avoid running tests. > Tools/Scripts/webkitpy/port/apple.py:59 > + if port_name == 'ios': > + return port_name This explicitly prevents ios-wk2 from being produced, why? Also, iOS full port name will not include a version, making integration with TestExpectations harder. > Tools/Scripts/webkitpy/port/apple.py:87 > - allowed_port_names = self.VERSION_FALLBACK_ORDER + [self.operating_system() + "-future"] > + allowed_port_names = self.VERSION_FALLBACK_ORDER + [self.operating_system() + "-future"] + ['ios'] Hmm, this is overridden in mac.py, should ios.py just do the same as mac.py? It doesn't seem right to make apple.py know about iOS, but not about any OS X versions. > Tools/Scripts/webkitpy/port/ios.py:58 > + self._leak_detector = LeakDetector(self) This will be dead code, probably best to not land it. > Tools/Scripts/webkitpy/port/ios.py:64 > + mac_config = port_config.Config(self._executive, self._filesystem, 'mac') > + self._mac_build_directory = mac_config.build_directory(self.get_option('configuration')) Hmm. > Tools/Scripts/webkitpy/port/ios.py:73 > + if self.get_option('driver_name'): > + return self.get_option('driver_name') > + if self.get_option('webkit_test_runner'): > + return 'WebKitTestRunnerApp.app' > + return 'DumpRenderTree.app' More dead code. Almost everything down below is about running tests. 1061561 4 ap 2015-01-15 09:30:23 -0800 > Shouldn't we just configure EWS in such a way that it doesn't attempt to run tests? I think that you already have that taken care of, through ews.json. 1061596 5 jake.nielsen.webkit 2015-01-15 11:31:05 -0800 (In reply to comment #3) > Comment on attachment 244658 [details] > Potential patch (needs testing!) > > View in context: > https://bugs.webkit.org/attachment.cgi?id=244658&action=review > > > Tools/EWSTools/start-queue-mac.sh:47 > > + (cd $WEBKIT_HOME; sudo ./Tools/Scripts/configure-xcode-for-ios-development) > > Does this need to be done on every start, or is once per machine enough? > Sudoing a script from a script makes me nervous for some reason. It should only need to be run once, but running it multiple times shouldn't be a problem. I had a discussion with Lucas regarding whether this was better to just run once on the machine, and then clone the machine's drive with that already taken care of. His stance was that we should just run it every time because it's one less configuration piece that needs to have occurred in order for the script to function. Personally, I'm not strongly opinionated in either direction. > > > Tools/Scripts/webkitpy/common/config/ports.py:147 > > + def run_javascriptcore_tests_command(self): > > + return None > > + > > + def run_webkit_unit_tests_command(self): > > + return None > > + > > + def run_webkit_tests_command(self): > > + return None > > + > > + def run_python_unittests_command(self): > > + return None > > + > > + def run_perl_unittests_command(self): > > + return None > > + > > + def run_bindings_tests_command(self): > > + return None > > I don't know if we need any of this. Shouldn't we just configure EWS in such > a way that it doesn't attempt to run tests? I don't know how it's done, but > Windows, Gtk and Efl EWS bots all avoid running tests. I'll start pruning things until something breaks to boil down this patch. > > > Tools/Scripts/webkitpy/port/apple.py:59 > > + if port_name == 'ios': > > + return port_name > > This explicitly prevents ios-wk2 from being produced, why? Also, iOS full > port name will not include a version, making integration with > TestExpectations harder. I was just trying to circumvent this assert (which will fail, because "mac" is not in "ios" ) assert host.platform.os_name in port_name, "%s is not in %s!" % (host.platform.os_name, port_name) I'll think harder about what the correct thing to do is and post another patch. > > > Tools/Scripts/webkitpy/port/apple.py:87 > > - allowed_port_names = self.VERSION_FALLBACK_ORDER + [self.operating_system() + "-future"] > > + allowed_port_names = self.VERSION_FALLBACK_ORDER + [self.operating_system() + "-future"] + ['ios'] > > Hmm, this is overridden in mac.py, should ios.py just do the same as mac.py? > It doesn't seem right to make apple.py know about iOS, but not about any OS > X versions. Good point! > > > Tools/Scripts/webkitpy/port/ios.py:58 > > + self._leak_detector = LeakDetector(self) > > This will be dead code, probably best to not land it. > > > Tools/Scripts/webkitpy/port/ios.py:64 > > + mac_config = port_config.Config(self._executive, self._filesystem, 'mac') > > + self._mac_build_directory = mac_config.build_directory(self.get_option('configuration')) > > Hmm. > > > Tools/Scripts/webkitpy/port/ios.py:73 > > + if self.get_option('driver_name'): > > + return self.get_option('driver_name') > > + if self.get_option('webkit_test_runner'): > > + return 'WebKitTestRunnerApp.app' > > + return 'DumpRenderTree.app' > > More dead code. Almost everything down below is about running tests. Yeah, I'll prune stuff and get back to you. 1061907 6 244658 ap 2015-01-16 12:43:13 -0800 Comment on attachment 244658 Potential patch (needs testing!) View in context: https://bugs.webkit.org/attachment.cgi?id=244658&action=review > Tools/Scripts/webkitpy/port/ios.py:310 > port_name = "ios-simulator" This is not part of this patch, but I just wanted to mention that this may be confusing a lot of webkitpy code. It probably parses "simulator" as an OS version. 1061972 7 244803 jake.nielsen.webkit 2015-01-16 14:40:57 -0800 Created attachment 244803 Patch 1061991 8 244803 ap 2015-01-16 15:18:01 -0800 Comment on attachment 244803 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=244803&action=review > Tools/EWSTools/start-queue-mac.sh:3 > +# Copyright (c) 2014-2015 Apple Inc. All rights reserved. I think that "2014, 2015" is right when there is nothing in between. > Tools/Scripts/webkitpy/common/config/ports.py:67 > + "ios": IOSPort, I'm worried that ios-simulator will now drop here (there are probably code paths that strip the version before constructing a DeprecatedPort). We used to get MacPort for the simulator, and now we get IOSPort. > Tools/Scripts/webkitpy/common/config/ports.py:127 > + command = super(IOSPort, self).build_webkit_command(build_style=build_style) build-webkit --help says that --device uses current iphoneos.internal SDK. Is that a lie? Or is this dead code? > Tools/Scripts/webkitpy/port/factory.py:87 > 'ios.IOSSimulatorPort', > + 'ios.IOSPort', Alphabetical! > Tools/Scripts/webkitpy/port/ios.py:1 > +# Copyright (C) 2014-2015 Apple Inc. All rights reserved. 2014, 2015 > Tools/Scripts/webkitpy/port/ios.py:55 > + sdk_command_stdout = sdk_command_process.communicate()[0].strip() It would probably be a good idea to plan for iOS 10. > Tools/Scripts/webkitpy/port/ios.py:57 > + assert sdk_command_stdout, "xcode is not installed, and hence we cannot construct an iOS port object!" Xcode (upper case) > Tools/Scripts/webkitpy/port/ios.py:81 > + def _path_to_webcore_library(self): > + return self._build_path('WebCore.framework/WebCore') Why is this needed? > Tools/Scripts/webkitpy/port/ios.py:87 > + def make_command(self): > + return self.xcrun_find('make', '/usr/bin/make') > + > + def nm_command(self): > + return self.xcrun_find('nm') Why are these needed? > Tools/Scripts/webkitpy/port/ios.py:99 > + def developer_dir(self): > + return self._executive.run_command(['xcode-select', '--print-path']).rstrip() It sounds like these things should be inherited from ApplePort, there is nothing iOS specific here. 1062069 9 244828 jake.nielsen.webkit 2015-01-16 18:20:55 -0800 Created attachment 244828 Patch 1062081 10 244828 ap 2015-01-16 19:26:07 -0800 Comment on attachment 244828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=244828&action=review > Tools/Scripts/webkitpy/port/ios.py:73 > + #Despite its name, these flags do not actually get passed all the way down to webkit-build. Travelers beware. Some grammar here (its/these). Please add a space in the beginning, and remove useless "travelers beware". > Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py:111 > + self.run_webkit_patch(command + [self._deprecated_port.flag()] + ['--architecture=%s' % self._port.architecture()] if self._port.architecture() else []) Is precedence correct here? 1062091 11 ddkilzer 2015-01-17 00:13:38 -0800 <rdar://problem/19462823> 1062092 12 244828 ddkilzer 2015-01-17 00:47:44 -0800 Comment on attachment 244828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=244828&action=review > Tools/Scripts/webkitpy/port/ios.py:54 > + sdk_command_process = subprocess.Popen('xcrun --sdk iphoneos --show-sdk-version', stdout=subprocess.PIPE, shell=True) Added "stderr=None" argument when landing to quiet some console spew running test-webkitpy. >> Tools/Scripts/webkitpy/port/ios.py:73 >> + #Despite its name, these flags do not actually get passed all the way down to webkit-build. Travelers beware. > > Some grammar here (its/these). Please add a space in the beginning, and remove useless "travelers beware". Fixed when landed. > Tools/Scripts/webkitpy/port/ios.py:75 > + return ['--sdk', 'iphoneos', 'ARCHS=%s' % self._architecture] Changed this to check self._architecture when landed: return ['--sdk', 'iphoneos'] + (['ARCHS=%s' % self._architecture] if self._architecture else []) Looking at the overall patch, this probably isn't needed, but won't hurt anything. >> Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py:111 >> + self.run_webkit_patch(command + [self._deprecated_port.flag()] + ['--architecture=%s' % self._port.architecture()] if self._port.architecture() else []) > > Is precedence correct here? No, it wasn't. Added parenthesis when landed: (['--architecture=%s' % self._port.architecture()] if self._port.architecture() else []) 1062093 13 244828 ddkilzer 2015-01-17 00:48:16 -0800 Comment on attachment 244828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=244828&action=review > Tools/Scripts/webkitpy/port/ios.py:54 > + sdk_command_process = subprocess.Popen('xcrun --sdk iphoneos --show-sdk-version', stdout=subprocess.PIPE, shell=True) Added "stderr=None" argument when landing to quiet some console spew running test-webkitpy. >> Tools/Scripts/webkitpy/port/ios.py:73 >> + #Despite its name, these flags do not actually get passed all the way down to webkit-build. Travelers beware. > > Some grammar here (its/these). Please add a space in the beginning, and remove useless "travelers beware". Fixed when landed. > Tools/Scripts/webkitpy/port/ios.py:75 > + return ['--sdk', 'iphoneos', 'ARCHS=%s' % self._architecture] Changed this to check self._architecture when landed: return ['--sdk', 'iphoneos'] + (['ARCHS=%s' % self._architecture] if self._architecture else []) Looking at the overall patch, this probably isn't needed, but won't hurt anything. >> Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py:111 >> + self.run_webkit_patch(command + [self._deprecated_port.flag()] + ['--architecture=%s' % self._port.architecture()] if self._port.architecture() else []) > > Is precedence correct here? No, it wasn't. Added parenthesis when landed: (['--architecture=%s' % self._port.architecture()] if self._port.architecture() else []) 1062094 14 ddkilzer 2015-01-17 00:48:49 -0800 Committed r178622: <http://trac.webkit.org/changeset/178622> 1062095 15 ddkilzer 2015-01-17 02:09:18 -0800 (In reply to comment #14) > Committed r178622: <http://trac.webkit.org/changeset/178622> Build fix for non-Mac ports (or Mac ports without an iOS SDK installed): Committed r178623: <http://trac.webkit.org/changeset/178623> 1062096 16 ddkilzer 2015-01-17 02:51:26 -0800 (In reply to comment #15) > (In reply to comment #14) > > Committed r178622: <http://trac.webkit.org/changeset/178622> > > Build fix for non-Mac ports (or Mac ports without an iOS SDK installed): > > Committed r178623: <http://trac.webkit.org/changeset/178623> Fix test-webkitpy on Mountain Lion, Mavericks bots: Committed r178624: <http://trac.webkit.org/changeset/178624> Some GTK bots are still failing, but I don't see what the issue is; it's kind of crazy that we try to create Port objects on every single platform, even if they aren't supported: <https://build.webkit.org/builders/GTK%20Linux%2064-bit%20Release%20%28Tests%29/builds/5459/steps/webkitpy-test/logs/stdio> Traceback (most recent call last): File "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem_unittest.py", line 103, in test_ewses self._test_ews(ews_class()) File "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem_unittest.py", line 96, in _test_ews self.assert_queue_outputs(ews, expected_logs=self._default_expected_logs(ews), options=options) File "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem_unittest.py", line 65, in _default_expected_logs real_port = Host().port_factory.get(real_port_name) File "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/webkitpy/port/factory.py", line 118, in get port_name = cls.determine_full_port_name(self._host, options, port_name) File "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/webkitpy/port/apple.py", line 65, in determine_full_port_name assert host.platform.os_name in port_name, "%s is not in %s!" % (host.platform.os_name, port_name) AssertionError: linux is not in mac-wk2! 1062097 17 ddkilzer 2015-01-17 03:14:07 -0800 (In reply to comment #16) > Some GTK bots are still failing, but I don't see what the issue is; it's > kind of crazy that we try to create Port objects on every single platform, > even if they aren't supported: > > <https://build.webkit.org/builders/GTK%20Linux%2064- > bit%20Release%20%28Tests%29/builds/5459/steps/webkitpy-test/logs/stdio> > > Traceback (most recent call last): > File > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > webkitpy/tool/commands/earlywarningsystem_unittest.py", line 103, in > test_ewses > self._test_ews(ews_class()) > File > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > webkitpy/tool/commands/earlywarningsystem_unittest.py", line 96, in _test_ews > self.assert_queue_outputs(ews, > expected_logs=self._default_expected_logs(ews), options=options) > File > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > webkitpy/tool/commands/earlywarningsystem_unittest.py", line 65, in > _default_expected_logs > real_port = Host().port_factory.get(real_port_name) > File > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > webkitpy/port/factory.py", line 118, in get > port_name = cls.determine_full_port_name(self._host, options, > port_name) > File > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > webkitpy/port/apple.py", line 65, in determine_full_port_name > assert host.platform.os_name in port_name, "%s is not in %s!" % > (host.platform.os_name, port_name) > AssertionError: linux is not in mac-wk2! The code added to earlywarningsystem_unittest.py to find the architecture for the port assumes that it will get the right answer for the system it's running on. That's not true for the port object created for mac-wk2-ews on a GTK Linux box. Not sure how to fix yet. The right thing to do would be to mock the architecture it would seem. 1062270 18 ddkilzer 2015-01-18 22:33:45 -0800 (In reply to comment #17) > (In reply to comment #16) > > Some GTK bots are still failing, but I don't see what the issue is; it's > > kind of crazy that we try to create Port objects on every single platform, > > even if they aren't supported: > > > > <https://build.webkit.org/builders/GTK%20Linux%2064- > > bit%20Release%20%28Tests%29/builds/5459/steps/webkitpy-test/logs/stdio> > > > > Traceback (most recent call last): > > File > > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > > webkitpy/tool/commands/earlywarningsystem_unittest.py", line 103, in > > test_ewses > > self._test_ews(ews_class()) > > File > > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > > webkitpy/tool/commands/earlywarningsystem_unittest.py", line 96, in _test_ews > > self.assert_queue_outputs(ews, > > expected_logs=self._default_expected_logs(ews), options=options) > > File > > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > > webkitpy/tool/commands/earlywarningsystem_unittest.py", line 65, in > > _default_expected_logs > > real_port = Host().port_factory.get(real_port_name) > > File > > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > > webkitpy/port/factory.py", line 118, in get > > port_name = cls.determine_full_port_name(self._host, options, > > port_name) > > File > > "/home/slave/webkitgtk/gtk-linux-64-release-tests/build/Tools/Scripts/ > > webkitpy/port/apple.py", line 65, in determine_full_port_name > > assert host.platform.os_name in port_name, "%s is not in %s!" % > > (host.platform.os_name, port_name) > > AssertionError: linux is not in mac-wk2! > > The code added to earlywarningsystem_unittest.py to find the architecture > for the port assumes that it will get the right answer for the system it's > running on. That's not true for the port object created for mac-wk2-ews on > a GTK Linux box. > > Not sure how to fix yet. The right thing to do would be to mock the > architecture it would seem. Still teasing apart the code to try to figure out when/where the architecture is set when testing EWS classes. 1062366 19 244828 dbates 2015-01-19 08:57:36 -0800 Comment on attachment 244828 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=244828&action=review I know this path was reviewed and landed. I noticed some issues. > Tools/Scripts/webkitpy/port/ios.py:55 > + sdk_command_process = subprocess.Popen('xcrun --sdk iphoneos --show-sdk-version', stdout=subprocess.PIPE, shell=True) > + sdk_command_stdout = sdk_command_process.communicate()[0].strip() Is it necessary to execute this using the shell (shell=True)? I take it we do to take advantage of the PATH environment variable to find xcun? Instead I suggest we reference the full path to /usr/bin/xcrun and remove the shell=True option. Also, it's sufficient to strip the newline characters are the end of the output (i.e. rstrip) as opposed to using strip to remove whitespace at the start and end of the string since xcrun --sdk iphoneos --show-sdk-version doesn't emit whitespace at the beginning of its output. Moreover, can we simplify this sdk_command_stdout = subprocess.check_output(...).rstrip()? > Tools/Scripts/webkitpy/port/ios.py:59 > + port_name = port_name + '-' + re.match('^([0-9]+).*', sdk_command_stdout).group(1) It seems unnecessary to match zero or more arbitrary characters after the first sequence of ASCII numbers. > Tools/Scripts/webkitpy/tool/commands/queues.py:32 > +import optparse It doesn't seem correct to import optparse to parse command line options at this layer in the software. I would have expected optparse to be used at a higher layer that is closer to the program entry point. > Tools/Scripts/webkitpy/tool/commands/queues.py:282 > + port_options = optparse.Values() > + if self.architecture: > + setattr(port_options, 'architecture', self.architecture) This doesn't seem like the correct way to get at port options and prevents unit testing the architecture option. Aren't the port options passed to PatchProcessingQueue or its base class? 1062479 20 jake.nielsen.webkit 2015-01-19 13:06:50 -0800 (In reply to comment #19) > Comment on attachment 244828 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=244828&action=review > > I know this path was reviewed and landed. I noticed some issues. > > > Tools/Scripts/webkitpy/port/ios.py:55 > > + sdk_command_process = subprocess.Popen('xcrun --sdk iphoneos --show-sdk-version', stdout=subprocess.PIPE, shell=True) > > + sdk_command_stdout = sdk_command_process.communicate()[0].strip() > > Is it necessary to execute this using the shell (shell=True)? I take it we > do to take advantage of the PATH environment variable to find xcun? Instead > I suggest we reference the full path to /usr/bin/xcrun and remove the > shell=True option. Also, it's sufficient to strip the newline characters are > the end of the output (i.e. rstrip) as opposed to using strip to remove > whitespace at the start and end of the string since xcrun --sdk iphoneos > --show-sdk-version doesn't emit whitespace at the beginning of its output. > > Moreover, can we simplify this sdk_command_stdout = > subprocess.check_output(...).rstrip()? > > > Tools/Scripts/webkitpy/port/ios.py:59 > > + port_name = port_name + '-' + re.match('^([0-9]+).*', sdk_command_stdout).group(1) > > It seems unnecessary to match zero or more arbitrary characters after the > first sequence of ASCII numbers. > > > Tools/Scripts/webkitpy/tool/commands/queues.py:32 > > +import optparse > > It doesn't seem correct to import optparse to parse command line options at > this layer in the software. I would have expected optparse to be used at a > higher layer that is closer to the program entry point. > > > Tools/Scripts/webkitpy/tool/commands/queues.py:282 > > + port_options = optparse.Values() > > + if self.architecture: > > + setattr(port_options, 'architecture', self.architecture) > > This doesn't seem like the correct way to get at port options and prevents > unit testing the architecture option. Aren't the port options passed to > PatchProcessingQueue or its base class? I created another bug and patch for these issues, and also addressed the python unit test problems: https://bugs.webkit.org/show_bug.cgi?id=140637 1062759 21 bfulgham 2015-01-20 09:05:34 -0800 This patch introduced a python test failure on the Windows bots (and perhaps other non-Mac bots): [1231/1425] webkitpy.tool.commands.earlywarningsystem_unittest.EarlyWarningSystemTest.test_ewses /bin/sh: xcrun: command not found [1232/1425] webkitpy.tool.commands.earlywarningsystem_unittest.EarlyWarningSystemTest.test_ewses failed: Traceback (most recent call last): File "/home/buildbot/slave/win-release-tests/build/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem_unittest.py", line 103, in test_ewses self._test_ews(ews_class()) File "/home/buildbot/slave/win-release-tests/build/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem_unittest.py", line 96, in _test_ews self.assert_queue_outputs(ews, expected_logs=self._default_expected_logs(ews), options=options) File "/home/buildbot/slave/win-release-tests/build/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem_unittest.py", line 65, in _default_expected_logs real_port = Host().port_factory.get(real_port_name) File "/home/buildbot/slave/win-release-tests/build/Tools/Scripts/webkitpy/port/factory.py", line 118, in get port_name = cls.determine_full_port_name(self._host, options, port_name) File "/home/buildbot/slave/win-release-tests/build/Tools/Scripts/webkitpy/port/ios.py", line 57, in determine_full_port_name assert sdk_command_stdout, "Xcode is not installed, and hence we cannot construct an iOS port object!" AssertionError: Xcode is not installed, and hence we cannot construct an iOS port object! 244658 2015-01-14 16:23:29 -0800 2015-01-16 14:40:55 -0800 Potential patch (needs testing!) 0001-Adds-the-ios-ews-client-side-functionality.patch text/plain 18623 jake.nielsen.webkit RnJvbSAzOGE1MDYyMzY2ZjUwYWM0MmYxMDFiOWJjM2E0MmZmNzVkZGJkNWM5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKYWtlIE5pZWxzZW4gPGphY29iX25pZWxzZW5AYXBwbGUuY29t PgpEYXRlOiBXZWQsIDE0IEphbiAyMDE1IDE2OjE4OjU3IC0wODAwClN1YmplY3Q6IFtQQVRDSF0g QWRkcyB0aGUgaW9zLWV3cyBjbGllbnQtc2lkZSBmdW5jdGlvbmFsaXR5CgotLS0KIFRvb2xzL0VX U1Rvb2xzL3N0YXJ0LXF1ZXVlLW1hYy5zaCAgICAgICAgICAgICB8ICAxOCArLQogVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2V3cy5qc29uIHwgICAzICsKIFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9wb3J0cy5weSB8ICAyOSArKysKIFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9hcHBsZS5weSAgICAgICAgICB8ICAgNCArLQogVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9wb3J0L2ZhY3RvcnkucHkgICAgICAgIHwgICAxICsKIFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9pb3MucHkgICAgICAgICAgICB8IDI2NyArKysrKysrKysrKysrKysrKysr KysrKysrLQogNiBmaWxlcyBjaGFuZ2VkLCAzMTUgaW5zZXJ0aW9ucygrKSwgNyBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9Ub29scy9FV1NUb29scy9zdGFydC1xdWV1ZS1tYWMuc2ggYi9Ub29s cy9FV1NUb29scy9zdGFydC1xdWV1ZS1tYWMuc2gKaW5kZXggMDQwNjUxZC4uODYyNGRjMiAxMDA3 NTUKLS0tIGEvVG9vbHMvRVdTVG9vbHMvc3RhcnQtcXVldWUtbWFjLnNoCisrKyBiL1Rvb2xzL0VX U1Rvb2xzL3N0YXJ0LXF1ZXVlLW1hYy5zaApAQCAtMSw2ICsxLDYgQEAKICMhL2Jpbi9zaAogIyBD b3B5cmlnaHQgKGMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KLSMgQ29w eXJpZ2h0IChjKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMgQ29weXJp Z2h0IChjKSAyMDE0LTIwMTUgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogIwogIyBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKICMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQpAQCAtMzksMjAgKzM5LDI4IEBAIFJFU0VUX0FGVEVS X0lURVJBVElPTj0kMwogc2hpZnQgMwogUVVFVUVfUEFSQU1TPSIkQCIKIAorRVdTX0hPTUU9L1Zv bHVtZXMvRGF0YS9FV1MKK1dFQktJVF9IT01FPSRFV1NfSE9NRS9XZWJLaXQKKworIyBJZiBidWls ZGluZyBmb3IgaU9TLCBtYWtlIHN1cmUgd2UgcnVuIHRoaXMgc2NyaXB0IHRvIG1ha2UgaXQgcG9z c2libGUgdG8gYnVpbGQgZnJhbWV3b3Jrcy4KK2lmIFsgIiRRVUVVRV9OQU1FIiA9PSAiaW9zLWV3 cyIgXTsgdGhlbgorICAgIChjZCAkV0VCS0lUX0hPTUU7IHN1ZG8gLi9Ub29scy9TY3JpcHRzL2Nv bmZpZ3VyZS14Y29kZS1mb3ItaW9zLWRldmVsb3BtZW50KQorZmkKKwogIyBXZSByZWJvb3QgZXZl cnkgbmlnaHQgYmV0d2VlbiAxIGFuZCA2IHRvIHJlZHVjZSB0aGUgbGlrZWxpaG9vZCBvZiB1bmV4 cGVjdGVkIHJlYm9vdHMgd2hpbGUgcGVvcGxlIGFyZSBsb29raW5nIGludG8gdGhpbmdzLgogVElN RV9UT19SRUJPT1Q9JCgoICQoZGF0ZSArJXMpICsgMzYwMCAqIDEyKSkKIAogd2hpbGUgWyAkVElN RV9UT19SRUJPT1QgLWd0ICQoZGF0ZSArJXMpIF0gfHwgWyAkKGRhdGUgKyVIKSAtbHQgMSBdIHx8 IFsgJChkYXRlICslSCkgLWdlIDYgXTsgZG8KLSAgICAjIERlbGV0ZSBsb2cgZmlsZXMgb2xkZXIg dGhhbiAxNCBkYXlzLCBtb3ZlIGFzaWRlIHRoZSBtYWluIG1hYy1ld3MubG9nIGZpbGUgdG8gcHJl dmVudCBpdCBmcm9tIGdyb3dpbmcgZXh0cmEgbGFyZ2UuCi0gICAgY2QgL1ZvbHVtZXMvRGF0YS9F V1MvJFFVRVVFX05BTUUtbG9ncworICAgICMgRGVsZXRlIGxvZyBmaWxlcyBvbGRlciB0aGFuIDE0 IGRheXMsIG1vdmUgYXNpZGUgdGhlIG1haW4gJFFVRVVFX05BTUUtZXdzLmxvZyBmaWxlIHRvIHBy ZXZlbnQgaXQgZnJvbSBncm93aW5nIGV4dHJhIGxhcmdlLgorICAgIGNkICRFV1NfSE9NRS8kUVVF VUVfTkFNRS1sb2dzCiAgICAgZmluZCAuIC1tdGltZSArMTQgLWRlbGV0ZQogICAgIGlmIFsgLXMg JFFVRVVFX05BTUUubG9nIF07IHRoZW4KICAgICAgICAgbXYgLWYgJFFVRVVFX05BTUUubG9nICR7 UVVFVUVfTkFNRX1fJChkYXRlICslWS0lbS0lZF8lSC0lbSkubG9nCiAgICAgZmkKLSAgICBjZCAv Vm9sdW1lcy9EYXRhL0VXUy9XZWJraXQKKyAgICBjZCAkV0VCS0lUX0hPTUUKICAgICAKICAgICAj IERlbGV0ZSBXZWJLaXRCdWlsZCB0byBmb3JjZSBhIGNsZWFuIGJ1aWxkCi0gICAgcm0gLXJmIC9W b2x1bWVzL0RhdGEvRVdTL1dlYktpdC9XZWJLaXRCdWlsZAorICAgIHJtIC1yZiAkV0VCS0lUX0hP TUUvV2ViS2l0QnVpbGQKICAgICAKICAgICAjIFRoaXMgc29tZXdoYXQgcXVpcmt5IHNlcXVlbmNl IG9mIHN0ZXBzIHNlZW1zIHRvIGNsZWFyIHVwIGFsbCB0aGUgYnJva2VuCiAgICAgIyBnaXQgc2l0 dWF0aW9ucyB3ZSd2ZSBnb3R0ZW4gb3Vyc2VsZiBpbnRvIGluIHRoZSBwYXN0LgpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2V3cy5qc29uIGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2V3cy5qc29uCmluZGV4IGJmYTRiYzYuLmE3 YTJhZWIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9l d3MuanNvbgorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvZXdzLmpz b24KQEAgLTE0LDYgKzE0LDkgQEAKICAgICAiV2luIEVXUyI6IHsKICAgICAgICAgInBvcnQiOiAi d2luIgogICAgIH0sCisgICAgImlPUyBFV1MiOiB7CisgICAgICAgICJwb3J0IjogImlvcyIKKyAg ICB9LAogICAgICJNYWMgRVdTIjogewogICAgICAgICAicG9ydCI6ICJtYWMiLAogICAgICAgICAi d2F0Y2hlcnMiOiBbCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9j b25maWcvcG9ydHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvcG9y dHMucHkKaW5kZXggYjcwYjgzYy4uMmRjZDVjNCAxMDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93 ZWJraXRweS9jb21tb24vY29uZmlnL3BvcnRzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvY29tbW9uL2NvbmZpZy9wb3J0cy5weQpAQCAtMSw1ICsxLDYgQEAKICMgQ29weXJpZ2h0IChD KSAyMDA5LCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogIyBDb3B5cmlnaHQgKEMp IDIwMTMgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMpLgorIyBD b3B5cmlnaHQgKEMpIDIwMTUgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogIwogIyBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKICMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQpAQCAtNjMsNiArNjQsNyBAQCBjbGFzcyBEZXByZWNh dGVkUG9ydChvYmplY3QpOgogICAgIGRlZiBwb3J0KHBvcnRfbmFtZSk6CiAgICAgICAgIHBvcnRz ID0gewogICAgICAgICAgICAgImd0ay13azIiOiBHdGtXSzJQb3J0LAorICAgICAgICAgICAgImlv cyI6IElPU1BvcnQsCiAgICAgICAgICAgICAibWFjIjogTWFjUG9ydCwKICAgICAgICAgICAgICJt YWMtd2syIjogTWFjV0syUG9ydCwKICAgICAgICAgICAgICJ3aW4iOiBXaW5Qb3J0LApAQCAtMTE4 LDYgKzEyMCwzMyBAQCBjbGFzcyBEZXByZWNhdGVkUG9ydChvYmplY3QpOgogICAgICAgICByZXR1 cm4gc2VsZi5zY3JpcHRfc2hlbGxfY29tbWFuZCgicnVuLWJpbmRpbmdzLXRlc3RzIikKIAogCitj bGFzcyBJT1NQb3J0KERlcHJlY2F0ZWRQb3J0KToKKyAgICBwb3J0X2ZsYWdfbmFtZSA9ICJpb3Mi CisKKyAgICBkZWYgYnVpbGRfd2Via2l0X2NvbW1hbmQoc2VsZiwgYnVpbGRfc3R5bGU9Tm9uZSk6 CisgICAgICAgIGNvbW1hbmQgPSBzdXBlcihJT1NQb3J0LCBzZWxmKS5idWlsZF93ZWJraXRfY29t bWFuZChidWlsZF9zdHlsZT1idWlsZF9zdHlsZSkKKyAgICAgICAgY29tbWFuZC5hcHBlbmQoIi0t ZGV2aWNlIikKKyAgICAgICAgcmV0dXJuIGNvbW1hbmQKKworICAgIGRlZiBydW5famF2YXNjcmlw dGNvcmVfdGVzdHNfY29tbWFuZChzZWxmKToKKyAgICAgICAgcmV0dXJuIE5vbmUKKworICAgIGRl ZiBydW5fd2Via2l0X3VuaXRfdGVzdHNfY29tbWFuZChzZWxmKToKKyAgICAgICAgcmV0dXJuIE5v bmUKKworICAgIGRlZiBydW5fd2Via2l0X3Rlc3RzX2NvbW1hbmQoc2VsZik6CisgICAgICAgIHJl dHVybiBOb25lCisKKyAgICBkZWYgcnVuX3B5dGhvbl91bml0dGVzdHNfY29tbWFuZChzZWxmKToK KyAgICAgICAgcmV0dXJuIE5vbmUKKworICAgIGRlZiBydW5fcGVybF91bml0dGVzdHNfY29tbWFu ZChzZWxmKToKKyAgICAgICAgcmV0dXJuIE5vbmUKKworICAgIGRlZiBydW5fYmluZGluZ3NfdGVz dHNfY29tbWFuZChzZWxmKToKKyAgICAgICAgcmV0dXJuIE5vbmUKKworCiBjbGFzcyBNYWNQb3J0 KERlcHJlY2F0ZWRQb3J0KToKICAgICBwb3J0X2ZsYWdfbmFtZSA9ICJtYWMiCiAKZGlmZiAtLWdp dCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9hcHBsZS5weSBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvcG9ydC9hcHBsZS5weQppbmRleCA5NjZkMDRhLi41OTgyZjE4IDEwMDY0NAotLS0g YS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYXBwbGUucHkKKysrIGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9wb3J0L2FwcGxlLnB5CkBAIC01NSw2ICs1NSw4IEBAIGNsYXNzIEFwcGxlUG9y dChQb3J0KToKIAogICAgIEBjbGFzc21ldGhvZAogICAgIGRlZiBkZXRlcm1pbmVfZnVsbF9wb3J0 X25hbWUoY2xzLCBob3N0LCBvcHRpb25zLCBwb3J0X25hbWUpOgorICAgICAgICBpZiBwb3J0X25h bWUgPT0gJ2lvcyc6CisgICAgICAgICAgICByZXR1cm4gcG9ydF9uYW1lCiAgICAgICAgIG9wdGlv bnMgPSBvcHRpb25zIG9yIHt9CiAgICAgICAgIGlmIHBvcnRfbmFtZSBpbiAoY2xzLnBvcnRfbmFt ZSwgY2xzLnBvcnRfbmFtZSArICctd2syJyk6CiAgICAgICAgICAgICAjIElmIHRoZSBwb3J0X25h bWUgbWF0Y2hlcyB0aGUgKGJhZGx5IG5hbWVkKSBjbHMucG9ydF9uYW1lLCB0aGF0CkBAIC04Miw3 ICs4NCw3IEBAIGNsYXNzIEFwcGxlUG9ydChQb3J0KToKICAgICBkZWYgX19pbml0X18oc2VsZiwg aG9zdCwgcG9ydF9uYW1lLCAqKmt3YXJncyk6CiAgICAgICAgIHN1cGVyKEFwcGxlUG9ydCwgc2Vs ZikuX19pbml0X18oaG9zdCwgcG9ydF9uYW1lLCAqKmt3YXJncykKIAotICAgICAgICBhbGxvd2Vk X3BvcnRfbmFtZXMgPSBzZWxmLlZFUlNJT05fRkFMTEJBQ0tfT1JERVIgKyBbc2VsZi5vcGVyYXRp bmdfc3lzdGVtKCkgKyAiLWZ1dHVyZSJdCisgICAgICAgIGFsbG93ZWRfcG9ydF9uYW1lcyA9IHNl bGYuVkVSU0lPTl9GQUxMQkFDS19PUkRFUiArIFtzZWxmLm9wZXJhdGluZ19zeXN0ZW0oKSArICIt ZnV0dXJlIl0gKyBbJ2lvcyddCiAgICAgICAgIHBvcnRfbmFtZSA9IHBvcnRfbmFtZS5yZXBsYWNl KCctd2syJywgJycpCiAgICAgICAgIHNlbGYuX3ZlcnNpb24gPSBzZWxmLl9zdHJpcF9wb3J0X25h bWVfcHJlZml4KHBvcnRfbmFtZSkKICAgICAgICAgYXNzZXJ0IHBvcnRfbmFtZSBpbiBhbGxvd2Vk X3BvcnRfbmFtZXMsICIlcyBpcyBub3QgaW4gJXMiICUgKHBvcnRfbmFtZSwgYWxsb3dlZF9wb3J0 X25hbWVzKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2ZhY3Rvcnku cHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQppbmRleCBkYjdhYjRh Li5hZWVmYWVjIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9y eS5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQpAQCAtODQs NiArODQsNyBAQCBjbGFzcyBQb3J0RmFjdG9yeShvYmplY3QpOgogICAgICAgICAnZWZsLkVmbFBv cnQnLAogICAgICAgICAnZ3RrLkd0a1BvcnQnLAogICAgICAgICAnaW9zLklPU1NpbXVsYXRvclBv cnQnLAorICAgICAgICAnaW9zLklPU1BvcnQnLAogICAgICAgICAnbWFjLk1hY1BvcnQnLAogICAg ICAgICAnbW9ja19kcnQuTW9ja0RSVFBvcnQnLAogICAgICAgICAndGVzdC5UZXN0UG9ydCcsCmRp ZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zLnB5IGIvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9wb3J0L2lvcy5weQppbmRleCA5YTYwNTMyLi5mNTAzMGQwIDEwMDY0NAot LS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zLnB5CisrKyBiL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9pb3MucHkKQEAgLTEsNCArMSw0IEBACi0jIENvcHlyaWdodCAoQykg MjAxNCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjIENvcHlyaWdodCAoQykgMjAx NC0yMDE1IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICMKICMgUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAj IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucwpAQCAtMzEsNiArMzEsNyBAQCBpbXBvcnQgc3VicHJvY2VzcwogZnJvbSB3ZWJr aXRweS5sYXlvdXRfdGVzdHMubW9kZWxzLnRlc3RfY29uZmlndXJhdGlvbiBpbXBvcnQgVGVzdENv bmZpZ3VyYXRpb24KIGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5jcmFzaGxvZ3MgaW1wb3J0 IENyYXNoTG9ncwogZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQg U2NyaXB0RXJyb3IKK2Zyb20gd2Via2l0cHkucG9ydC5hcHBsZSBpbXBvcnQgQXBwbGVQb3J0CiBm cm9tIHdlYmtpdHB5LnBvcnQgaW1wb3J0IGRyaXZlciwgaW1hZ2VfZGlmZgogZnJvbSB3ZWJraXRw eS5wb3J0LmJhc2UgaW1wb3J0IFBvcnQKIGZyb20gd2Via2l0cHkucG9ydC5sZWFrZGV0ZWN0b3Ig aW1wb3J0IExlYWtEZXRlY3RvcgpAQCAtNDEsNiArNDIsMjcwIEBAIGZyb20gd2Via2l0cHkueGNv ZGUgaW1wb3J0IHNpbXVsYXRvcgogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKF9fbmFtZV9fKQog CiAKK2NsYXNzIElPU1BvcnQoQXBwbGVQb3J0KToKKyAgICBwb3J0X25hbWUgPSAiaW9zIgorCisg ICAgQVJDSElURUNUVVJFUyA9IFsnYXJtdjcnLCAnYXJtdjdzJywgJ2FybTY0J10KKworICAgIGRl ZiBfX2luaXRfXyhzZWxmLCAqYXJncywgKiprd2FyZ3MpOgorICAgICAgICBzdXBlcihJT1NQb3J0 LCBzZWxmKS5fX2luaXRfXygqYXJncywgKiprd2FyZ3MpCisKKyAgICAgICAgc2VsZi5fYXJjaGl0 ZWN0dXJlID0gc2VsZi5nZXRfb3B0aW9uKCdhcmNoaXRlY3R1cmUnKQorCisgICAgICAgIGlmIG5v dCBzZWxmLl9hcmNoaXRlY3R1cmU6CisgICAgICAgICAgICBzZWxmLl9hcmNoaXRlY3R1cmUgPSAn YXJtdjcnCisKKyAgICAgICAgc2VsZi5fbGVha19kZXRlY3RvciA9IExlYWtEZXRlY3RvcihzZWxm KQorICAgICAgICBpZiBzZWxmLmdldF9vcHRpb24oImxlYWtzIik6CisgICAgICAgICAgICAjIER1 bXBSZW5kZXJUcmVlIHNsb3dzIGRvd24gbm90aWNhYmx5IGlmIHdlIHJ1biBtb3JlIHRoYW4gYWJv dXQgMTAwMCB0ZXN0cyBpbiBhIGJhdGNoCisgICAgICAgICAgICAjIHdpdGggTWFsbG9jU3RhY2tM b2dnaW5nIGVuYWJsZWQuCisgICAgICAgICAgICBzZWxmLnNldF9vcHRpb25fZGVmYXVsdCgiYmF0 Y2hfc2l6ZSIsIDEwMDApCisgICAgICAgIG1hY19jb25maWcgPSBwb3J0X2NvbmZpZy5Db25maWco c2VsZi5fZXhlY3V0aXZlLCBzZWxmLl9maWxlc3lzdGVtLCAnbWFjJykKKyAgICAgICAgc2VsZi5f bWFjX2J1aWxkX2RpcmVjdG9yeSA9IG1hY19jb25maWcuYnVpbGRfZGlyZWN0b3J5KHNlbGYuZ2V0 X29wdGlvbignY29uZmlndXJhdGlvbicpKQorCisgICAgICAgIHNlbGYuX3Rlc3RpbmdfZGV2aWNl ID0gTm9uZQorCisgICAgZGVmIGRyaXZlcl9uYW1lKHNlbGYpOgorICAgICAgICBpZiBzZWxmLmdl dF9vcHRpb24oJ2RyaXZlcl9uYW1lJyk6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5nZXRfb3B0 aW9uKCdkcml2ZXJfbmFtZScpCisgICAgICAgIGlmIHNlbGYuZ2V0X29wdGlvbignd2Via2l0X3Rl c3RfcnVubmVyJyk6CisgICAgICAgICAgICByZXR1cm4gJ1dlYktpdFRlc3RSdW5uZXJBcHAuYXBw JworICAgICAgICByZXR1cm4gJ0R1bXBSZW5kZXJUcmVlLmFwcCcKKworICAgIGRlZiBkZWZhdWx0 X3RpbWVvdXRfbXMoc2VsZik6CisgICAgICAgIGlmIHNlbGYuZ2V0X29wdGlvbignZ3VhcmRfbWFs bG9jJyk6CisgICAgICAgICAgICByZXR1cm4gMzUwICogMTAwMAorICAgICAgICByZXR1cm4gc3Vw ZXIoSU9TUG9ydCwgc2VsZikuZGVmYXVsdF90aW1lb3V0X21zKCkKKworICAgIGRlZiBzdXBwb3J0 c19wZXJfdGVzdF90aW1lb3V0KHNlbGYpOgorICAgICAgICByZXR1cm4gVHJ1ZQorCisgICAgZGVm IF9jaGVja19yZWxheShzZWxmKToKKyAgICAgICAgaWYgbm90IHNlbGYuX2ZpbGVzeXN0ZW0uZXhp c3RzKHNlbGYucmVsYXlfcGF0aCk6CisgICAgICAgICAgICBfbG9nLmVycm9yKCIlcyB3YXMgbm90 IGZvdW5kIGF0ICVzIiAlIChzZWxmLnJlbGF5X25hbWUsIHNlbGYucmVsYXlfcGF0aCkpCisgICAg ICAgICAgICByZXR1cm4gRmFsc2UKKyAgICAgICAgcmV0dXJuIFRydWUKKworICAgIGRlZiBfY2hl Y2tfYnVpbGRfcmVsYXkoc2VsZik6CisgICAgICAgIGlmIHNlbGYuZ2V0X29wdGlvbignYnVpbGQn KSBhbmQgbm90IHNlbGYuX2J1aWxkX3JlbGF5KCk6CisgICAgICAgICAgICByZXR1cm4gRmFsc2UK KyAgICAgICAgaWYgbm90IHNlbGYuX2NoZWNrX3JlbGF5KCk6CisgICAgICAgICAgICByZXR1cm4g RmFsc2UKKyAgICAgICAgcmV0dXJuIFRydWUKKworICAgIGRlZiBjaGVja19idWlsZChzZWxmLCBu ZWVkc19odHRwKToKKyAgICAgICAgbmVlZHNfZHJpdmVyID0gc3VwZXIoSU9TUG9ydCwgc2VsZiku Y2hlY2tfYnVpbGQobmVlZHNfaHR0cCkKKyAgICAgICAgcmV0dXJuIG5lZWRzX2RyaXZlciBhbmQg c2VsZi5fY2hlY2tfYnVpbGRfcmVsYXkoKQorCisgICAgZGVmIF9idWlsZF9kcml2ZXJfZmxhZ3Mo c2VsZik6CisgICAgICAgIHNkayA9IFsnLS1zZGsnLCAnaXBob25lb3MnXQorICAgICAgICByZXR1 cm4gc2RrCisKKyAgICBkZWYgc2hvdWxkX3JldHJ5X2NyYXNoZXMoc2VsZik6CisgICAgICAgIHJl dHVybiBUcnVlCisKKyAgICBkZWYgX2dlbmVyYXRlX2FsbF90ZXN0X2NvbmZpZ3VyYXRpb25zKHNl bGYpOgorICAgICAgICBjb25maWd1cmF0aW9ucyA9IFtdCisgICAgICAgIGZvciBidWlsZF90eXBl IGluIHNlbGYuQUxMX0JVSUxEX1RZUEVTOgorICAgICAgICAgICAgZm9yIGFyY2hpdGVjdHVyZSBp biBzZWxmLkFSQ0hJVEVDVFVSRVM6CisgICAgICAgICAgICAgICAgY29uZmlndXJhdGlvbnMuYXBw ZW5kKFRlc3RDb25maWd1cmF0aW9uKHZlcnNpb249c2VsZi5fdmVyc2lvbiwgYXJjaGl0ZWN0dXJl PWFyY2hpdGVjdHVyZSwgYnVpbGRfdHlwZT1idWlsZF90eXBlKSkKKyAgICAgICAgcmV0dXJuIGNv bmZpZ3VyYXRpb25zCisKKyAgICBkZWYgX2RyaXZlcl9jbGFzcyhzZWxmKToKKyAgICAgICAgcmV0 dXJuIGRyaXZlci5JT1NEcml2ZXIKKworICAgIGRlZiBkZWZhdWx0X2Jhc2VsaW5lX3NlYXJjaF9w YXRoKHNlbGYpOgorICAgICAgICBpZiBzZWxmLmdldF9vcHRpb24oJ3dlYmtpdF90ZXN0X3J1bm5l cicpOgorICAgICAgICAgICAgZmFsbGJhY2tfbmFtZXMgPSBbc2VsZi5wb3J0X25hbWUgKyAnLXdr MiddICsgW3NlbGYucG9ydF9uYW1lXQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgZmFsbGJh Y2tfbmFtZXMgPSBbc2VsZi5wb3J0X25hbWVdCisKKyAgICAgICAgcmV0dXJuIG1hcChzZWxmLl93 ZWJraXRfYmFzZWxpbmVfcGF0aCwgZmFsbGJhY2tfbmFtZXMpCisKKyAgICBkZWYgX3BvcnRfc3Bl Y2lmaWNfZXhwZWN0YXRpb25zX2ZpbGVzKHNlbGYpOgorICAgICAgICByZXR1cm4gbGlzdChyZXZl cnNlZChbc2VsZi5fZmlsZXN5c3RlbS5qb2luKHNlbGYuX3dlYmtpdF9iYXNlbGluZV9wYXRoKHAp LCAnVGVzdEV4cGVjdGF0aW9ucycpIGZvciBwIGluIHNlbGYuYmFzZWxpbmVfc2VhcmNoX3BhdGgo KV0pKQorCisgICAgZGVmIHNldHVwX2Vudmlyb25fZm9yX3NlcnZlcihzZWxmLCBzZXJ2ZXJfbmFt ZT1Ob25lKToKKyAgICAgICAgZW52ID0gc3VwZXIoSU9TUG9ydCwgc2VsZikuc2V0dXBfZW52aXJv bl9mb3Jfc2VydmVyKHNlcnZlcl9uYW1lKQorICAgICAgICBpZiBzZXJ2ZXJfbmFtZSA9PSBzZWxm LmRyaXZlcl9uYW1lKCk6CisgICAgICAgICAgICBpZiBzZWxmLmdldF9vcHRpb24oJ2xlYWtzJyk6 CisgICAgICAgICAgICAgICAgZW52WydNYWxsb2NTdGFja0xvZ2dpbmcnXSA9ICcxJworICAgICAg ICAgICAgaWYgc2VsZi5nZXRfb3B0aW9uKCdndWFyZF9tYWxsb2MnKToKKyAgICAgICAgICAgICAg ICBlbnZbJ0RZTERfSU5TRVJUX0xJQlJBUklFUyddID0gJy91c3IvbGliL2xpYmdtYWxsb2MuZHls aWI6JyArIHNlbGYuX2J1aWxkX3BhdGgoImxpYldlYkNvcmVUZXN0U2hpbS5keWxpYiIpCisgICAg ICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgIGVudlsnRFlMRF9JTlNFUlRfTElCUkFSSUVT J10gPSBzZWxmLl9idWlsZF9wYXRoKCJsaWJXZWJDb3JlVGVzdFNoaW0uZHlsaWIiKQorICAgICAg ICBlbnZbJ1hNTF9DQVRBTE9HX0ZJTEVTJ10gPSAnJyAgIyB3b3JrIGFyb3VuZCBtaXNzaW5nIC9l dGMvY2F0YWxvZyA8cmRhcjovL3Byb2JsZW0vNDI5Mjk5NT4KKyAgICAgICAgcmV0dXJuIGVudgor CisgICAgZGVmIG9wZXJhdGluZ19zeXN0ZW0oc2VsZik6CisgICAgICAgIHJldHVybiAnaW9zJwor CisgICAgZGVmIGNoZWNrX2Zvcl9sZWFrcyhzZWxmLCBwcm9jZXNzX25hbWUsIHByb2Nlc3NfcGlk KToKKyAgICAgICAgaWYgbm90IHNlbGYuZ2V0X29wdGlvbignbGVha3MnKToKKyAgICAgICAgICAg IHJldHVybgorICAgICAgICAjIFdlIGNvdWxkIHVzZSBodHRwOi8vY29kZS5nb29nbGUuY29tL3Av cHN1dGlsLyB0byBnZXQgdGhlIHByb2Nlc3NfbmFtZSBmcm9tIHRoZSBwaWQuCisgICAgICAgIHNl bGYuX2xlYWtfZGV0ZWN0b3IuY2hlY2tfZm9yX2xlYWtzKHByb2Nlc3NfbmFtZSwgcHJvY2Vzc19w aWQpCisKKyAgICBkZWYgcHJpbnRfbGVha3Nfc3VtbWFyeShzZWxmKToKKyAgICAgICAgaWYgbm90 IHNlbGYuZ2V0X29wdGlvbignbGVha3MnKToKKyAgICAgICAgICAgIHJldHVybgorICAgICAgICAj IFdlJ3JlIGluIHRoZSBtYW5hZ2VyIHByb2Nlc3MsIHNvIHRoZSBsZWFrIGRldGVjdG9yIHdpbGwg bm90IGhhdmUgYSB2YWxpZCBsaXN0IG9mIGxlYWsgZmlsZXMuCisgICAgICAgIGxlYWtzX2ZpbGVz ID0gc2VsZi5fbGVha19kZXRlY3Rvci5sZWFrc19maWxlc19pbl9kaXJlY3Rvcnkoc2VsZi5yZXN1 bHRzX2RpcmVjdG9yeSgpKQorICAgICAgICBpZiBub3QgbGVha3NfZmlsZXM6CisgICAgICAgICAg ICByZXR1cm4KKyAgICAgICAgdG90YWxfYnl0ZXNfc3RyaW5nLCB1bmlxdWVfbGVha3MgPSBzZWxm Ll9sZWFrX2RldGVjdG9yLmNvdW50X3RvdGFsX2J5dGVzX2FuZF91bmlxdWVfbGVha3MobGVha3Nf ZmlsZXMpCisgICAgICAgIHRvdGFsX2xlYWtzID0gc2VsZi5fbGVha19kZXRlY3Rvci5jb3VudF90 b3RhbF9sZWFrcyhsZWFrc19maWxlcykKKyAgICAgICAgX2xvZy5pbmZvKCIlcyB0b3RhbCBsZWFr cyBmb3VuZCBmb3IgYSB0b3RhbCBvZiAlcyEiICUgKHRvdGFsX2xlYWtzLCB0b3RhbF9ieXRlc19z dHJpbmcpKQorICAgICAgICBfbG9nLmluZm8oIiVzIHVuaXF1ZSBsZWFrcyBmb3VuZCEiICUgdW5p cXVlX2xlYWtzKQorCisgICAgZGVmIF9wYXRoX3RvX3dlYmNvcmVfbGlicmFyeShzZWxmKToKKyAg ICAgICAgcmV0dXJuIHNlbGYuX2J1aWxkX3BhdGgoJ1dlYkNvcmUuZnJhbWV3b3JrL1dlYkNvcmUn KQorCisgICAgZGVmIHNob3dfcmVzdWx0c19odG1sX2ZpbGUoc2VsZiwgcmVzdWx0c19maWxlbmFt ZSk6CisgICAgICAgICMgV2UgZG9uJ3QgdXNlIHNlbGYuX3J1bl9zY3JpcHQoKSBiZWNhdXNlIHdl IGRvbid0IHdhbnQgdG8gd2FpdCBmb3IgdGhlIHNjcmlwdAorICAgICAgICAjIHRvIGV4aXQgYW5k IHdlIHdhbnQgdGhlIG91dHB1dCB0byBzaG93IHVwIG9uIHN0ZG91dCBpbiBjYXNlIHRoZXJlIGFy ZSBlcnJvcnMKKyAgICAgICAgIyBsYXVuY2hpbmcgdGhlIGJyb3dzZXIuCisgICAgICAgIHNlbGYu X2V4ZWN1dGl2ZS5wb3Blbihbc2VsZi5wYXRoX3RvX3NjcmlwdCgncnVuLXNhZmFyaScpXSArIHNl bGYuX2FyZ3VtZW50c19mb3JfY29uZmlndXJhdGlvbigpICsgWyctLW5vLXNhdmVkLXN0YXRlJywg Jy1OU09wZW4nLCByZXN1bHRzX2ZpbGVuYW1lXSwKKyAgICAgICAgICAgIGN3ZD1zZWxmLndlYmtp dF9iYXNlKCksIHN0ZG91dD1maWxlKG9zLmRldm51bGwpLCBzdGRlcnI9ZmlsZShvcy5kZXZudWxs KSkKKworICAgIGRlZiBzYW1wbGVfZmlsZV9wYXRoKHNlbGYsIG5hbWUsIHBpZCk6CisgICAgICAg IHJldHVybiBzZWxmLl9maWxlc3lzdGVtLmpvaW4oc2VsZi5yZXN1bHRzX2RpcmVjdG9yeSgpLCAi ezB9LXsxfS1zYW1wbGUudHh0Ii5mb3JtYXQobmFtZSwgcGlkKSkKKworICAgIFNVQlBST0NFU1Nf Q1JBU0hfUkVHRVggPSByZS5jb21waWxlKCcjQ1JBU0hFRCAtICg/UDxzdWJwcm9jZXNzX25hbWU+ XFMrKSBcKHBpZCAoP1A8c3VicHJvY2Vzc19waWQ+XGQrKVwpJykKKworICAgIGRlZiBfZ2V0X2Ny YXNoX2xvZyhzZWxmLCBuYW1lLCBwaWQsIHN0ZG91dCwgc3RkZXJyLCBuZXdlcl90aGFuLCB0aW1l X2ZuPXRpbWUudGltZSwgc2xlZXBfZm49dGltZS5zbGVlcCwgd2FpdF9mb3JfbG9nPVRydWUpOgor ICAgICAgICB0aW1lX2ZuID0gdGltZV9mbiBvciB0aW1lLnRpbWUKKyAgICAgICAgc2xlZXBfZm4g PSBzbGVlcF9mbiBvciB0aW1lLnNsZWVwCisKKyAgICAgICAgIyBGSVhNRTogV2Ugc2hvdWxkIGNv bGxlY3QgdGhlIGFjdHVhbCBjcmFzaCBsb2cgZm9yIER1bXBSZW5kZXJUcmVlLmFwcCBiZWNhdXNl IGl0IGluY2x1ZGVzIG1vcmUKKyAgICAgICAgIyBpbmZvcm1hdGlvbiAoZS5nLiBleGNlcHRpb24g Y29kZXMpIHRoYW4gaXMgYXZhaWxhYmxlIGluIHRoZSBzdGFjayB0cmFjZSB3cml0dGVuIHRvIHN0 YW5kYXJkIGVycm9yLgorICAgICAgICBzdGRlcnJfbGluZXMgPSBbXQorICAgICAgICBjcmFzaGVk X3N1YnByb2Nlc3NfbmFtZV9hbmRfcGlkID0gTm9uZSAgIyBlLmcuICgnRHVtcFJlbmRlclRyZWUu YXBwJywgMTIzNCkKKyAgICAgICAgZm9yIGxpbmUgaW4gKHN0ZGVyciBvciAnJykuc3BsaXRsaW5l cygpOgorICAgICAgICAgICAgaWYgbm90IGNyYXNoZWRfc3VicHJvY2Vzc19uYW1lX2FuZF9waWQ6 CisgICAgICAgICAgICAgICAgbWF0Y2ggPSBzZWxmLlNVQlBST0NFU1NfQ1JBU0hfUkVHRVgubWF0 Y2gobGluZSkKKyAgICAgICAgICAgICAgICBpZiBtYXRjaDoKKyAgICAgICAgICAgICAgICAgICAg Y3Jhc2hlZF9zdWJwcm9jZXNzX25hbWVfYW5kX3BpZCA9IChtYXRjaC5ncm91cCgnc3VicHJvY2Vz c19uYW1lJyksIGludChtYXRjaC5ncm91cCgnc3VicHJvY2Vzc19waWQnKSkpCisgICAgICAgICAg ICAgICAgICAgIGNvbnRpbnVlCisgICAgICAgICAgICBzdGRlcnJfbGluZXMuYXBwZW5kKGxpbmUp CisKKyAgICAgICAgaWYgY3Jhc2hlZF9zdWJwcm9jZXNzX25hbWVfYW5kX3BpZDoKKyAgICAgICAg ICAgIHJldHVybiBzZWxmLl9nZXRfY3Jhc2hfbG9nKGNyYXNoZWRfc3VicHJvY2Vzc19uYW1lX2Fu ZF9waWRbMF0sIGNyYXNoZWRfc3VicHJvY2Vzc19uYW1lX2FuZF9waWRbMV0sIHN0ZG91dCwKKyAg ICAgICAgICAgICAgICAnXG4nLmpvaW4oc3RkZXJyX2xpbmVzKSwgbmV3ZXJfdGhhbiwgdGltZV9m biwgc2xlZXBfZm4sIHdhaXRfZm9yX2xvZykKKworICAgICAgICAjIExheW91dFRlc3RSZWxheSBj cmFzaGVkCisgICAgICAgIF9sb2cuZGVidWcoJ2xvb2tpbmcgZm9yIGNyYXNoIGxvZyBmb3IgJXM6 JXMnICUgKG5hbWUsIHN0cihwaWQpKSkKKyAgICAgICAgY3Jhc2hfbG9nID0gJycKKyAgICAgICAg Y3Jhc2hfbG9ncyA9IENyYXNoTG9ncyhzZWxmLmhvc3QpCisgICAgICAgIG5vdyA9IHRpbWVfZm4o KQorICAgICAgICBkZWFkbGluZSA9IG5vdyArIDUgKiBpbnQoc2VsZi5nZXRfb3B0aW9uKCdjaGls ZF9wcm9jZXNzZXMnLCAxKSkKKyAgICAgICAgd2hpbGUgbm90IGNyYXNoX2xvZyBhbmQgbm93IDw9 IGRlYWRsaW5lOgorICAgICAgICAgICAgY3Jhc2hfbG9nID0gY3Jhc2hfbG9ncy5maW5kX25ld2Vz dF9sb2cobmFtZSwgcGlkLCBpbmNsdWRlX2Vycm9ycz1UcnVlLCBuZXdlcl90aGFuPW5ld2VyX3Ro YW4pCisgICAgICAgICAgICBpZiBub3Qgd2FpdF9mb3JfbG9nOgorICAgICAgICAgICAgICAgIGJy ZWFrCisgICAgICAgICAgICBpZiBub3QgY3Jhc2hfbG9nIG9yIG5vdCBbbGluZSBmb3IgbGluZSBp biBjcmFzaF9sb2cuc3BsaXRsaW5lcygpIGlmIG5vdCBsaW5lLnN0YXJ0c3dpdGgoJ0VSUk9SJyld OgorICAgICAgICAgICAgICAgIHNsZWVwX2ZuKDAuMSkKKyAgICAgICAgICAgICAgICBub3cgPSB0 aW1lX2ZuKCkKKworICAgICAgICBpZiBub3QgY3Jhc2hfbG9nOgorICAgICAgICAgICAgcmV0dXJu IHN0ZGVyciwgTm9uZQorICAgICAgICByZXR1cm4gc3RkZXJyLCBjcmFzaF9sb2cKKworICAgIEBw cm9wZXJ0eQorICAgIGRlZiB0ZXN0aW5nX2RldmljZShzZWxmKToKKyAgICAgICAgaWYgc2VsZi5f dGVzdGluZ19kZXZpY2UgaXMgbm90IE5vbmU6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5fdGVz dGluZ19kZXZpY2UKKworICAgICAgICBkZXZpY2VfdHlwZSA9IHNlbGYuZ2V0X29wdGlvbignZGV2 aWNlX3R5cGUnKQorICAgICAgICBydW50aW1lID0gc2VsZi5nZXRfb3B0aW9uKCdydW50aW1lJykK KyAgICAgICAgc2VsZi5fdGVzdGluZ19kZXZpY2UgPSBzaW11bGF0b3IuU2ltdWxhdG9yKCkudGVz dGluZ19kZXZpY2UoZGV2aWNlX3R5cGUsIHJ1bnRpbWUpCisgICAgICAgIHJldHVybiBzZWxmLnRl c3RpbmdfZGV2aWNlCisKKyAgICBkZWYgc2ltdWxhdG9yX3BhdGgoc2VsZiwgdWRpZCk6CisgICAg ICAgIGlmIHVkaWQ6CisgICAgICAgICAgICByZXR1cm4gb3MucGF0aC5yZWFscGF0aChvcy5wYXRo LmV4cGFuZHVzZXIob3MucGF0aC5qb2luKCd+L0xpYnJhcnkvRGV2ZWxvcGVyL0NvcmVTaW11bGF0 b3IvRGV2aWNlcycsIHVkaWQpKSkKKworICAgIGRlZiBsb29rX2Zvcl9uZXdfY3Jhc2hfbG9ncyhz ZWxmLCBjcmFzaGVkX3Byb2Nlc3Nlcywgc3RhcnRfdGltZSk6CisgICAgICAgIGNyYXNoX2xvZ3Mg PSB7fQorICAgICAgICBmb3IgKHRlc3RfbmFtZSwgcHJvY2Vzc19uYW1lLCBwaWQpIGluIGNyYXNo ZWRfcHJvY2Vzc2VzOgorICAgICAgICAgICAgIyBQYXNzaW5nIE5vbmUgZm9yIG91dHB1dC4gIFRo aXMgaXMgYSBzZWNvbmQgcGFzcyBhZnRlciB0aGUgdGVzdCBmaW5pc2hlZCBzbworICAgICAgICAg ICAgIyBpZiB0aGUgb3V0cHV0IGhhZCBhbnkgbG9nZ2luZyB3ZSB3b3VsZCBoYXZlIGFscmVhZHkg Y29sbGVjdGVkIGl0LgorICAgICAgICAgICAgY3Jhc2hfbG9nID0gc2VsZi5fZ2V0X2NyYXNoX2xv Zyhwcm9jZXNzX25hbWUsIHBpZCwgTm9uZSwgTm9uZSwgc3RhcnRfdGltZSwgd2FpdF9mb3JfbG9n PUZhbHNlKVsxXQorICAgICAgICAgICAgaWYgbm90IGNyYXNoX2xvZzoKKyAgICAgICAgICAgICAg ICBjb250aW51ZQorICAgICAgICAgICAgY3Jhc2hfbG9nc1t0ZXN0X25hbWVdID0gY3Jhc2hfbG9n CisgICAgICAgIHJldHVybiBjcmFzaF9sb2dzCisKKyAgICBkZWYgbG9va19mb3JfbmV3X3NhbXBs ZXMoc2VsZiwgdW5yZXNwb25zaXZlX3Byb2Nlc3Nlcywgc3RhcnRfdGltZSk6CisgICAgICAgIHNh bXBsZV9maWxlcyA9IHt9CisgICAgICAgIGZvciAodGVzdF9uYW1lLCBwcm9jZXNzX25hbWUsIHBp ZCkgaW4gdW5yZXNwb25zaXZlX3Byb2Nlc3NlczoKKyAgICAgICAgICAgIHNhbXBsZV9maWxlID0g c2VsZi5zYW1wbGVfZmlsZV9wYXRoKHByb2Nlc3NfbmFtZSwgcGlkKQorICAgICAgICAgICAgaWYg bm90IHNlbGYuX2ZpbGVzeXN0ZW0uaXNmaWxlKHNhbXBsZV9maWxlKToKKyAgICAgICAgICAgICAg ICBjb250aW51ZQorICAgICAgICAgICAgc2FtcGxlX2ZpbGVzW3Rlc3RfbmFtZV0gPSBzYW1wbGVf ZmlsZQorICAgICAgICByZXR1cm4gc2FtcGxlX2ZpbGVzCisKKyAgICBkZWYgc2FtcGxlX3Byb2Nl c3Moc2VsZiwgbmFtZSwgcGlkKToKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgaGFuZ19yZXBv cnQgPSBzZWxmLnNhbXBsZV9maWxlX3BhdGgobmFtZSwgcGlkKQorICAgICAgICAgICAgc2VsZi5f ZXhlY3V0aXZlLnJ1bl9jb21tYW5kKFsKKyAgICAgICAgICAgICAgICAiL3Vzci9iaW4vc2FtcGxl IiwKKyAgICAgICAgICAgICAgICBwaWQsCisgICAgICAgICAgICAgICAgMTAsCisgICAgICAgICAg ICAgICAgMTAsCisgICAgICAgICAgICAgICAgIi1maWxlIiwKKyAgICAgICAgICAgICAgICBoYW5n X3JlcG9ydCwKKyAgICAgICAgICAgIF0pCisgICAgICAgIGV4Y2VwdCBTY3JpcHRFcnJvciBhcyBl OgorICAgICAgICAgICAgX2xvZy53YXJuaW5nKCdVbmFibGUgdG8gc2FtcGxlIHByb2Nlc3M6JyAr IHN0cihlKSkKKworICAgIGRlZiBfcGF0aF90b19oZWxwZXIoc2VsZik6CisgICAgICAgIGJpbmFy eV9uYW1lID0gJ0xheW91dFRlc3RIZWxwZXInCisgICAgICAgIHJldHVybiBzZWxmLl9idWlsZF9w YXRoKGJpbmFyeV9uYW1lKQorCisgICAgZGVmIGRpZmZfaW1hZ2Uoc2VsZiwgZXhwZWN0ZWRfY29u dGVudHMsIGFjdHVhbF9jb250ZW50cywgdG9sZXJhbmNlPU5vbmUpOgorICAgICAgICBpZiBub3Qg YWN0dWFsX2NvbnRlbnRzIGFuZCBub3QgZXhwZWN0ZWRfY29udGVudHM6CisgICAgICAgICAgICBy ZXR1cm4gKE5vbmUsIDAsIE5vbmUpCisgICAgICAgIGlmIG5vdCBhY3R1YWxfY29udGVudHMgb3Ig bm90IGV4cGVjdGVkX2NvbnRlbnRzOgorICAgICAgICAgICAgcmV0dXJuIChUcnVlLCAwLCBOb25l KQorICAgICAgICBpZiBub3Qgc2VsZi5faW1hZ2VfZGlmZmVyOgorICAgICAgICAgICAgc2VsZi5f aW1hZ2VfZGlmZmVyID0gaW1hZ2VfZGlmZi5JT1NJbWFnZURpZmZlcihzZWxmKQorICAgICAgICBz ZWxmLnNldF9vcHRpb25fZGVmYXVsdCgndG9sZXJhbmNlJywgMC4xKQorICAgICAgICBpZiB0b2xl cmFuY2UgaXMgTm9uZToKKyAgICAgICAgICAgIHRvbGVyYW5jZSA9IHNlbGYuZ2V0X29wdGlvbign dG9sZXJhbmNlJykKKyAgICAgICAgcmV0dXJuIHNlbGYuX2ltYWdlX2RpZmZlci5kaWZmX2ltYWdl KGV4cGVjdGVkX2NvbnRlbnRzLCBhY3R1YWxfY29udGVudHMsIHRvbGVyYW5jZSkKKworICAgIGRl ZiByZXNldF9wcmVmZXJlbmNlcyhzZWxmKToKKyAgICAgICAgc2ltdWxhdG9yX3BhdGggPSBzZWxm LnRlc3RpbmdfZGV2aWNlLnBhdGgKKyAgICAgICAgZGF0YV9wYXRoID0gb3MucGF0aC5qb2luKHNp bXVsYXRvcl9wYXRoLCAnZGF0YScpCisgICAgICAgIGlmIG9zLnBhdGguaXNkaXIoZGF0YV9wYXRo KToKKyAgICAgICAgICAgIHNodXRpbC5ybXRyZWUoZGF0YV9wYXRoKQorCisgICAgZGVmIG1ha2Vf Y29tbWFuZChzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYueGNydW5fZmluZCgnbWFrZScsICcv dXNyL2Jpbi9tYWtlJykKKworICAgIGRlZiBubV9jb21tYW5kKHNlbGYpOgorICAgICAgICByZXR1 cm4gc2VsZi54Y3J1bl9maW5kKCdubScpCisKKyAgICBkZWYgeGNydW5fZmluZChzZWxmLCBjb21t YW5kLCBmYWxsYmFjaz1Ob25lKToKKyAgICAgICAgZmFsbGJhY2sgPSBmYWxsYmFjayBvciBjb21t YW5kCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHJldHVybiBzZWxmLl9leGVjdXRpdmUucnVu X2NvbW1hbmQoWyd4Y3J1bicsICctLXNkaycsICdpcGhvbmVvcycsICctZmluZCcsIGNvbW1hbmRd KS5yc3RyaXAoKQorICAgICAgICBleGNlcHQgU2NyaXB0RXJyb3I6CisgICAgICAgICAgICBfbG9n Lndhcm4oInhjcnVuIGZhaWxlZDsgZmFsbGluZyBiYWNrIHRvICclcycuIiAlIGZhbGxiYWNrKQor ICAgICAgICAgICAgcmV0dXJuIGZhbGxiYWNrCisKKyAgICBAcHJvcGVydHkKKyAgICBkZWYgZGV2 ZWxvcGVyX2RpcihzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYuX2V4ZWN1dGl2ZS5ydW5fY29t bWFuZChbJ3hjb2RlLXNlbGVjdCcsICctLXByaW50LXBhdGgnXSkucnN0cmlwKCkKKworICAgIGRl ZiBsb2dnaW5nX3BhdHRlcm5zX3RvX3N0cmlwKHNlbGYpOgorICAgICAgICByZXR1cm4gW10KKwor ICAgIGRlZiBzdGRlcnJfcGF0dGVybnNfdG9fc3RyaXAoc2VsZik6CisgICAgICAgIHJldHVybiBb XQorCisKIGNsYXNzIElPU1NpbXVsYXRvclBvcnQoUG9ydCk6CiAgICAgcG9ydF9uYW1lID0gImlv cy1zaW11bGF0b3IiCiAKLS0gCjIuMS4xIChBcHBsZSBHaXQtNTEpCgo= 244803 2015-01-16 14:40:57 -0800 2015-01-16 18:20:53 -0800 Patch bug-140476-20150116144104.patch text/plain 12076 jake.nielsen.webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTc4NDUyCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMGM5Nzk2ZDYzM2Q2NzE3NTliZTE5ODI1MjA5ZWIyNjY3 NjZlOTcyMS4uNzU4NzIzMjRmNmU2ZDg4NThmOWQ2ZmYyOTM2NDhjZDc1ZDUwYTQyYiAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4 IEBACisyMDE1LTAxLTE2ICBKYWtlIE5pZWxzZW4gIDxqYWNvYl9uaWVsc2VuQGFwcGxlLmNvbT4K KworICAgICAgICBDcmVhdGUgaU9TLUVXUyBjbGllbnQgcXVldWUKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0MDQ3NgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogRVdTVG9vbHMvc3RhcnQtcXVldWUtbWFj LnNoOgorICAgICAgICBBZGRzIHRoZSBhYmlsaXR5IHRvIHJ1biBzdGFydC1xdWV1ZS1tYWMuc2gg d2l0aCBpb3MtZXdzLiBUaGlzIHJ1bnMKKyAgICAgICAgY29uZmlndXJlLXhjb2RlLWZvci1pb3Mt ZGV2ZWxvcG1lbnQgYmVmb3JlIGtpY2tpbmcgb2ZmIHRoZSBld3MgYm90LgorICAgICAgICAqIFNj cmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9ld3MuanNvbjoKKyAgICAgICAgQWRkcyBpT1Mg RVdTIGNvbmZpZ3VyYXRpb24uCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29u ZmlnL3BvcnRzLnB5OgorICAgICAgICAoRGVwcmVjYXRlZFBvcnQucG9ydCk6CisgICAgICAgIEFk ZHMgSU9TUG9ydCB0byB0aGUgcG9ydCBkaWN0aW9uYXJ5LgorICAgICAgICAoSU9TUG9ydCk6Cisg ICAgICAgIEFkZHMgdGhlIElPU1BvcnQgY2xhc3MuCisgICAgICAgIChJT1NQb3J0LmJ1aWxkX3dl YmtpdF9jb21tYW5kKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5w eToKKyAgICAgICAgKFBvcnRGYWN0b3J5KToKKyAgICAgICAgQWRkcyBpb3MuSU9TUG9ydCB0byB0 aGUgbGlzdCBvZiBwb3J0IGNsYXNzZXMuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9wb3J0 L2lvcy5weToKKyAgICAgICAgKElPU1BvcnQpOgorICAgICAgICBGaWxscyBvdXQgdGhlIElPU1Bv cnQgY2xhc3MgdG8gYWxsb3cgRVdTIHRvIGJ1aWxkIHdlYmtpdCBmb3IgaU9TCisgICAgICAgIGRl dmljZXMuCisgICAgICAgIChJT1NQb3J0LmRldGVybWluZV9mdWxsX3BvcnRfbmFtZSk6CisgICAg ICAgIChJT1NQb3J0Ll9faW5pdF9fKToKKyAgICAgICAgKElPU1BvcnQuX2J1aWxkX2RyaXZlcl9m bGFncyk6CisgICAgICAgIChJT1NQb3J0Lm9wZXJhdGluZ19zeXN0ZW0pOgorICAgICAgICAoSU9T UG9ydC5fcGF0aF90b193ZWJjb3JlX2xpYnJhcnkpOgorICAgICAgICAoSU9TUG9ydC5tYWtlX2Nv bW1hbmQpOgorICAgICAgICAoSU9TUG9ydC5ubV9jb21tYW5kKToKKyAgICAgICAgKElPU1BvcnQu eGNydW5fZmluZCk6CisgICAgICAgIChJT1NQb3J0LmRldmVsb3Blcl9kaXIpOgorICAgICAgICAo SU9TUG9ydC5sb2dnaW5nX3BhdHRlcm5zX3RvX3N0cmlwKToKKyAgICAgICAgKElPU1BvcnQuc3Rk ZXJyX3BhdHRlcm5zX3RvX3N0cmlwKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wv Y29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtLnB5OgorICAgICAgICAoQWJzdHJhY3RFYXJseVdh cm5pbmdTeXN0ZW0ubG9hZF9ld3NfY2xhc3Nlcyk6CisgICAgICAgIEFkZHMgdGhlIGFyY2hpdGVj dHVyZSBvcHRpb24gdG8gdGhlIEVXUyBjb25maWd1cmF0aW9uIGxvYWRpbmcgc3RlcC4KKyAgICAg ICAgKiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzLnB5OgorICAgICAgICAo QWJzdHJhY3RRdWV1ZS5fX2luaXRfXyk6CisgICAgICAgIChQYXRjaFByb2Nlc3NpbmdRdWV1ZS5i ZWdpbl93b3JrX3F1ZXVlKToKKyAgICAgICAgTWFrZXMgc3VyZSB0aGUgYXJjaGl0ZWN0dXJlIG9w dGlvbiBnZXRzIHBhc3NlZCBkb3duIHRvIHRoZSBwb3J0CisgICAgICAgIGluaXRpYWxpemVyLgor CiAyMDE1LTAxLTE0ICBEYW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFwcGxlLmNvbT4KIAogICAgICAg ICBbaU9TXSBydW4td2Via2l0LXRlc3RzIC0taW9zIGhhbmdzIHRyeWluZyB0byBsYXVuY2ggaU9T IFNpbXVsYXRvciB3aXRoIHVuYXZhaWxhYmxlIHJ1bnRpbWUKZGlmZiAtLWdpdCBhL1Rvb2xzL0VX U1Rvb2xzL3N0YXJ0LXF1ZXVlLW1hYy5zaCBiL1Rvb2xzL0VXU1Rvb2xzL3N0YXJ0LXF1ZXVlLW1h Yy5zaAppbmRleCAwNDA2NTFkYmQ5NzEyYWVjYzQ3MjgwZGY0ZjBkODNjZDUzYmU4NGFjLi44NjI0 ZGMyYTU3ZmZlMjZiODIzMTA3NThlYWVhODE1ZDFjZTE5ZTU4IDEwMDc1NQotLS0gYS9Ub29scy9F V1NUb29scy9zdGFydC1xdWV1ZS1tYWMuc2gKKysrIGIvVG9vbHMvRVdTVG9vbHMvc3RhcnQtcXVl dWUtbWFjLnNoCkBAIC0xLDYgKzEsNiBAQAogIyEvYmluL3NoCiAjIENvcHlyaWdodCAoYykgMjAx MiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIyBDb3B5cmlnaHQgKGMpIDIwMTQg QXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorIyBDb3B5cmlnaHQgKGMpIDIwMTQtMjAx NSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAjCiAjIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAogIyBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMgYXJlCkBAIC0zOSwyMCArMzksMjggQEAgUkVTRVRfQUZURVJfSVRFUkFUSU9OPSQzCiBz aGlmdCAzCiBRVUVVRV9QQVJBTVM9IiRAIgogCitFV1NfSE9NRT0vVm9sdW1lcy9EYXRhL0VXUwor V0VCS0lUX0hPTUU9JEVXU19IT01FL1dlYktpdAorCisjIElmIGJ1aWxkaW5nIGZvciBpT1MsIG1h a2Ugc3VyZSB3ZSBydW4gdGhpcyBzY3JpcHQgdG8gbWFrZSBpdCBwb3NzaWJsZSB0byBidWlsZCBm cmFtZXdvcmtzLgoraWYgWyAiJFFVRVVFX05BTUUiID09ICJpb3MtZXdzIiBdOyB0aGVuCisgICAg KGNkICRXRUJLSVRfSE9NRTsgc3VkbyAuL1Rvb2xzL1NjcmlwdHMvY29uZmlndXJlLXhjb2RlLWZv ci1pb3MtZGV2ZWxvcG1lbnQpCitmaQorCiAjIFdlIHJlYm9vdCBldmVyeSBuaWdodCBiZXR3ZWVu IDEgYW5kIDYgdG8gcmVkdWNlIHRoZSBsaWtlbGlob29kIG9mIHVuZXhwZWN0ZWQgcmVib290cyB3 aGlsZSBwZW9wbGUgYXJlIGxvb2tpbmcgaW50byB0aGluZ3MuCiBUSU1FX1RPX1JFQk9PVD0kKCgg JChkYXRlICslcykgKyAzNjAwICogMTIpKQogCiB3aGlsZSBbICRUSU1FX1RPX1JFQk9PVCAtZ3Qg JChkYXRlICslcykgXSB8fCBbICQoZGF0ZSArJUgpIC1sdCAxIF0gfHwgWyAkKGRhdGUgKyVIKSAt Z2UgNiBdOyBkbwotICAgICMgRGVsZXRlIGxvZyBmaWxlcyBvbGRlciB0aGFuIDE0IGRheXMsIG1v dmUgYXNpZGUgdGhlIG1haW4gbWFjLWV3cy5sb2cgZmlsZSB0byBwcmV2ZW50IGl0IGZyb20gZ3Jv d2luZyBleHRyYSBsYXJnZS4KLSAgICBjZCAvVm9sdW1lcy9EYXRhL0VXUy8kUVVFVUVfTkFNRS1s b2dzCisgICAgIyBEZWxldGUgbG9nIGZpbGVzIG9sZGVyIHRoYW4gMTQgZGF5cywgbW92ZSBhc2lk ZSB0aGUgbWFpbiAkUVVFVUVfTkFNRS1ld3MubG9nIGZpbGUgdG8gcHJldmVudCBpdCBmcm9tIGdy b3dpbmcgZXh0cmEgbGFyZ2UuCisgICAgY2QgJEVXU19IT01FLyRRVUVVRV9OQU1FLWxvZ3MKICAg ICBmaW5kIC4gLW10aW1lICsxNCAtZGVsZXRlCiAgICAgaWYgWyAtcyAkUVVFVUVfTkFNRS5sb2cg XTsgdGhlbgogICAgICAgICBtdiAtZiAkUVVFVUVfTkFNRS5sb2cgJHtRVUVVRV9OQU1FfV8kKGRh dGUgKyVZLSVtLSVkXyVILSVtKS5sb2cKICAgICBmaQotICAgIGNkIC9Wb2x1bWVzL0RhdGEvRVdT L1dlYmtpdAorICAgIGNkICRXRUJLSVRfSE9NRQogICAgIAogICAgICMgRGVsZXRlIFdlYktpdEJ1 aWxkIHRvIGZvcmNlIGEgY2xlYW4gYnVpbGQKLSAgICBybSAtcmYgL1ZvbHVtZXMvRGF0YS9FV1Mv V2ViS2l0L1dlYktpdEJ1aWxkCisgICAgcm0gLXJmICRXRUJLSVRfSE9NRS9XZWJLaXRCdWlsZAog ICAgIAogICAgICMgVGhpcyBzb21ld2hhdCBxdWlya3kgc2VxdWVuY2Ugb2Ygc3RlcHMgc2VlbXMg dG8gY2xlYXIgdXAgYWxsIHRoZSBicm9rZW4KICAgICAjIGdpdCBzaXR1YXRpb25zIHdlJ3ZlIGdv dHRlbiBvdXJzZWxmIGludG8gaW4gdGhlIHBhc3QuCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRz L3dlYmtpdHB5L2NvbW1vbi9jb25maWcvZXdzLmpzb24gYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L2NvbW1vbi9jb25maWcvZXdzLmpzb24KaW5kZXggYmZhNGJjNmI4MDhhZGM0ZDZkYmRjMjFhY2Jl ZWMyYmFiMThhZmI2Ni4uMDNlMzhkZGNlYjkwOGRmZjg1MzI2ODMwZDQwYmFjZmQ5YzliMjY0NiAx MDA2NDQKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2V3cy5qc29u CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZpZy9ld3MuanNvbgpAQCAt MTQsNiArMTQsMTAgQEAKICAgICAiV2luIEVXUyI6IHsKICAgICAgICAgInBvcnQiOiAid2luIgog ICAgIH0sCisgICAgImlPUyBFV1MiOiB7CisgICAgICAgICJwb3J0IjogImlvcyIsCisgICAgICAg ICJhcmNoaXRlY3R1cmUiOiAiYXJtdjciCisgICAgfSwKICAgICAiTWFjIEVXUyI6IHsKICAgICAg ICAgInBvcnQiOiAibWFjIiwKICAgICAgICAgIndhdGNoZXJzIjogWwpkaWZmIC0tZ2l0IGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL3BvcnRzLnB5IGIvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9jb21tb24vY29uZmlnL3BvcnRzLnB5CmluZGV4IGI3MGI4M2NjZTVlOGQzM2Vh NmYxMDlhMTNlNDg1MTE3MjQ5YWU2MGIuLjJjYTgxZWJkNzcxNGI2NGNhNTljZGNjNTA5ODUwODg2 NGI1MzIwZmUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29tbW9uL2NvbmZp Zy9wb3J0cy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvcG9y dHMucHkKQEAgLTEsNSArMSw2IEBACiAjIENvcHlyaWdodCAoQykgMjAwOSwgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KICMgQ29weXJpZ2h0IChDKSAyMDEzIE5va2lhIENvcnBvcmF0 aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKS4KKyMgQ29weXJpZ2h0IChDKSAyMDE1IEFw cGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICMKICMgUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAjIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cyBhcmUKQEAgLTYzLDYgKzY0LDcgQEAgY2xhc3MgRGVwcmVjYXRlZFBvcnQob2JqZWN0KToKICAg ICBkZWYgcG9ydChwb3J0X25hbWUpOgogICAgICAgICBwb3J0cyA9IHsKICAgICAgICAgICAgICJn dGstd2syIjogR3RrV0syUG9ydCwKKyAgICAgICAgICAgICJpb3MiOiBJT1NQb3J0LAogICAgICAg ICAgICAgIm1hYyI6IE1hY1BvcnQsCiAgICAgICAgICAgICAibWFjLXdrMiI6IE1hY1dLMlBvcnQs CiAgICAgICAgICAgICAid2luIjogV2luUG9ydCwKQEAgLTExOCw2ICsxMjAsMTUgQEAgY2xhc3Mg RGVwcmVjYXRlZFBvcnQob2JqZWN0KToKICAgICAgICAgcmV0dXJuIHNlbGYuc2NyaXB0X3NoZWxs X2NvbW1hbmQoInJ1bi1iaW5kaW5ncy10ZXN0cyIpCiAKIAorY2xhc3MgSU9TUG9ydChEZXByZWNh dGVkUG9ydCk6CisgICAgcG9ydF9mbGFnX25hbWUgPSAiaW9zIgorCisgICAgZGVmIGJ1aWxkX3dl YmtpdF9jb21tYW5kKHNlbGYsIGJ1aWxkX3N0eWxlPU5vbmUpOgorICAgICAgICBjb21tYW5kID0g c3VwZXIoSU9TUG9ydCwgc2VsZikuYnVpbGRfd2Via2l0X2NvbW1hbmQoYnVpbGRfc3R5bGU9YnVp bGRfc3R5bGUpCisgICAgICAgIGNvbW1hbmQuYXBwZW5kKCItLWRldmljZSIpCisgICAgICAgIHJl dHVybiBjb21tYW5kCisKKwogY2xhc3MgTWFjUG9ydChEZXByZWNhdGVkUG9ydCk6CiAgICAgcG9y dF9mbGFnX25hbWUgPSAibWFjIgogCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvZmFjdG9yeS5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5 CmluZGV4IGRiN2FiNGEzNWVhMTlhYzI5MTAwYWFkYjkwNmZiN2Q1ZTJjNDE5M2YuLmFlZWZhZWNk MTg5MzZkYTg2YTZmNWJlOTVjOTA0MGExYTM5Njg1MDUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9mYWN0b3J5LnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv cG9ydC9mYWN0b3J5LnB5CkBAIC04NCw2ICs4NCw3IEBAIGNsYXNzIFBvcnRGYWN0b3J5KG9iamVj dCk6CiAgICAgICAgICdlZmwuRWZsUG9ydCcsCiAgICAgICAgICdndGsuR3RrUG9ydCcsCiAgICAg ICAgICdpb3MuSU9TU2ltdWxhdG9yUG9ydCcsCisgICAgICAgICdpb3MuSU9TUG9ydCcsCiAgICAg ICAgICdtYWMuTWFjUG9ydCcsCiAgICAgICAgICdtb2NrX2RydC5Nb2NrRFJUUG9ydCcsCiAgICAg ICAgICd0ZXN0LlRlc3RQb3J0JywKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkv cG9ydC9pb3MucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9zLnB5CmluZGV4IDlh NjA1MzI3MTQ1YThhMDc2NGJmODQyN2I0ZjE4Y2NiOTYwNGZjYWMuLmMwZmNlM2NmMmIwM2U0ODNi MTNiYjAyODJiYTJiODZhNjU3N2QzZGIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcG9ydC9pb3MucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2lvcy5weQpA QCAtMSw0ICsxLDQgQEAKLSMgQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyMgQ29weXJpZ2h0IChDKSAyMDE0LTIwMTUgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgogIwogIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCkBAIC0zMSw2ICszMSw3 IEBAIGltcG9ydCBzdWJwcm9jZXNzCiBmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5tb2RlbHMu dGVzdF9jb25maWd1cmF0aW9uIGltcG9ydCBUZXN0Q29uZmlndXJhdGlvbgogZnJvbSB3ZWJraXRw eS5jb21tb24uc3lzdGVtLmNyYXNobG9ncyBpbXBvcnQgQ3Jhc2hMb2dzCiBmcm9tIHdlYmtpdHB5 LmNvbW1vbi5zeXN0ZW0uZXhlY3V0aXZlIGltcG9ydCBTY3JpcHRFcnJvcgorZnJvbSB3ZWJraXRw eS5wb3J0LmFwcGxlIGltcG9ydCBBcHBsZVBvcnQKIGZyb20gd2Via2l0cHkucG9ydCBpbXBvcnQg ZHJpdmVyLCBpbWFnZV9kaWZmCiBmcm9tIHdlYmtpdHB5LnBvcnQuYmFzZSBpbXBvcnQgUG9ydAog ZnJvbSB3ZWJraXRweS5wb3J0LmxlYWtkZXRlY3RvciBpbXBvcnQgTGVha0RldGVjdG9yCkBAIC00 MSw2ICs0Miw2OSBAQCBmcm9tIHdlYmtpdHB5Lnhjb2RlIGltcG9ydCBzaW11bGF0b3IKIF9sb2cg PSBsb2dnaW5nLmdldExvZ2dlcihfX25hbWVfXykKIAogCitjbGFzcyBJT1NQb3J0KEFwcGxlUG9y dCk6CisgICAgcG9ydF9uYW1lID0gImlvcyIKKworICAgIEFSQ0hJVEVDVFVSRVMgPSBbJ2FybXY3 JywgJ2FybXY3cycsICdhcm02NCddCisgICAgVkVSU0lPTl9GQUxMQkFDS19PUkRFUiA9IFsnaW9z LTgnXQorCisgICAgQGNsYXNzbWV0aG9kCisgICAgZGVmIGRldGVybWluZV9mdWxsX3BvcnRfbmFt ZShjbHMsIGhvc3QsIG9wdGlvbnMsIHBvcnRfbmFtZSk6CisgICAgICAgIGlmIHBvcnRfbmFtZSA9 PSBjbHMucG9ydF9uYW1lOgorICAgICAgICAgICAgc2RrX2NvbW1hbmRfcHJvY2VzcyA9IHN1YnBy b2Nlc3MuUG9wZW4oJ3hjcnVuIC0tc2RrIGlwaG9uZW9zIC0tc2hvdy1zZGstdmVyc2lvbicsIHN0 ZG91dD1zdWJwcm9jZXNzLlBJUEUsIHNoZWxsPVRydWUpCisgICAgICAgICAgICBzZGtfY29tbWFu ZF9zdGRvdXQgPSBzZGtfY29tbWFuZF9wcm9jZXNzLmNvbW11bmljYXRlKClbMF0uc3RyaXAoKQor CisgICAgICAgICAgICBhc3NlcnQgc2RrX2NvbW1hbmRfc3Rkb3V0LCAieGNvZGUgaXMgbm90IGlu c3RhbGxlZCwgYW5kIGhlbmNlIHdlIGNhbm5vdCBjb25zdHJ1Y3QgYW4gaU9TIHBvcnQgb2JqZWN0 ISIKKworICAgICAgICAgICAgcG9ydF9uYW1lID0gcG9ydF9uYW1lICsgJy0nICsgc2RrX2NvbW1h bmRfc3Rkb3V0WzBdCisKKyAgICAgICAgcmV0dXJuIHBvcnRfbmFtZQorCisgICAgZGVmIF9faW5p dF9fKHNlbGYsICphcmdzLCAqKmt3YXJncyk6CisgICAgICAgIHN1cGVyKElPU1BvcnQsIHNlbGYp Ll9faW5pdF9fKCphcmdzLCAqKmt3YXJncykKKworICAgICAgICBzZWxmLl9hcmNoaXRlY3R1cmUg PSBzZWxmLmdldF9vcHRpb24oJ2FyY2hpdGVjdHVyZScpCisKKyAgICAgICAgaWYgbm90IHNlbGYu X2FyY2hpdGVjdHVyZToKKyAgICAgICAgICAgIHNlbGYuX2FyY2hpdGVjdHVyZSA9ICdhcm12NycK KworICAgICAgICBzZWxmLl90ZXN0aW5nX2RldmljZSA9IE5vbmUKKworICAgIGRlZiBfYnVpbGRf ZHJpdmVyX2ZsYWdzKHNlbGYpOgorICAgICAgICBzZGsgPSBbJy0tc2RrJywgJ2lwaG9uZW9zJywg J0FSQ0hTPSVzJyAlIHNlbGYuX2FyY2hpdGVjdHVyZV0KKyAgICAgICAgcmV0dXJuIHNkaworCisg ICAgZGVmIG9wZXJhdGluZ19zeXN0ZW0oc2VsZik6CisgICAgICAgIHJldHVybiAnaW9zJworCisg ICAgZGVmIF9wYXRoX3RvX3dlYmNvcmVfbGlicmFyeShzZWxmKToKKyAgICAgICAgcmV0dXJuIHNl bGYuX2J1aWxkX3BhdGgoJ1dlYkNvcmUuZnJhbWV3b3JrL1dlYkNvcmUnKQorCisgICAgZGVmIG1h a2VfY29tbWFuZChzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYueGNydW5fZmluZCgnbWFrZScs ICcvdXNyL2Jpbi9tYWtlJykKKworICAgIGRlZiBubV9jb21tYW5kKHNlbGYpOgorICAgICAgICBy ZXR1cm4gc2VsZi54Y3J1bl9maW5kKCdubScpCisKKyAgICBkZWYgeGNydW5fZmluZChzZWxmLCBj b21tYW5kLCBmYWxsYmFjaz1Ob25lKToKKyAgICAgICAgZmFsbGJhY2sgPSBmYWxsYmFjayBvciBj b21tYW5kCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHJldHVybiBzZWxmLl9leGVjdXRpdmUu cnVuX2NvbW1hbmQoWyd4Y3J1bicsICctLXNkaycsICdpcGhvbmVvcycsICctZmluZCcsIGNvbW1h bmRdKS5yc3RyaXAoKQorICAgICAgICBleGNlcHQgU2NyaXB0RXJyb3I6CisgICAgICAgICAgICBf bG9nLndhcm4oInhjcnVuIGZhaWxlZDsgZmFsbGluZyBiYWNrIHRvICclcycuIiAlIGZhbGxiYWNr KQorICAgICAgICAgICAgcmV0dXJuIGZhbGxiYWNrCisKKyAgICBAcHJvcGVydHkKKyAgICBkZWYg ZGV2ZWxvcGVyX2RpcihzZWxmKToKKyAgICAgICAgcmV0dXJuIHNlbGYuX2V4ZWN1dGl2ZS5ydW5f Y29tbWFuZChbJ3hjb2RlLXNlbGVjdCcsICctLXByaW50LXBhdGgnXSkucnN0cmlwKCkKKworICAg IGRlZiBsb2dnaW5nX3BhdHRlcm5zX3RvX3N0cmlwKHNlbGYpOgorICAgICAgICByZXR1cm4gW10K KworICAgIGRlZiBzdGRlcnJfcGF0dGVybnNfdG9fc3RyaXAoc2VsZik6CisgICAgICAgIHJldHVy biBbXQorCisKIGNsYXNzIElPU1NpbXVsYXRvclBvcnQoUG9ydCk6CiAgICAgcG9ydF9uYW1lID0g Imlvcy1zaW11bGF0b3IiCiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9v bC9jb21tYW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0ucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3Rvb2wvY29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtLnB5CmluZGV4IDM0YjY3YzcxMmQ1NTBh NDg2MGYzYzE3YzVlYmMyNGRkMDRjMWJiMzkuLjA4YjkwNDFiMGViMTdjMDdiNDgyZDYwMjRiMDU0 OWU2MTFjOTU2MDIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21t YW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0ucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90 b29sL2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbS5weQpAQCAtMTUzLDYgKzE1Myw3IEBAIGNs YXNzIEFic3RyYWN0RWFybHlXYXJuaW5nU3lzdGVtKEFic3RyYWN0UmV2aWV3UXVldWUsIEVhcmx5 V2FybmluZ1N5c3RlbVRhc2tEZWxlCiAgICAgICAgICAgICBjbGFzc2VzLmFwcGVuZCh0eXBlKHN0 cihuYW1lLnJlcGxhY2UoJyAnLCAnJykpLCAoQWJzdHJhY3RFYXJseVdhcm5pbmdTeXN0ZW0sKSwg ewogICAgICAgICAgICAgICAgICduYW1lJzogY29uZmlnWydwb3J0J10gKyAnLWV3cycsCiAgICAg ICAgICAgICAgICAgJ3BvcnRfbmFtZSc6IGNvbmZpZ1sncG9ydCddLAorICAgICAgICAgICAgICAg ICdhcmNoaXRlY3R1cmUnOiBjb25maWcuZ2V0KCdhcmNoaXRlY3R1cmUnLCBOb25lKSwKICAgICAg ICAgICAgICAgICAnd2F0Y2hlcnMnOiBjb25maWcuZ2V0KCd3YXRjaGVycycsIFtdKSwKICAgICAg ICAgICAgICAgICAncnVuX3Rlc3RzJzogY29uZmlnLmdldCgncnVuVGVzdHMnLCBjbHMucnVuX3Rl c3RzKSwKICAgICAgICAgICAgIH0pKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRw eS90b29sL2NvbW1hbmRzL3F1ZXVlcy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9j b21tYW5kcy9xdWV1ZXMucHkKaW5kZXggNmJlODUzZmNmYjU1YTBmYjJiODIxZTA4ZmY2YzBjZGJj YTA4NWVjMy4uNjRhM2RlYWIyNWY1ODJlNTUwZWNkYTBlMTRhMmZiYmJmMGI1ODhjNCAxMDA2NDQK LS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL3F1ZXVlcy5weQorKysg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzLnB5CkBAIC0yOSw2 ICsyOSw3IEBACiAKIGltcG9ydCBjb2RlY3MKIGltcG9ydCBsb2dnaW5nCitpbXBvcnQgb3B0cGFy c2UKIGltcG9ydCBvcwogaW1wb3J0IHJlCiBpbXBvcnQgc3lzCkBAIC03NCw2ICs3NSw3IEBAIGNs YXNzIEFic3RyYWN0UXVldWUoQ29tbWFuZCwgUXVldWVFbmdpbmVEZWxlZ2F0ZSk6CiAgICAgICAg IHNlbGYuaGVscF90ZXh0ID0gIlJ1biB0aGUgJXMiICUgc2VsZi5uYW1lCiAgICAgICAgIENvbW1h bmQuX19pbml0X18oc2VsZiwgb3B0aW9ucz1vcHRpb25zX2xpc3QpCiAgICAgICAgIHNlbGYuX2l0 ZXJhdGlvbl9jb3VudCA9IDAKKyAgICAgICAgc2VsZi5hcmNoaXRlY3R1cmUgPSBOb25lCiAKICAg ICBkZWYgX2NjX3dhdGNoZXJzKHNlbGYsIGJ1Z19pZCk6CiAgICAgICAgIHRyeToKQEAgLTI3NSw3 ICsyNzcsMTAgQEAgY2xhc3MgUGF0Y2hQcm9jZXNzaW5nUXVldWUoQWJzdHJhY3RQYXRjaFF1ZXVl KToKICAgICAgICAgc2VsZi5fZGVwcmVjYXRlZF9wb3J0ID0gRGVwcmVjYXRlZFBvcnQucG9ydChz ZWxmLnBvcnRfbmFtZSkKICAgICAgICAgIyBGSVhNRTogVGhpcyB2aW9sYXRlcyBhYnN0cmFjdGlv bgogICAgICAgICBzZWxmLl90b29sLl9kZXByZWNhdGVkX3BvcnQgPSBzZWxmLl9kZXByZWNhdGVk X3BvcnQKLSAgICAgICAgc2VsZi5fcG9ydCA9IHNlbGYuX3Rvb2wucG9ydF9mYWN0b3J5LmdldChz ZWxmLl9uZXdfcG9ydF9uYW1lX2Zyb21fb2xkKHNlbGYucG9ydF9uYW1lLCBzZWxmLl90b29sLnBs YXRmb3JtKSkKKyAgICAgICAgcG9ydF9vcHRpb25zID0gb3B0cGFyc2UuVmFsdWVzKCkKKyAgICAg ICAgaWYgc2VsZi5hcmNoaXRlY3R1cmU6CisgICAgICAgICAgICBzZXRhdHRyKHBvcnRfb3B0aW9u cywgJ2FyY2hpdGVjdHVyZScsIHNlbGYuYXJjaGl0ZWN0dXJlKQorICAgICAgICBzZWxmLl9wb3J0 ID0gc2VsZi5fdG9vbC5wb3J0X2ZhY3RvcnkuZ2V0KHNlbGYuX25ld19wb3J0X25hbWVfZnJvbV9v bGQoc2VsZi5wb3J0X25hbWUsIHNlbGYuX3Rvb2wucGxhdGZvcm0pLCBwb3J0X29wdGlvbnMpCiAK ICAgICBkZWYgX3VwbG9hZF9yZXN1bHRzX2FyY2hpdmVfZm9yX3BhdGNoKHNlbGYsIHBhdGNoLCBy ZXN1bHRzX2FyY2hpdmVfemlwKToKICAgICAgICAgaWYgbm90IHNlbGYuX3BvcnQ6Cg== 244828 2015-01-16 18:20:55 -0800 2015-01-16 19:26:07 -0800 Patch bug-140476-20150116182102.patch text/plain 20083 jake.nielsen.webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTc4NDUyCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMGM5Nzk2ZDYzM2Q2NzE3NTliZTE5ODI1MjA5ZWIyNjY3 NjZlOTcyMS4uNDQyNmMwM2UzZWM2NDliYWI4ZTUwNTA5YWM2NzgwZWVkODg5MjgzMyAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDYy IEBACisyMDE1LTAxLTE2ICBKYWtlIE5pZWxzZW4gIDxqYWNvYl9uaWVsc2VuQGFwcGxlLmNvbT4K KworICAgICAgICBDcmVhdGUgaU9TLUVXUyBjbGllbnQgcXVldWUKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0MDQ3NgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogRVdTVG9vbHMvc3RhcnQtcXVldWUtbWFj LnNoOgorICAgICAgICBBZGRzIGNhbGwgdG8gY29uZmlndXJlLXhjb2RlLWZvci1pb3MtZGV2ZWxv cG1lbnQgZm9yIGlPUyBFV1MuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29u ZmlnL2V3cy5qc29uOgorICAgICAgICBBZGRzIHRoZSBpT1MgRVdTIGNvbmZpZyBlbnRyeS4KKyAg ICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvcG9ydHMucHk6CisgICAgICAg IChEZXByZWNhdGVkUG9ydC5wb3J0KToKKyAgICAgICAgQWRkcyBJT1NQb3J0IHRvIHRoZSBwb3J0 IG1hcC4KKyAgICAgICAgKElPU1BvcnQpOgorICAgICAgICAoSU9TUG9ydC5idWlsZF93ZWJraXRf Y29tbWFuZCk6CisgICAgICAgIEFkZHMgLS1zZGs9aXBob25lb3MgdG8gdGhlIHdlYmtpdCBidWls ZCBjb21tYW5kLgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9iYXNlLnB5OgorICAg ICAgICAoUG9ydC5hcmNoaXRlY3R1cmUpOgorICAgICAgICBBZGRzIGFuIGFjY2Vzc29yIGZvciB0 aGUgYXJjaGl0ZWN0dXJlIG1lbWJlciB2YXJpYWJsZS4KKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3BvcnQvZmFjdG9yeS5weToKKyAgICAgICAgKFBvcnRGYWN0b3J5KToKKyAgICAgICAgQWRk cyBJT1NQb3J0IHRvIHRoZSBwb3J0IGNsYXNzIGxpc3QuCisgICAgICAgICogU2NyaXB0cy93ZWJr aXRweS9wb3J0L2lvcy5weToKKyAgICAgICAgQWRkcyB0aGUgSU9TUG9ydCB0byBlbmNhcHN1bGF0 ZSBpT1Mtc3BlY2lmaWMgdGhpbmdzLgorICAgICAgICAoSU9TUG9ydCk6CisgICAgICAgIChJT1NQ b3J0LmRldGVybWluZV9mdWxsX3BvcnRfbmFtZSk6CisgICAgICAgIChJT1NQb3J0Ll9faW5pdF9f KToKKyAgICAgICAgKElPU1BvcnQuX2J1aWxkX2RyaXZlcl9mbGFncyk6CisgICAgICAgIChJT1NQ b3J0Lm9wZXJhdGluZ19zeXN0ZW0pOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9j b21tYW5kcy9kb3dubG9hZF91bml0dGVzdC5weToKKyAgICAgICAgQWRkcyB0aGUgYXJjaGV0ZWN0 dXJlIG9wdGlvbiB0byB0aGUgbW9jayBvcHRpb25zLgorICAgICAgICAoRG93bmxvYWRDb21tYW5k c1Rlc3QuX2RlZmF1bHRfb3B0aW9ucyk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29s L2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbS5weToKKyAgICAgICAgQXBwZW5kcyB0aGUgYXJj aGV0ZWN0dXJlIG9wdGlvbiBpbnRvIGNhbGxzIHRvIHdlYmtpdC1wYXRjaC4KKyAgICAgICAgKEFi c3RyYWN0RWFybHlXYXJuaW5nU3lzdGVtLnJldmlld19wYXRjaCk6CisgICAgICAgIChBYnN0cmFj dEVhcmx5V2FybmluZ1N5c3RlbS5ydW5fY29tbWFuZCk6CisgICAgICAgIChBYnN0cmFjdEVhcmx5 V2FybmluZ1N5c3RlbS5sb2FkX2V3c19jbGFzc2VzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3Rvb2wvY29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtX3VuaXR0ZXN0LnB5OgorICAgICAg ICBBZGRzIGxvZ2ljIHRvIHNvb3RoZSB0aGUgdW5pdHRlc3Qgbm93IHRoYXQgLS1hcmNoaXRlY3R1 cmUgaXMgYmVpbmcKKyAgICAgICAgdGhyb3duIGFyb3VuZCBldmVyeXdoZXJlLgorICAgICAgICAo RWFybHlXYXJuaW5nU3lzdGVtVGVzdC5fZGVmYXVsdF9leHBlY3RlZF9sb2dzKToKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzLnB5OgorICAgICAgICBBZGRz IGdsdWUgY29kZSB0byBmZXJyeSB0aGUgLS1hcmNoaXRlY3R1cmUgb3B0aW9uIGFyb3VuZC4KKyAg ICAgICAgKEFic3RyYWN0UXVldWUuX19pbml0X18pOgorICAgICAgICAoUGF0Y2hQcm9jZXNzaW5n UXVldWUuYmVnaW5fd29ya19xdWV1ZSk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29s L3N0ZXBzL2Fic3RyYWN0c3RlcC5weToKKyAgICAgICAgQWRkcyB0aGUgYXJjaGV0ZWN0dXJlIG9w dGlvbiB0byBhbGwgQWJzdHJhY3RTdGVwcyBzbyB0aGF0CisgICAgICAgIEVhcmx5V2FybmluZ1N5 c3RlbSBkb2Vzbid0IHN0YXJ0IHNob3ZpbmcgLS1hcmNoaXRlY3R1cmUgaW50bworICAgICAgICB1 bnN1c3BlY3RpbmcgY29tbWFuZHMuCisgICAgICAgIChBYnN0cmFjdFN0ZXAub3B0aW9ucyk6Cisg ICAgICAgICogU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL2J1aWxkLnB5OgorICAgICAgICBU cmFuc2xhdGVzIHRoZSAtLWFyY2hpdGVjdHVyZSBvcHRpb24gaW50byBhbiBBUkNIUz0gZm9ybWF0 IHRvIHBhc3MgdG8KKyAgICAgICAgYnVpbGQtd2Via2l0LgorICAgICAgICAoQnVpbGQuYnVpbGQp OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9vcHRpb25zLnB5OgorICAg ICAgICBBZGRzIGEgZGVmaW5pdGlvbiBmb3IgdGhlIC0tYXJjaGl0ZWN0dXJlIG9wdGlvbi4KKyAg ICAgICAgKE9wdGlvbnMpOgorCiAyMDE1LTAxLTE0ICBEYW5pZWwgQmF0ZXMgIDxkYWJhdGVzQGFw cGxlLmNvbT4KIAogICAgICAgICBbaU9TXSBydW4td2Via2l0LXRlc3RzIC0taW9zIGhhbmdzIHRy eWluZyB0byBsYXVuY2ggaU9TIFNpbXVsYXRvciB3aXRoIHVuYXZhaWxhYmxlIHJ1bnRpbWUKZGlm ZiAtLWdpdCBhL1Rvb2xzL0VXU1Rvb2xzL3N0YXJ0LXF1ZXVlLW1hYy5zaCBiL1Rvb2xzL0VXU1Rv b2xzL3N0YXJ0LXF1ZXVlLW1hYy5zaAppbmRleCAwNDA2NTFkYmQ5NzEyYWVjYzQ3MjgwZGY0ZjBk ODNjZDUzYmU4NGFjLi44ODI4NTEzNjdiY2QzNDE1YjY0YmUwYmFmNmQwMGU4MDNhZGMyOTIxIDEw MDc1NQotLS0gYS9Ub29scy9FV1NUb29scy9zdGFydC1xdWV1ZS1tYWMuc2gKKysrIGIvVG9vbHMv RVdTVG9vbHMvc3RhcnQtcXVldWUtbWFjLnNoCkBAIC0xLDYgKzEsNiBAQAogIyEvYmluL3NoCiAj IENvcHlyaWdodCAoYykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgotIyBD b3B5cmlnaHQgKGMpIDIwMTQgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorIyBDb3B5 cmlnaHQgKGMpIDIwMTQsIDIwMTUgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogIwog IyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKICMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQpAQCAtMzksMjAgKzM5LDI4IEBAIFJFU0VUX0FG VEVSX0lURVJBVElPTj0kMwogc2hpZnQgMwogUVVFVUVfUEFSQU1TPSIkQCIKIAorRVdTX0hPTUU9 L1ZvbHVtZXMvRGF0YS9FV1MKK1dFQktJVF9IT01FPSRFV1NfSE9NRS9XZWJLaXQKKworIyBJZiBi dWlsZGluZyBmb3IgaU9TLCBtYWtlIHN1cmUgd2UgcnVuIHRoaXMgc2NyaXB0IHRvIG1ha2UgaXQg cG9zc2libGUgdG8gYnVpbGQgZnJhbWV3b3Jrcy4KK2lmIFsgIiRRVUVVRV9OQU1FIiA9PSAiaW9z LWV3cyIgXTsgdGhlbgorICAgIChjZCAkV0VCS0lUX0hPTUU7IHN1ZG8gLi9Ub29scy9TY3JpcHRz L2NvbmZpZ3VyZS14Y29kZS1mb3ItaW9zLWRldmVsb3BtZW50KQorZmkKKwogIyBXZSByZWJvb3Qg ZXZlcnkgbmlnaHQgYmV0d2VlbiAxIGFuZCA2IHRvIHJlZHVjZSB0aGUgbGlrZWxpaG9vZCBvZiB1 bmV4cGVjdGVkIHJlYm9vdHMgd2hpbGUgcGVvcGxlIGFyZSBsb29raW5nIGludG8gdGhpbmdzLgog VElNRV9UT19SRUJPT1Q9JCgoICQoZGF0ZSArJXMpICsgMzYwMCAqIDEyKSkKIAogd2hpbGUgWyAk VElNRV9UT19SRUJPT1QgLWd0ICQoZGF0ZSArJXMpIF0gfHwgWyAkKGRhdGUgKyVIKSAtbHQgMSBd IHx8IFsgJChkYXRlICslSCkgLWdlIDYgXTsgZG8KLSAgICAjIERlbGV0ZSBsb2cgZmlsZXMgb2xk ZXIgdGhhbiAxNCBkYXlzLCBtb3ZlIGFzaWRlIHRoZSBtYWluIG1hYy1ld3MubG9nIGZpbGUgdG8g cHJldmVudCBpdCBmcm9tIGdyb3dpbmcgZXh0cmEgbGFyZ2UuCi0gICAgY2QgL1ZvbHVtZXMvRGF0 YS9FV1MvJFFVRVVFX05BTUUtbG9ncworICAgICMgRGVsZXRlIGxvZyBmaWxlcyBvbGRlciB0aGFu IDE0IGRheXMsIG1vdmUgYXNpZGUgdGhlIG1haW4gJFFVRVVFX05BTUUtZXdzLmxvZyBmaWxlIHRv IHByZXZlbnQgaXQgZnJvbSBncm93aW5nIGV4dHJhIGxhcmdlLgorICAgIGNkICRFV1NfSE9NRS8k UVVFVUVfTkFNRS1sb2dzCiAgICAgZmluZCAuIC1tdGltZSArMTQgLWRlbGV0ZQogICAgIGlmIFsg LXMgJFFVRVVFX05BTUUubG9nIF07IHRoZW4KICAgICAgICAgbXYgLWYgJFFVRVVFX05BTUUubG9n ICR7UVVFVUVfTkFNRX1fJChkYXRlICslWS0lbS0lZF8lSC0lbSkubG9nCiAgICAgZmkKLSAgICBj ZCAvVm9sdW1lcy9EYXRhL0VXUy9XZWJraXQKKyAgICBjZCAkV0VCS0lUX0hPTUUKICAgICAKICAg ICAjIERlbGV0ZSBXZWJLaXRCdWlsZCB0byBmb3JjZSBhIGNsZWFuIGJ1aWxkCi0gICAgcm0gLXJm IC9Wb2x1bWVzL0RhdGEvRVdTL1dlYktpdC9XZWJLaXRCdWlsZAorICAgIHJtIC1yZiAkV0VCS0lU X0hPTUUvV2ViS2l0QnVpbGQKICAgICAKICAgICAjIFRoaXMgc29tZXdoYXQgcXVpcmt5IHNlcXVl bmNlIG9mIHN0ZXBzIHNlZW1zIHRvIGNsZWFyIHVwIGFsbCB0aGUgYnJva2VuCiAgICAgIyBnaXQg c2l0dWF0aW9ucyB3ZSd2ZSBnb3R0ZW4gb3Vyc2VsZiBpbnRvIGluIHRoZSBwYXN0LgpkaWZmIC0t Z2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2V3cy5qc29uIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL2V3cy5qc29uCmluZGV4IGJmYTRiYzZi ODA4YWRjNGQ2ZGJkYzIxYWNiZWVjMmJhYjE4YWZiNjYuLmIyZWNkYTNiNGYwNTE4NzExNjlhZDg5 ZmNlOWI3ZDE5ZGZjMjFmNzYgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvY29t bW9uL2NvbmZpZy9ld3MuanNvbgorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9j b25maWcvZXdzLmpzb24KQEAgLTE0LDYgKzE0LDEwIEBACiAgICAgIldpbiBFV1MiOiB7CiAgICAg ICAgICJwb3J0IjogIndpbiIKICAgICB9LAorICAgICJpT1MgRVdTIjogeworICAgICAgICAicG9y dCI6ICJpb3MtZGV2aWNlIiwKKyAgICAgICAgImFyY2hpdGVjdHVyZSI6ICJhcm12NyIKKyAgICB9 LAogICAgICJNYWMgRVdTIjogewogICAgICAgICAicG9ydCI6ICJtYWMiLAogICAgICAgICAid2F0 Y2hlcnMiOiBbCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25m aWcvcG9ydHMucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2NvbW1vbi9jb25maWcvcG9ydHMu cHkKaW5kZXggYjcwYjgzY2NlNWU4ZDMzZWE2ZjEwOWExM2U0ODUxMTcyNDlhZTYwYi4uMDQyZTg5 NmJiNzhmZDAxZTVmZGM2MDMwYzRlNWJkMmYzNWI3MzlhZSAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9jb21tb24vY29uZmlnL3BvcnRzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvY29tbW9uL2NvbmZpZy9wb3J0cy5weQpAQCAtMSw1ICsxLDYgQEAKICMgQ29weXJp Z2h0IChDKSAyMDA5LCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogIyBDb3B5cmln aHQgKEMpIDIwMTMgTm9raWEgQ29ycG9yYXRpb24gYW5kL29yIGl0cyBzdWJzaWRpYXJ5KC1pZXMp LgorIyBDb3B5cmlnaHQgKEMpIDIwMTUgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgog IwogIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKICMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQpAQCAtNjMsNiArNjQsNyBAQCBjbGFzcyBE ZXByZWNhdGVkUG9ydChvYmplY3QpOgogICAgIGRlZiBwb3J0KHBvcnRfbmFtZSk6CiAgICAgICAg IHBvcnRzID0gewogICAgICAgICAgICAgImd0ay13azIiOiBHdGtXSzJQb3J0LAorICAgICAgICAg ICAgImlvcy1kZXZpY2UiOiBJT1NQb3J0LAogICAgICAgICAgICAgIm1hYyI6IE1hY1BvcnQsCiAg ICAgICAgICAgICAibWFjLXdrMiI6IE1hY1dLMlBvcnQsCiAgICAgICAgICAgICAid2luIjogV2lu UG9ydCwKQEAgLTExOCw2ICsxMjAsMTUgQEAgY2xhc3MgRGVwcmVjYXRlZFBvcnQob2JqZWN0KToK ICAgICAgICAgcmV0dXJuIHNlbGYuc2NyaXB0X3NoZWxsX2NvbW1hbmQoInJ1bi1iaW5kaW5ncy10 ZXN0cyIpCiAKIAorY2xhc3MgSU9TUG9ydChEZXByZWNhdGVkUG9ydCk6CisgICAgcG9ydF9mbGFn X25hbWUgPSAiaW9zLWRldmljZSIKKworICAgIGRlZiBidWlsZF93ZWJraXRfY29tbWFuZChzZWxm LCBidWlsZF9zdHlsZT1Ob25lKToKKyAgICAgICAgY29tbWFuZCA9IHN1cGVyKElPU1BvcnQsIHNl bGYpLmJ1aWxkX3dlYmtpdF9jb21tYW5kKGJ1aWxkX3N0eWxlPWJ1aWxkX3N0eWxlKQorICAgICAg ICBjb21tYW5kLmFwcGVuZCgiLS1zZGs9aXBob25lb3MiKQorICAgICAgICByZXR1cm4gY29tbWFu ZAorCisKIGNsYXNzIE1hY1BvcnQoRGVwcmVjYXRlZFBvcnQpOgogICAgIHBvcnRfZmxhZ19uYW1l ID0gIm1hYyIKIApkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2Jhc2Uu cHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQppbmRleCBjOWU4NDlkNTQ0 ZDQ0MDE5YzkyNDRiMmVkZjRjNTlkMWQ3OGQ2MTA5Li5hNmQ3MzMwYWFlOGNiYzgxMjE5MjA0NDcz YzY4YTkzMWUyMThmZWRmIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQv YmFzZS5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQpAQCAtMTI3 LDYgKzEyNyw5IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgc2VsZi5fcm9vdF93YXNf c2V0ID0gaGFzYXR0cihvcHRpb25zLCAncm9vdCcpIGFuZCBvcHRpb25zLnJvb3QKICAgICAgICAg c2VsZi5famhidWlsZF93cmFwcGVyID0gW10KIAorICAgIGRlZiBhcmNoaXRlY3R1cmUoc2VsZik6 CisgICAgICAgIHJldHVybiBzZWxmLl9hcmNoaXRlY3R1cmUKKwogICAgIGRlZiBhZGRpdGlvbmFs X2RydF9mbGFnKHNlbGYpOgogICAgICAgICByZXR1cm4gW10KIApkaWZmIC0tZ2l0IGEvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9wb3J0L2ZhY3RvcnkucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5 L3BvcnQvZmFjdG9yeS5weQppbmRleCBkYjdhYjRhMzVlYTE5YWMyOTEwMGFhZGI5MDZmYjdkNWUy YzQxOTNmLi41NDIzNzljYjU4ZDM1ZWFlNjAzYmExYWUwOTRmZjRkYThiZjYxZDdkIDEwMDY0NAot LS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQorKysgYi9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L3BvcnQvZmFjdG9yeS5weQpAQCAtODMsNiArODMsNyBAQCBjbGFzcyBQ b3J0RmFjdG9yeShvYmplY3QpOgogICAgIFBPUlRfQ0xBU1NFUyA9ICgKICAgICAgICAgJ2VmbC5F ZmxQb3J0JywKICAgICAgICAgJ2d0ay5HdGtQb3J0JywKKyAgICAgICAgJ2lvcy5JT1NQb3J0JywK ICAgICAgICAgJ2lvcy5JT1NTaW11bGF0b3JQb3J0JywKICAgICAgICAgJ21hYy5NYWNQb3J0JywK ICAgICAgICAgJ21vY2tfZHJ0Lk1vY2tEUlRQb3J0JywKZGlmZiAtLWdpdCBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvcG9ydC9pb3MucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvaW9z LnB5CmluZGV4IDlhNjA1MzI3MTQ1YThhMDc2NGJmODQyN2I0ZjE4Y2NiOTYwNGZjYWMuLmRmYTIz NzIzZWVmNTRmNTJjMDE2OTkwMTBhYTcxOGIyN2M1OTZjMzAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Nj cmlwdHMvd2Via2l0cHkvcG9ydC9pb3MucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9w b3J0L2lvcy5weQpAQCAtMSw0ICsxLDQgQEAKLSMgQ29weXJpZ2h0IChDKSAyMDE0IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMgQ29weXJpZ2h0IChDKSAyMDE0LCAyMDE1IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICMKICMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAjIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpA QCAtMzEsNiArMzEsNyBAQCBpbXBvcnQgc3VicHJvY2VzcwogZnJvbSB3ZWJraXRweS5sYXlvdXRf dGVzdHMubW9kZWxzLnRlc3RfY29uZmlndXJhdGlvbiBpbXBvcnQgVGVzdENvbmZpZ3VyYXRpb24K IGZyb20gd2Via2l0cHkuY29tbW9uLnN5c3RlbS5jcmFzaGxvZ3MgaW1wb3J0IENyYXNoTG9ncwog ZnJvbSB3ZWJraXRweS5jb21tb24uc3lzdGVtLmV4ZWN1dGl2ZSBpbXBvcnQgU2NyaXB0RXJyb3IK K2Zyb20gd2Via2l0cHkucG9ydC5hcHBsZSBpbXBvcnQgQXBwbGVQb3J0CiBmcm9tIHdlYmtpdHB5 LnBvcnQgaW1wb3J0IGRyaXZlciwgaW1hZ2VfZGlmZgogZnJvbSB3ZWJraXRweS5wb3J0LmJhc2Ug aW1wb3J0IFBvcnQKIGZyb20gd2Via2l0cHkucG9ydC5sZWFrZGV0ZWN0b3IgaW1wb3J0IExlYWtE ZXRlY3RvcgpAQCAtNDEsNiArNDIsNDIgQEAgZnJvbSB3ZWJraXRweS54Y29kZSBpbXBvcnQgc2lt dWxhdG9yCiBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoX19uYW1lX18pCiAKIAorY2xhc3MgSU9T UG9ydChBcHBsZVBvcnQpOgorICAgIHBvcnRfbmFtZSA9ICJpb3MtZGV2aWNlIgorCisgICAgQVJD SElURUNUVVJFUyA9IFsnYXJtdjcnLCAnYXJtdjdzJywgJ2FybTY0J10KKyAgICBWRVJTSU9OX0ZB TExCQUNLX09SREVSID0gWydpb3MtZGV2aWNlLTgnXQorCisgICAgQGNsYXNzbWV0aG9kCisgICAg ZGVmIGRldGVybWluZV9mdWxsX3BvcnRfbmFtZShjbHMsIGhvc3QsIG9wdGlvbnMsIHBvcnRfbmFt ZSk6CisgICAgICAgIGlmIHBvcnRfbmFtZSA9PSBjbHMucG9ydF9uYW1lOgorICAgICAgICAgICAg c2RrX2NvbW1hbmRfcHJvY2VzcyA9IHN1YnByb2Nlc3MuUG9wZW4oJ3hjcnVuIC0tc2RrIGlwaG9u ZW9zIC0tc2hvdy1zZGstdmVyc2lvbicsIHN0ZG91dD1zdWJwcm9jZXNzLlBJUEUsIHNoZWxsPVRy dWUpCisgICAgICAgICAgICBzZGtfY29tbWFuZF9zdGRvdXQgPSBzZGtfY29tbWFuZF9wcm9jZXNz LmNvbW11bmljYXRlKClbMF0uc3RyaXAoKQorCisgICAgICAgICAgICBhc3NlcnQgc2RrX2NvbW1h bmRfc3Rkb3V0LCAiWGNvZGUgaXMgbm90IGluc3RhbGxlZCwgYW5kIGhlbmNlIHdlIGNhbm5vdCBj b25zdHJ1Y3QgYW4gaU9TIHBvcnQgb2JqZWN0ISIKKworICAgICAgICAgICAgcG9ydF9uYW1lID0g cG9ydF9uYW1lICsgJy0nICsgcmUubWF0Y2goJ14oWzAtOV0rKS4qJywgc2RrX2NvbW1hbmRfc3Rk b3V0KS5ncm91cCgxKQorCisgICAgICAgIHJldHVybiBwb3J0X25hbWUKKworICAgIGRlZiBfX2lu aXRfXyhzZWxmLCAqYXJncywgKiprd2FyZ3MpOgorICAgICAgICBzdXBlcihJT1NQb3J0LCBzZWxm KS5fX2luaXRfXygqYXJncywgKiprd2FyZ3MpCisKKyAgICAgICAgc2VsZi5fYXJjaGl0ZWN0dXJl ID0gc2VsZi5nZXRfb3B0aW9uKCdhcmNoaXRlY3R1cmUnKQorCisgICAgICAgIGlmIG5vdCBzZWxm Ll9hcmNoaXRlY3R1cmU6CisgICAgICAgICAgICBzZWxmLl9hcmNoaXRlY3R1cmUgPSAnYXJtdjcn CisKKyAgICAgICAgc2VsZi5fdGVzdGluZ19kZXZpY2UgPSBOb25lCisKKyAgICAjRGVzcGl0ZSBp dHMgbmFtZSwgdGhlc2UgZmxhZ3MgZG8gbm90IGFjdHVhbGx5IGdldCBwYXNzZWQgYWxsIHRoZSB3 YXkgZG93biB0byB3ZWJraXQtYnVpbGQuIFRyYXZlbGVycyBiZXdhcmUuCisgICAgZGVmIF9idWls ZF9kcml2ZXJfZmxhZ3Moc2VsZik6CisgICAgICAgIHJldHVybiBbJy0tc2RrJywgJ2lwaG9uZW9z JywgJ0FSQ0hTPSVzJyAlIHNlbGYuX2FyY2hpdGVjdHVyZV0KKworICAgIGRlZiBvcGVyYXRpbmdf c3lzdGVtKHNlbGYpOgorICAgICAgICByZXR1cm4gJ2lvcycKKworCiBjbGFzcyBJT1NTaW11bGF0 b3JQb3J0KFBvcnQpOgogICAgIHBvcnRfbmFtZSA9ICJpb3Mtc2ltdWxhdG9yIgogCmRpZmYgLS1n aXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5pdHRl c3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZG93bmxvYWRfdW5p dHRlc3QucHkKaW5kZXggNTliNTJlYWQ4ZmQzZWVkMjhkMzA5NWJiNTMyYmZlNDQ1ZDJkY2I5OS4u NmM4Y2Q1NDUwMDMwMmU4NmZmM2NjMmRkMzRmMWZjZjE2OGJmYWY0ZiAxMDA2NDQKLS0tIGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Rvd25sb2FkX3VuaXR0ZXN0LnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9kb3dubG9hZF91bml0dGVz dC5weQpAQCAtODcsNiArODcsNyBAQCBjbGFzcyBEb3dubG9hZENvbW1hbmRzVGVzdChDb21tYW5k c1Rlc3QpOgogICAgICAgICBvcHRpb25zLnF1aWV0ID0gRmFsc2UKICAgICAgICAgb3B0aW9ucy50 ZXN0ID0gVHJ1ZQogICAgICAgICBvcHRpb25zLnVwZGF0ZSA9IFRydWUKKyAgICAgICAgb3B0aW9u cy5hcmNoaXRlY3R1cmUgPSAnTU9DSyBBUkNIJwogICAgICAgICByZXR1cm4gb3B0aW9ucwogCiAg ICAgZGVmIHRlc3RfYnVpbGQoc2VsZik6CkBAIC0xNjIsNyArMTYzLDcgQEAgTU9DSyBydW5fY29t bWFuZDogWydydWJ5JywgJy1JJywgJy9tb2NrLWNoZWNrb3V0L1dlYnNpdGVzL2J1Z3Mud2Via2l0 Lm9yZy9QcmV0dHkKIE1PQ0s6IHVzZXIub3Blbl91cmw6IGZpbGU6Ly8uLi4KIFdhcyB0aGF0IGRp ZmYgY29ycmVjdD8KIEJ1aWxkaW5nIFdlYktpdAotTU9DSyBydW5fYW5kX3Rocm93X2lmX2ZhaWw6 IFsnbW9jay1idWlsZC13ZWJraXQnXSwgY3dkPS9tb2NrLWNoZWNrb3V0LCBlbnY9eydMQ19BTEwn OiAnQycsICdURVJNJzogJ25vbmUnLCAnTU9DS19FTlZJUk9OX0NPUFknOiAnMSd9CitNT0NLIHJ1 bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLWJ1aWxkLXdlYmtpdCcsICdBUkNIUz1NT0NLIEFS Q0gnXSwgY3dkPS9tb2NrLWNoZWNrb3V0LCBlbnY9eydMQ19BTEwnOiAnQycsICdURVJNJzogJ25v bmUnLCAnTU9DS19FTlZJUk9OX0NPUFknOiAnMSd9CiBSdW5uaW5nIFB5dGhvbiB1bml0IHRlc3Rz CiBNT0NLIHJ1bl9hbmRfdGhyb3dfaWZfZmFpbDogWydtb2NrLXRlc3Qtd2Via2l0cHknXSwgY3dk PS9tb2NrLWNoZWNrb3V0CiBSdW5uaW5nIFBlcmwgdW5pdCB0ZXN0cwpkaWZmIC0tZ2l0IGEvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbS5weSBi L1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9lYXJseXdhcm5pbmdzeXN0ZW0u cHkKaW5kZXggMzRiNjdjNzEyZDU1MGE0ODYwZjNjMTdjNWViYzI0ZGQwNGMxYmIzOS4uZTZiZWI4 NmY5MmVmMmU5M2U2YjJhMzZhZWFmMzljZTVmZTYxYTg3NCAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS90b29sL2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbS5weQorKysgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvZWFybHl3YXJuaW5nc3lzdGVtLnB5 CkBAIC0xMDgsNyArMTA4LDcgQEAgY2xhc3MgQWJzdHJhY3RFYXJseVdhcm5pbmdTeXN0ZW0oQWJz dHJhY3RSZXZpZXdRdWV1ZSwgRWFybHlXYXJuaW5nU3lzdGVtVGFza0RlbGUKICAgICAgICAgcmV0 dXJuIHNlbGYubmFtZQogCiAgICAgZGVmIHJ1bl9jb21tYW5kKHNlbGYsIGNvbW1hbmQpOgotICAg ICAgICBzZWxmLnJ1bl93ZWJraXRfcGF0Y2goY29tbWFuZCArIFtzZWxmLl9kZXByZWNhdGVkX3Bv cnQuZmxhZygpXSkKKyAgICAgICAgc2VsZi5ydW5fd2Via2l0X3BhdGNoKGNvbW1hbmQgKyBbc2Vs Zi5fZGVwcmVjYXRlZF9wb3J0LmZsYWcoKV0gKyBbJy0tYXJjaGl0ZWN0dXJlPSVzJyAlIHNlbGYu X3BvcnQuYXJjaGl0ZWN0dXJlKCldIGlmIHNlbGYuX3BvcnQuYXJjaGl0ZWN0dXJlKCkgZWxzZSBb XSkKIAogICAgIGRlZiBjb21tYW5kX3Bhc3NlZChzZWxmLCBtZXNzYWdlLCBwYXRjaCk6CiAgICAg ICAgIHBhc3MKQEAgLTE1Myw2ICsxNTMsNyBAQCBjbGFzcyBBYnN0cmFjdEVhcmx5V2FybmluZ1N5 c3RlbShBYnN0cmFjdFJldmlld1F1ZXVlLCBFYXJseVdhcm5pbmdTeXN0ZW1UYXNrRGVsZQogICAg ICAgICAgICAgY2xhc3Nlcy5hcHBlbmQodHlwZShzdHIobmFtZS5yZXBsYWNlKCcgJywgJycpKSwg KEFic3RyYWN0RWFybHlXYXJuaW5nU3lzdGVtLCksIHsKICAgICAgICAgICAgICAgICAnbmFtZSc6 IGNvbmZpZ1sncG9ydCddICsgJy1ld3MnLAogICAgICAgICAgICAgICAgICdwb3J0X25hbWUnOiBj b25maWdbJ3BvcnQnXSwKKyAgICAgICAgICAgICAgICAnYXJjaGl0ZWN0dXJlJzogY29uZmlnLmdl dCgnYXJjaGl0ZWN0dXJlJywgTm9uZSksCiAgICAgICAgICAgICAgICAgJ3dhdGNoZXJzJzogY29u ZmlnLmdldCgnd2F0Y2hlcnMnLCBbXSksCiAgICAgICAgICAgICAgICAgJ3J1bl90ZXN0cyc6IGNv bmZpZy5nZXQoJ3J1blRlc3RzJywgY2xzLnJ1bl90ZXN0cyksCiAgICAgICAgICAgICB9KSkKZGlm ZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9lYXJseXdhcm5p bmdzeXN0ZW1fdW5pdHRlc3QucHkgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFu ZHMvZWFybHl3YXJuaW5nc3lzdGVtX3VuaXR0ZXN0LnB5CmluZGV4IGM2ZGUxM2E0MGUyNmU4NjMw MmRhYmIwY2EyYzczN2ZkMjlkNjBjMzguLjZmN2Q0YWI2NjZlN2NkNDRkMGUzZjUxNzlmNGZmNDc5 YWZmMWQ1YTIgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5k cy9lYXJseXdhcm5pbmdzeXN0ZW1fdW5pdHRlc3QucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL2NvbW1hbmRzL2Vhcmx5d2FybmluZ3N5c3RlbV91bml0dGVzdC5weQpAQCAtMjcs MTIgKzI3LDE1IEBACiAjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCiAKIGZyb20gd2Via2l0cHkudGhpcmRwYXJ0eS5t b2NrIGltcG9ydCBNb2NrCitmcm9tIHdlYmtpdHB5LmNvbW1vbi5ob3N0IGltcG9ydCBIb3N0CiBm cm9tIHdlYmtpdHB5LmNvbW1vbi5uZXQubGF5b3V0dGVzdHJlc3VsdHMgaW1wb3J0IExheW91dFRl c3RSZXN1bHRzCiBmcm9tIHdlYmtpdHB5LmNvbW1vbi5zeXN0ZW0ub3V0cHV0Y2FwdHVyZSBpbXBv cnQgT3V0cHV0Q2FwdHVyZQogZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMubW9kZWxzIGltcG9y dCB0ZXN0X3Jlc3VsdHMKIGZyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLm1vZGVscyBpbXBvcnQg dGVzdF9mYWlsdXJlcworZnJvbSB3ZWJraXRweS5wb3J0LmZhY3RvcnkgaW1wb3J0IFBvcnRGYWN0 b3J5CiBmcm9tIHdlYmtpdHB5LnRvb2wuYm90LnF1ZXVlZW5naW5lIGltcG9ydCBRdWV1ZUVuZ2lu ZQogZnJvbSB3ZWJraXRweS50b29sLmNvbW1hbmRzLmVhcmx5d2FybmluZ3N5c3RlbSBpbXBvcnQg KgorZnJvbSB3ZWJraXRweS50b29sLmNvbW1hbmRzLnF1ZXVlcyBpbXBvcnQgUGF0Y2hQcm9jZXNz aW5nUXVldWUKIGZyb20gd2Via2l0cHkudG9vbC5jb21tYW5kcy5xdWV1ZXN0ZXN0IGltcG9ydCBR dWV1ZXNUZXN0CiBmcm9tIHdlYmtpdHB5LnRvb2wubW9ja3Rvb2wgaW1wb3J0IE1vY2tUb29sLCBN b2NrT3B0aW9ucwogCkBAIC01NywyMiArNjAsMjYgQEAgY2xhc3MgQWJzdHJhY3RFYXJseVdhcm5p bmdTeXN0ZW1UZXN0KFF1ZXVlc1Rlc3QpOgogCiBjbGFzcyBFYXJseVdhcm5pbmdTeXN0ZW1UZXN0 KFF1ZXVlc1Rlc3QpOgogICAgIGRlZiBfZGVmYXVsdF9leHBlY3RlZF9sb2dzKHNlbGYsIGV3cyk6 CisgICAgICAgIGhvc3QgPSBIb3N0KCkKKyAgICAgICAgcmVhbF9wb3J0X25hbWUgPSBQYXRjaFBy b2Nlc3NpbmdRdWV1ZSgpLl9uZXdfcG9ydF9uYW1lX2Zyb21fb2xkKGV3cy5wb3J0X25hbWUsIGhv c3QucGxhdGZvcm0pCisgICAgICAgIHJlYWxfcG9ydCA9IEhvc3QoKS5wb3J0X2ZhY3RvcnkuZ2V0 KHJlYWxfcG9ydF9uYW1lKQogICAgICAgICBzdHJpbmdfcmVwbGFjZW1lbnRzID0gewogICAgICAg ICAgICAgIm5hbWUiOiBld3MubmFtZSwKICAgICAgICAgICAgICJwb3J0IjogZXdzLnBvcnRfbmFt ZSwKKyAgICAgICAgICAgICJhcmNoaXRlY3R1cmUiOiByZWFsX3BvcnQuYXJjaGl0ZWN0dXJlKCks CiAgICAgICAgIH0KICAgICAgICAgaWYgZXdzLnJ1bl90ZXN0czoKLSAgICAgICAgICAgIHJ1bl90 ZXN0c19saW5lID0gIlJ1bm5pbmc6IHdlYmtpdC1wYXRjaCAtLXN0YXR1cy1ob3N0PWV4YW1wbGUu Y29tIGJ1aWxkLWFuZC10ZXN0IC0tbm8tY2xlYW4gLS1uby11cGRhdGUgLS10ZXN0IC0tbm9uLWlu dGVyYWN0aXZlIC0tcG9ydD0lKHBvcnQpc1xuIiAlIHN0cmluZ19yZXBsYWNlbWVudHMKKyAgICAg ICAgICAgIHJ1bl90ZXN0c19saW5lID0gIlJ1bm5pbmc6IHdlYmtpdC1wYXRjaCAtLXN0YXR1cy1o b3N0PWV4YW1wbGUuY29tIGJ1aWxkLWFuZC10ZXN0IC0tbm8tY2xlYW4gLS1uby11cGRhdGUgLS10 ZXN0IC0tbm9uLWludGVyYWN0aXZlIC0tcG9ydD0lKHBvcnQpcyAtLWFyY2hpdGVjdHVyZT0lKGFy Y2hpdGVjdHVyZSlzXG4iICUgc3RyaW5nX3JlcGxhY2VtZW50cwogICAgICAgICBlbHNlOgogICAg ICAgICAgICAgcnVuX3Rlc3RzX2xpbmUgPSAiIgogICAgICAgICBzdHJpbmdfcmVwbGFjZW1lbnRz WydydW5fdGVzdHNfbGluZSddID0gcnVuX3Rlc3RzX2xpbmUKIAogICAgICAgICBleHBlY3RlZF9s b2dzID0gewogICAgICAgICAgICAgImJlZ2luX3dvcmtfcXVldWUiOiBzZWxmLl9kZWZhdWx0X2Jl Z2luX3dvcmtfcXVldWVfbG9ncyhld3MubmFtZSksCi0gICAgICAgICAgICAicHJvY2Vzc193b3Jr X2l0ZW0iOiAiIiJSdW5uaW5nOiB3ZWJraXQtcGF0Y2ggLS1zdGF0dXMtaG9zdD1leGFtcGxlLmNv bSBjbGVhbiAtLXBvcnQ9JShwb3J0KXMKLVJ1bm5pbmc6IHdlYmtpdC1wYXRjaCAtLXN0YXR1cy1o b3N0PWV4YW1wbGUuY29tIHVwZGF0ZSAtLXBvcnQ9JShwb3J0KXMKLVJ1bm5pbmc6IHdlYmtpdC1w YXRjaCAtLXN0YXR1cy1ob3N0PWV4YW1wbGUuY29tIGFwcGx5LWF0dGFjaG1lbnQgLS1uby11cGRh dGUgLS1ub24taW50ZXJhY3RpdmUgMTAwMDAgLS1wb3J0PSUocG9ydClzCi1SdW5uaW5nOiB3ZWJr aXQtcGF0Y2ggLS1zdGF0dXMtaG9zdD1leGFtcGxlLmNvbSBidWlsZCAtLW5vLWNsZWFuIC0tbm8t dXBkYXRlIC0tYnVpbGQtc3R5bGU9cmVsZWFzZSAtLXBvcnQ9JShwb3J0KXMKKyAgICAgICAgICAg ICJwcm9jZXNzX3dvcmtfaXRlbSI6ICIiIlJ1bm5pbmc6IHdlYmtpdC1wYXRjaCAtLXN0YXR1cy1o b3N0PWV4YW1wbGUuY29tIGNsZWFuIC0tcG9ydD0lKHBvcnQpcyAtLWFyY2hpdGVjdHVyZT0lKGFy Y2hpdGVjdHVyZSlzCitSdW5uaW5nOiB3ZWJraXQtcGF0Y2ggLS1zdGF0dXMtaG9zdD1leGFtcGxl LmNvbSB1cGRhdGUgLS1wb3J0PSUocG9ydClzIC0tYXJjaGl0ZWN0dXJlPSUoYXJjaGl0ZWN0dXJl KXMKK1J1bm5pbmc6IHdlYmtpdC1wYXRjaCAtLXN0YXR1cy1ob3N0PWV4YW1wbGUuY29tIGFwcGx5 LWF0dGFjaG1lbnQgLS1uby11cGRhdGUgLS1ub24taW50ZXJhY3RpdmUgMTAwMDAgLS1wb3J0PSUo cG9ydClzIC0tYXJjaGl0ZWN0dXJlPSUoYXJjaGl0ZWN0dXJlKXMKK1J1bm5pbmc6IHdlYmtpdC1w YXRjaCAtLXN0YXR1cy1ob3N0PWV4YW1wbGUuY29tIGJ1aWxkIC0tbm8tY2xlYW4gLS1uby11cGRh dGUgLS1idWlsZC1zdHlsZT1yZWxlYXNlIC0tcG9ydD0lKHBvcnQpcyAtLWFyY2hpdGVjdHVyZT0l KGFyY2hpdGVjdHVyZSlzCiAlKHJ1bl90ZXN0c19saW5lKXNNT0NLOiB1cGRhdGVfc3RhdHVzOiAl KG5hbWUpcyBQYXNzCiBNT0NLOiByZWxlYXNlX3dvcmtfaXRlbTogJShuYW1lKXMgMTAwMDAKICIi IiAlIHN0cmluZ19yZXBsYWNlbWVudHMsCmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29s L2NvbW1hbmRzL3F1ZXVlcy5weQppbmRleCA2YmU4NTNmY2ZiNTVhMGZiMmI4MjFlMDhmZjZjMGNk YmNhMDg1ZWMzLi42NGEzZGVhYjI1ZjU4MmU1NTBlY2RhMGUxNGEyZmJiYmYwYjU4OGM0IDEwMDY0 NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvY29tbWFuZHMvcXVldWVzLnB5Cisr KyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9jb21tYW5kcy9xdWV1ZXMucHkKQEAgLTI5 LDYgKzI5LDcgQEAKIAogaW1wb3J0IGNvZGVjcwogaW1wb3J0IGxvZ2dpbmcKK2ltcG9ydCBvcHRw YXJzZQogaW1wb3J0IG9zCiBpbXBvcnQgcmUKIGltcG9ydCBzeXMKQEAgLTc0LDYgKzc1LDcgQEAg Y2xhc3MgQWJzdHJhY3RRdWV1ZShDb21tYW5kLCBRdWV1ZUVuZ2luZURlbGVnYXRlKToKICAgICAg ICAgc2VsZi5oZWxwX3RleHQgPSAiUnVuIHRoZSAlcyIgJSBzZWxmLm5hbWUKICAgICAgICAgQ29t bWFuZC5fX2luaXRfXyhzZWxmLCBvcHRpb25zPW9wdGlvbnNfbGlzdCkKICAgICAgICAgc2VsZi5f aXRlcmF0aW9uX2NvdW50ID0gMAorICAgICAgICBzZWxmLmFyY2hpdGVjdHVyZSA9IE5vbmUKIAog ICAgIGRlZiBfY2Nfd2F0Y2hlcnMoc2VsZiwgYnVnX2lkKToKICAgICAgICAgdHJ5OgpAQCAtMjc1 LDcgKzI3NywxMCBAQCBjbGFzcyBQYXRjaFByb2Nlc3NpbmdRdWV1ZShBYnN0cmFjdFBhdGNoUXVl dWUpOgogICAgICAgICBzZWxmLl9kZXByZWNhdGVkX3BvcnQgPSBEZXByZWNhdGVkUG9ydC5wb3J0 KHNlbGYucG9ydF9uYW1lKQogICAgICAgICAjIEZJWE1FOiBUaGlzIHZpb2xhdGVzIGFic3RyYWN0 aW9uCiAgICAgICAgIHNlbGYuX3Rvb2wuX2RlcHJlY2F0ZWRfcG9ydCA9IHNlbGYuX2RlcHJlY2F0 ZWRfcG9ydAotICAgICAgICBzZWxmLl9wb3J0ID0gc2VsZi5fdG9vbC5wb3J0X2ZhY3RvcnkuZ2V0 KHNlbGYuX25ld19wb3J0X25hbWVfZnJvbV9vbGQoc2VsZi5wb3J0X25hbWUsIHNlbGYuX3Rvb2wu cGxhdGZvcm0pKQorICAgICAgICBwb3J0X29wdGlvbnMgPSBvcHRwYXJzZS5WYWx1ZXMoKQorICAg ICAgICBpZiBzZWxmLmFyY2hpdGVjdHVyZToKKyAgICAgICAgICAgIHNldGF0dHIocG9ydF9vcHRp b25zLCAnYXJjaGl0ZWN0dXJlJywgc2VsZi5hcmNoaXRlY3R1cmUpCisgICAgICAgIHNlbGYuX3Bv cnQgPSBzZWxmLl90b29sLnBvcnRfZmFjdG9yeS5nZXQoc2VsZi5fbmV3X3BvcnRfbmFtZV9mcm9t X29sZChzZWxmLnBvcnRfbmFtZSwgc2VsZi5fdG9vbC5wbGF0Zm9ybSksIHBvcnRfb3B0aW9ucykK IAogICAgIGRlZiBfdXBsb2FkX3Jlc3VsdHNfYXJjaGl2ZV9mb3JfcGF0Y2goc2VsZiwgcGF0Y2gs IHJlc3VsdHNfYXJjaGl2ZV96aXApOgogICAgICAgICBpZiBub3Qgc2VsZi5fcG9ydDoKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9hYnN0cmFjdHN0ZXAucHkg Yi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3RlcHMvYWJzdHJhY3RzdGVwLnB5CmluZGV4 IDJhNWZlYTYyOGMxOTU0OTlkN2I1ZGIzNzBmNzAwMWI5ZjI0NjE2ZTguLjczMDZiNjk5OWRiNTIy NDgyMTkzOWE4NDBkOWYzOTgwYjk5ZjBjY2MgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvdG9vbC9zdGVwcy9hYnN0cmFjdHN0ZXAucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS90b29sL3N0ZXBzL2Fic3RyYWN0c3RlcC5weQpAQCAtNzIsNiArNzIsNyBAQCBjbGFzcyBB YnN0cmFjdFN0ZXAob2JqZWN0KToKICAgICAgICAgcmV0dXJuIFsKICAgICAgICAgICAgICMgV2Ug bmVlZCB0aGlzIG9wdGlvbiBoZXJlIGJlY2F1c2UgY2FjaGVkX2xvb2t1cCB1c2VzIGl0LiAgOigK ICAgICAgICAgICAgIE9wdGlvbnMuZ2l0X2NvbW1pdCwKKyAgICAgICAgICAgIE9wdGlvbnMuYXJj aGl0ZWN0dXJlLAogICAgICAgICBdCiAKICAgICBkZWYgcnVuKHNlbGYsIHN0YXRlKToKZGlmZiAt LWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9idWlsZC5weSBiL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvdG9vbC9zdGVwcy9idWlsZC5weQppbmRleCBiNjZhMzVmZjdjMTkw NTA0NzM1NjgzOTY5MmE0YTU2OTQ4OGFkYWRkLi4wMzU2YjQwOTI1NjQ5MzU4MjdjYTZkMThjMDhk OTgyYzY2ZDQxNTczIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Rvb2wvc3Rl cHMvYnVpbGQucHkKKysrIGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL2J1aWxk LnB5CkBAIC01MCw2ICs1MCwxMCBAQCBjbGFzcyBCdWlsZChBYnN0cmFjdFN0ZXApOgogICAgICAg ICBlbnYgPSBlbnZpcm9ubWVudC50b19kaWN0aW9uYXJ5KCkKIAogICAgICAgICBidWlsZF93ZWJr aXRfY29tbWFuZCA9IHNlbGYuX3Rvb2wuZGVwcmVjYXRlZF9wb3J0KCkuYnVpbGRfd2Via2l0X2Nv bW1hbmQoYnVpbGRfc3R5bGU9YnVpbGRfc3R5bGUpCisKKyAgICAgICAgaWYgc2VsZi5fb3B0aW9u cy5hcmNoaXRlY3R1cmU6CisgICAgICAgICAgICBidWlsZF93ZWJraXRfY29tbWFuZCArPSBbJ0FS Q0hTPSVzJyAlIHNlbGYuX29wdGlvbnMuYXJjaGl0ZWN0dXJlXQorCiAgICAgICAgIHNlbGYuX3Rv b2wuZXhlY3V0aXZlLnJ1bl9hbmRfdGhyb3dfaWZfZmFpbChidWlsZF93ZWJraXRfY29tbWFuZCwg c2VsZi5fb3B0aW9ucy5xdWlldCwKICAgICAgICAgICAgIGN3ZD1zZWxmLl90b29sLnNjbSgpLmNo ZWNrb3V0X3Jvb3QsIGVudj1lbnYpCiAKZGlmZiAtLWdpdCBhL1Rvb2xzL1NjcmlwdHMvd2Via2l0 cHkvdG9vbC9zdGVwcy9vcHRpb25zLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0 ZXBzL29wdGlvbnMucHkKaW5kZXggN2VkYTYxNDU5MDFiZjUyZDhiODljNzVkNGRjYTY1ZmM1MzQ1 MzIyZi4uZGM1ZmUyYzhiNGZiMTc3M2EyMWE0OGU3MDA4OTQxMGZjZWE5OGZlNyAxMDA2NDQKLS0t IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL29wdGlvbnMucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS90b29sL3N0ZXBzL29wdGlvbnMucHkKQEAgLTI5LDYgKzI5LDcg QEAKIGZyb20gb3B0cGFyc2UgaW1wb3J0IG1ha2Vfb3B0aW9uCiAKIGNsYXNzIE9wdGlvbnMob2Jq ZWN0KToKKyAgICBhcmNoaXRlY3R1cmUgPSBtYWtlX29wdGlvbigiLS1hcmNoaXRlY3R1cmUiLCBh Y3Rpb249InN0b3JlIiwgdHlwZT0ic3RyaW5nIiwgZGVzdD0iYXJjaGl0ZWN0dXJlIiwgZGVmYXVs dD1Ob25lLCBoZWxwPSJUYXJnZXQgYXJjaGl0ZWN0dXJlIikKICAgICBibG9ja3MgPSBtYWtlX29w dGlvbigiLS1ibG9ja3MiLCBhY3Rpb249InN0b3JlIiwgdHlwZT0ic3RyaW5nIiwgZGVzdD0iYmxv Y2tzIiwgZGVmYXVsdD1Ob25lLCBoZWxwPSJCdWcgbnVtYmVyIHdoaWNoIHRoZSBjcmVhdGVkIGJ1 ZyBibG9ja3MuIikKICAgICBidWlsZCA9IG1ha2Vfb3B0aW9uKCItLWJ1aWxkIiwgYWN0aW9uPSJz dG9yZV90cnVlIiwgZGVzdD0iYnVpbGQiLCBkZWZhdWx0PUZhbHNlLCBoZWxwPSJCdWlsZCBhbmQg cnVuIHJ1bi13ZWJraXQtdGVzdHMgYmVmb3JlIGNvbW1pdHRpbmcuIikKICAgICBidWlsZF9zdHls ZSA9IG1ha2Vfb3B0aW9uKCItLWJ1aWxkLXN0eWxlIiwgYWN0aW9uPSJzdG9yZSIsIGRlc3Q9ImJ1 aWxkX3N0eWxlIiwgZGVmYXVsdD1Ob25lLCBoZWxwPSJXaGV0aGVyIHRvIGJ1aWxkIGRlYnVnLCBy ZWxlYXNlLCBvciBib3RoLiIpCg==