Debian Codegraph @

cross-project-tests/debuginfo-tests/dexter/dex/debugger/visualstudio/windows/ComInterface.py

raw
1 # DExTer : Debugging Experience Tester
2 # ~~~~~~ ~ ~~ ~ ~~
3 #
4 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 # See https://llvm.org/LICENSE.txt for license information.
6 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 """Communication via the Windows COM interface."""
8
9 import inspect
10 import time
11 import sys
12
13 # pylint: disable=import-error
14 import win32com.client as com
15 import win32api
16
17 # pylint: enable=import-error
18
19 from dex.utils.Exceptions import LoadDebuggerException
20
21 _com_error = com.pywintypes.com_error # pylint: disable=no-member
22
23
24 def get_file_version(file_):
25 try:
26 info = win32api.GetFileVersionInfo(file_, "\\")
27 ms = info["FileVersionMS"]
28 ls = info["FileVersionLS"]
29 return ".".join(
30 str(s)
31 for s in [
32 win32api.HIWORD(ms),
33 win32api.LOWORD(ms),
34 win32api.HIWORD(ls),
35 win32api.LOWORD(ls),
36 ]
37 )
38 except com.pywintypes.error: # pylint: disable=no-member
39 return "no versioninfo present"
40
41
42 def _handle_com_error(e):
43 exc = sys.exc_info()
44 msg = win32api.FormatMessage(e.hresult)
45 try:
46 msg = msg.decode("CP1251")
47 except AttributeError:
48 pass
49 msg = msg.strip()
50 return msg, exc
51
52
53 class ComObject(object):
54 """Wrap a raw Windows COM object in a class that implements auto-retry of
55 failed calls.
56 """
57
58 def __init__(self, raw):
59 assert not isinstance(raw, ComObject), raw
60 self.__dict__["raw"] = raw
61
62 def __str__(self):
63 return self._call(self.raw.__str__)
64
65 def __getattr__(self, key):
66 if key in self.__dict__:
67 return self.__dict__[key]
68 return self._call(self.raw.__getattr__, key)
69
70 def __setattr__(self, key, val):
71 if key in self.__dict__:
72 self.__dict__[key] = val
73 self._call(self.raw.__setattr__, key, val)
74
75 def __getitem__(self, key):
76 return self._call(self.raw.__getitem__, key)
77
78 def __setitem__(self, key, val):
79 self._call(self.raw.__setitem__, key, val)
80
81 def __call__(self, *args):
82 return self._call(self.raw, *args)
83
84 @classmethod
85 def _call(cls, fn, *args):
86 """COM calls tend to randomly fail due to thread sync issues.
87 The Microsoft recommended solution is to set up a message filter object
88 to automatically retry failed calls, but this seems prohibitively hard
89 from python, so this is a custom solution to do the same thing.
90 All COM accesses should go through this function.
91 """
92 ex = AssertionError("this should never be raised!")
93
94 assert (
95 inspect.isfunction(fn) or inspect.ismethod(fn) or inspect.isbuiltin(fn)
96 ), (fn, type(fn))
97 retries = ([0] * 50) + ([1] * 5)
98 for r in retries:
99 try:
100 try:
101 result = fn(*args)
102 if inspect.ismethod(result) or "win32com" in str(result.__class__):
103 result = ComObject(result)
104 return result
105 except _com_error as e:
106 msg, _ = _handle_com_error(e)
107 e = WindowsError(msg) # pylint: disable=undefined-variable
108 raise e
109 except (AttributeError, TypeError, OSError) as e:
110 ex = e
111 time.sleep(r)
112 raise ex
113
114
115 class DTE(ComObject):
116 def __init__(self, class_string):
117 try:
118 super(DTE, self).__init__(com.DispatchEx(class_string))
119 except _com_error as e:
120 msg, exc = _handle_com_error(e)
121 raise LoadDebuggerException(
122 "{} [{}]".format(msg, class_string), orig_exception=exc
123 )