-
-
Notifications
You must be signed in to change notification settings - Fork 8.1k
/
service.py
224 lines (199 loc) · 8.44 KB
/
service.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
# Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import errno
import logging
import os
import subprocess
import typing
from abc import ABC
from abc import abstractmethod
from platform import system
from subprocess import DEVNULL
from subprocess import PIPE
from time import sleep
from urllib import request
from urllib.error import URLError
from selenium.common.exceptions import WebDriverException
from selenium.types import SubprocessStdAlias
from selenium.webdriver.common import utils
from selenium.webdriver.common.selenium_manager import SeleniumManager
logger = logging.getLogger(__name__)
_HAS_NATIVE_DEVNULL = True
class Service(ABC):
"""The abstract base class for all service objects. Services typically launch a child program
in a new process as an interim process to communicate with a browser.
:param executable: install path of the executable.
:param port: Port for the service to run on, defaults to 0 where the operating system will decide.
:param log_file: (Optional) file descriptor (pos int) or file object with a valid file descriptor.
subprocess.PIPE & subprocess.DEVNULL are also valid values.
:param env: (Optional) Mapping of environment variables for the new process, defaults to `os.environ`.
"""
def __init__(
self,
executable: str,
port: int = 0,
log_file: SubprocessStdAlias = DEVNULL,
env: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None,
start_error_message: typing.Optional[str] = None,
) -> None:
self.path = executable
self.port = port or utils.free_port()
self.log_file = open(os.devnull, "wb") if not _HAS_NATIVE_DEVNULL and log_file == DEVNULL else log_file
self.start_error_message = start_error_message or ""
# Default value for every python subprocess: subprocess.Popen(..., creationflags=0)
self.creation_flags = 0
self.env = env or os.environ
@property
def service_url(self) -> str:
"""
Gets the url of the Service
"""
return f"http://{utils.join_host_port('localhost', self.port)}"
@abstractmethod
def command_line_args(self) -> typing.List[str]:
"""A List of program arguments (excluding the executable)."""
raise NotImplementedError("This method needs to be implemented in a sub class")
def start(self) -> None:
"""
Starts the Service.
:Exceptions:
- WebDriverException : Raised either when it can't start the service
or when it can't connect to the service
"""
try:
self._start_process(self.path)
except WebDriverException as err:
if "executable needs to be in PATH" in err.msg:
logger.debug("driver not found in PATH, trying Selenium Manager")
browser = self.__class__.__module__.split(".")[-2]
try:
path = SeleniumManager().driver_location(browser)
except WebDriverException as new_err:
logger.debug("Unable to obtain driver using Selenium Manager: " + new_err.msg)
raise err
self._start_process(path)
count = 0
while True:
self.assert_process_still_running()
if self.is_connectable():
break
count += 1
sleep(0.5)
if count == 60:
raise WebDriverException(f"Can not connect to the Service {self.path}")
def assert_process_still_running(self) -> None:
"""Check if the underlying process is still running."""
return_code = self.process.poll()
if return_code:
raise WebDriverException(f"Service {self.path} unexpectedly exited. Status code was: {return_code}")
def is_connectable(self) -> bool:
"""Establishes a socket connection to determine if the service running on
the port is accessible."""
return utils.is_connectable(self.port)
def send_remote_shutdown_command(self) -> None:
"""
Dispatch an HTTP request to the shutdown endpoint for the service in an
attempt to stop it.
"""
try:
request.urlopen(f"{self.service_url}/shutdown")
except URLError:
return
for _ in range(30):
if not self.is_connectable():
break
sleep(1)
def stop(self) -> None:
"""
Stops the service.
"""
if self.log_file != PIPE and not (self.log_file == DEVNULL and _HAS_NATIVE_DEVNULL):
try:
# Todo: Be explicit in what we are catching here.
if hasattr(self.log_file, "close"):
self.log_file.close() # type: ignore
except Exception:
pass
if self.process is not None:
try:
self.send_remote_shutdown_command()
except TypeError:
pass
self._terminate_process()
def _terminate_process(self) -> None:
"""Terminate the child process. On POSIX this attempts a graceful
SIGTERM followed by a SIGKILL, on a Windows OS kill is an alias to
terminate. Terminating does not raise itself if something has gone
wrong but (currently) silently ignores errors here."""
try:
stdin, stdout, stderr = self.process.stdin, self.process.stdout, self.process.stderr
for stream in stdin, stdout, stderr:
try:
stream.close() # type: ignore
except AttributeError:
pass
self.process.terminate()
self.process.wait(60)
# Todo: only SIGKILL if necessary; the process may be cleanly exited by now.
self.process.kill()
except OSError:
logger.error("Error terminating service process.", exc_info=True)
def __del__(self) -> None:
# `subprocess.Popen` doesn't send signal on `__del__`;
# so we attempt to close the launched process when `__del__`
# is triggered.
# do not use globals here; interpreter shutdown may have already cleaned them up
# and they would be `None`. This goes for anything this method is referencing internally.
try:
self.stop()
except Exception:
pass
def _start_process(self, path: str) -> None:
"""
Creates a subprocess by executing the command provided.
:param cmd: full command to execute
"""
cmd = [path]
cmd.extend(self.command_line_args())
try:
self.process = subprocess.Popen(
cmd,
env=self.env,
close_fds=system() != "Windows",
stdout=self.log_file,
stderr=self.log_file,
stdin=PIPE,
creationflags=self.creation_flags,
)
logger.debug(f"Started executable: `{self.path}` in a child process with pid: {self.process.pid}")
except TypeError:
raise
except OSError as err:
if err.errno == errno.ENOENT:
raise WebDriverException(
f"'{os.path.basename(self.path)}' executable needs to be in PATH. {self.start_error_message}"
)
elif err.errno == errno.EACCES:
raise WebDriverException(
f"'{os.path.basename(self.path)}' executable may have wrong permissions. {self.start_error_message}"
)
else:
raise
except Exception as e:
raise WebDriverException(
f"The executable {os.path.basename(self.path)} needs to be available in the path. {self.start_error_message}\n{str(e)}"
)