9077922839

Committed 14 May 2024 10:35AM UTC coverage: 59.03%. Remained the same

Build # 9077922839

Build Type

push

github

Committed by

Christian-B

Commit Message

add typing

more typing

flake8

typing fix

copyright

Run Details

1847 of 3094 branches covered (59.7%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

186 existing lines in 2 files now uncovered.

4775 of 8124 relevant lines covered (58.78%)

0.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.5

/spinnman/spalloc/spalloc_job.py

# Copyright (c) 2022 The University of Manchester
#
# Licensed 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
#
#     https://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.

from typing import Dict, Mapping, Optional, Tuple
from spinn_utilities.abstract_base import AbstractBase, abstractmethod
from spinnman.constants import SCP_SCAMP_PORT
from spinnman.transceiver.transceiver import Transceiver
from spinnman.connections.udp_packet_connections import UDPConnection
from .spalloc_state import SpallocState
from .spalloc_boot_connection import SpallocBootConnection
from .spalloc_eieio_connection import SpallocEIEIOConnection
from .spalloc_eieio_listener import SpallocEIEIOListener
from .spalloc_scp_connection import SpallocSCPConnection


class SpallocJob(object, metaclass=AbstractBase):
    """
    Represents a job in Spalloc.

    Don't make this yourself. Use :py:class:`SpallocClient` instead.
    """
    __slots__ = ()

    @abstractmethod
    def get_state(self, wait_for_change: bool = False) -> SpallocState:
        """
        Get the current state of the machine.

        :param bool wait_for_change: Whether to wait for a change in state

        :rtype: SpallocState
        """
        raise NotImplementedError()

    @abstractmethod
    def get_root_host(self) -> Optional[str]:
        """
        Get the IP address for talking to the machine.

        :return: The IP address, or ``None`` if not allocated.
        :rtype: str or None
        """
        raise NotImplementedError()

    @abstractmethod
    def get_connections(self) -> Dict[Tuple[int, int], str]:
        """
        Get the mapping from board coordinates to IP addresses.

        :return: (x,y)->IP mapping, or ``None`` if not allocated
        :rtype: dict(tuple(int,int), str) or None
        """
        raise NotImplementedError()

    @abstractmethod
    def connect_to_board(
            self, x: int, y: int,
            port: int = SCP_SCAMP_PORT) -> SpallocSCPConnection:
        """
        Open a connection to a particular board in the job.

        :param int x: X coordinate of the board's Ethernet-enabled chip
        :param int y: Y coordinate of the board's Ethernet-enabled chip
        :param int port: UDP port to talk to; defaults to the SCP port
        :return: A connection that talks to the board.
        :rtype: SpallocProxiedConnection
        """
        raise NotImplementedError()

    @abstractmethod
    def connect_for_booting(self) -> SpallocBootConnection:
        """
        Open a connection to a job's allocation so it can be booted.

        :return: a boot connection
        :rtype: SpallocBootConnection
        """
        raise NotImplementedError()

    @abstractmethod
    def open_eieio_connection(self, x: int, y: int) -> SpallocEIEIOConnection:
        """
        Open an EIEIO connection to a specific board in a job.

        :param int x:
            The X coordinate of the Ethernet-enabled chip to connect to
        :param int y:
            The Y coordinate of the Ethernet-enabled chip to connect to
        :return: an EIEIO connection with a board address bound
        :rtype: SpallocEIEIOConnection
        """
        raise NotImplementedError()

    @abstractmethod
    def open_eieio_listener_connection(self) -> SpallocEIEIOListener:
        """
        Open a listening EIEIO connection to the job's boards. Messages cannot
        be sent on this connection unless you say which board to send to, but
        they can be received from all boards. You can also get the *server*
        side connection information so you can program that into a tag.

        :return: an EIEIO connection with no board address bound
        :rtype: SpallocEIEIOListener
        """
        raise NotImplementedError()

    @abstractmethod
    def open_udp_listener_connection(self) -> UDPConnection:
        """
        Open a listening UDP connection to the job's boards. Messages cannot
        be sent on this connection unless you say which board to send to, but
        they can be received from all boards. You can also get the *server*
        side connection information so you can program that into a tag.

        :return: a UDP connection with no board address bound
        :rtype: UDPConnection
        """
        raise NotImplementedError()

    @abstractmethod
    def create_transceiver(self) -> Transceiver:
        """
        Create a transceiver that will talk to this job. The transceiver will
        only be configured to talk to the SCP ports of the boards of the job.

        :rtype: Transceiver
        """
        raise NotImplementedError()

    @abstractmethod
    def wait_for_state_change(self, old_state: SpallocState,
                              timeout: Optional[int] = None) -> SpallocState:
        """
        Wait until the allocation is not in the given old state.

        :param SpallocState old_state:
            The state that we are looking to change out of.
        :param timeout:
            The time to wait, or None to wait forever
        :type timeout: int or None
        :return: The state that the allocation is now in.

            .. note::
                If the machine gets destroyed, this will not wait for it.
        :rtype: SpallocState
        """
        raise NotImplementedError()

    @abstractmethod
    def wait_until_ready(self, timeout: Optional[int] = None,
                         n_retries: Optional[int] = None):
        """
        Wait until the allocation is in the ``READY`` state.

        :param timeout: The timeout or None to wait forever
        :type timeout: int or None
        :param n_retries:
            The number of times to retry, or None to retry forever
        :type n_retries: int or None
        :raises Exception: If the allocation is destroyed
        """
        raise NotImplementedError()

    @abstractmethod
    def destroy(self, reason: str = "finished"):
        """
        Destroy the job.

        :param str reason: Why the job is being destroyed.
        """
        raise NotImplementedError()

    @abstractmethod
    def where_is_machine(self, x: int, y: int) -> Optional[
            Tuple[int, int, int]]:
        """
        Get the *physical* coordinates of the board hosting the given chip.

        :param int x: Chip X coordinate
        :param int y: Chip Y coordinate
        :return: physical board coordinates (cabinet, frame, board), or
            ``None`` if there are no boards currently allocated to the job or
            the chip lies outside the allocation.
        :rtype: tuple(int,int,int) or None
        """
        raise NotImplementedError()

    @abstractmethod
    def get_session_credentials_for_db(self) -> Mapping[Tuple[str, str], str]:
        """
        Get the session credentials for the job to be written into a database

        .. note::
            May assume that there is a ``proxy_configuration`` table with
            ``kind``, ``name`` and ``value`` columns.
        """
        raise NotImplementedError()

    def __enter__(self):
        """
        Return self on entering context.
        """
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        """
        Handle exceptions by killing the job and logging the exception in the
        job's destroy reason.
        """
        try:
            self.destroy(str(exc_value))
        except Exception:  # pylint: disable=broad-except
            # Ignore this exception; there's not much we can do with it
            pass
        return None

1	# Copyright (c) 2022 The University of Manchester
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# https://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14
15	from typing import Dict, Mapping, Optional, Tuple	1✔
16	from spinn_utilities.abstract_base import AbstractBase, abstractmethod	1✔
17	from spinnman.constants import SCP_SCAMP_PORT	1✔
18	from spinnman.transceiver.transceiver import Transceiver	1✔
19	from spinnman.connections.udp_packet_connections import UDPConnection	1✔
20	from .spalloc_state import SpallocState	1✔
21	from .spalloc_boot_connection import SpallocBootConnection	1✔
22	from .spalloc_eieio_connection import SpallocEIEIOConnection	1✔
23	from .spalloc_eieio_listener import SpallocEIEIOListener	1✔
24	from .spalloc_scp_connection import SpallocSCPConnection	1✔
25
26
27	class SpallocJob(object, metaclass=AbstractBase):	1✔
28	"""
29	Represents a job in Spalloc.
30
31	Don't make this yourself. Use :py:class:`SpallocClient` instead.
32	"""
33	__slots__ = ()	1✔
34
35	@abstractmethod	1✔
36	def get_state(self, wait_for_change: bool = False) -> SpallocState:	1✔
37	"""
38	Get the current state of the machine.
39
40	:param bool wait_for_change: Whether to wait for a change in state
41
42	:rtype: SpallocState
43	"""
44	raise NotImplementedError()
45
46	@abstractmethod	1✔
47	def get_root_host(self) -> Optional[str]:	1✔
48	"""
49	Get the IP address for talking to the machine.
50
51	:return: The IP address, or ``None`` if not allocated.
52	:rtype: str or None
53	"""
54	raise NotImplementedError()
55
56	@abstractmethod	1✔
57	def get_connections(self) -> Dict[Tuple[int, int], str]:	1✔
58	"""
59	Get the mapping from board coordinates to IP addresses.
60
61	:return: (x,y)->IP mapping, or ``None`` if not allocated
62	:rtype: dict(tuple(int,int), str) or None
63	"""
64	raise NotImplementedError()
65
66	@abstractmethod	1✔
67	def connect_to_board(	1✔
68	self, x: int, y: int,
69	port: int = SCP_SCAMP_PORT) -> SpallocSCPConnection:
70	"""
71	Open a connection to a particular board in the job.
72
73	:param int x: X coordinate of the board's Ethernet-enabled chip
74	:param int y: Y coordinate of the board's Ethernet-enabled chip
75	:param int port: UDP port to talk to; defaults to the SCP port
76	:return: A connection that talks to the board.
77	:rtype: SpallocProxiedConnection
78	"""
79	raise NotImplementedError()
80
81	@abstractmethod	1✔
82	def connect_for_booting(self) -> SpallocBootConnection:	1✔
83	"""
84	Open a connection to a job's allocation so it can be booted.
85
86	:return: a boot connection
87	:rtype: SpallocBootConnection
88	"""
89	raise NotImplementedError()
90
91	@abstractmethod	1✔
92	def open_eieio_connection(self, x: int, y: int) -> SpallocEIEIOConnection:	1✔
93	"""
94	Open an EIEIO connection to a specific board in a job.
95
96	:param int x:
97	The X coordinate of the Ethernet-enabled chip to connect to
98	:param int y:
99	The Y coordinate of the Ethernet-enabled chip to connect to
100	:return: an EIEIO connection with a board address bound
101	:rtype: SpallocEIEIOConnection
102	"""
103	raise NotImplementedError()
104
105	@abstractmethod	1✔
106	def open_eieio_listener_connection(self) -> SpallocEIEIOListener:	1✔
107	"""
108	Open a listening EIEIO connection to the job's boards. Messages cannot
109	be sent on this connection unless you say which board to send to, but
110	they can be received from all boards. You can also get the server
111	side connection information so you can program that into a tag.
112
113	:return: an EIEIO connection with no board address bound
114	:rtype: SpallocEIEIOListener
115	"""
116	raise NotImplementedError()
117
118	@abstractmethod	1✔
119	def open_udp_listener_connection(self) -> UDPConnection:	1✔
120	"""
121	Open a listening UDP connection to the job's boards. Messages cannot
122	be sent on this connection unless you say which board to send to, but
123	they can be received from all boards. You can also get the server
124	side connection information so you can program that into a tag.
125
126	:return: a UDP connection with no board address bound
127	:rtype: UDPConnection
128	"""
129	raise NotImplementedError()
130
131	@abstractmethod	1✔
132	def create_transceiver(self) -> Transceiver:	1✔
133	"""
134	Create a transceiver that will talk to this job. The transceiver will
135	only be configured to talk to the SCP ports of the boards of the job.
136
137	:rtype: Transceiver
138	"""
139	raise NotImplementedError()
140
141	@abstractmethod	1✔
142	def wait_for_state_change(self, old_state: SpallocState,	1✔
143	timeout: Optional[int] = None) -> SpallocState:
144	"""
145	Wait until the allocation is not in the given old state.
146
147	:param SpallocState old_state:
148	The state that we are looking to change out of.
149	:param timeout:
150	The time to wait, or None to wait forever
151	:type timeout: int or None
152	:return: The state that the allocation is now in.
153
154	.. note::
155	If the machine gets destroyed, this will not wait for it.
156	:rtype: SpallocState
157	"""
158	raise NotImplementedError()
159
160	@abstractmethod	1✔
161	def wait_until_ready(self, timeout: Optional[int] = None,	1✔
162	n_retries: Optional[int] = None):
163	"""
164	Wait until the allocation is in the ``READY`` state.
165
166	:param timeout: The timeout or None to wait forever
167	:type timeout: int or None
168	:param n_retries:
169	The number of times to retry, or None to retry forever
170	:type n_retries: int or None
171	:raises Exception: If the allocation is destroyed
172	"""
173	raise NotImplementedError()
174
175	@abstractmethod	1✔
176	def destroy(self, reason: str = "finished"):	1✔
177	"""
178	Destroy the job.
179
180	:param str reason: Why the job is being destroyed.
181	"""
182	raise NotImplementedError()
183
184	@abstractmethod	1✔
185	def where_is_machine(self, x: int, y: int) -> Optional[	1✔
186	Tuple[int, int, int]]:
187	"""
188	Get the physical coordinates of the board hosting the given chip.
189
190	:param int x: Chip X coordinate
191	:param int y: Chip Y coordinate
192	:return: physical board coordinates (cabinet, frame, board), or
193	``None`` if there are no boards currently allocated to the job or
194	the chip lies outside the allocation.
195	:rtype: tuple(int,int,int) or None
196	"""
197	raise NotImplementedError()
198
199	@abstractmethod	1✔
200	def get_session_credentials_for_db(self) -> Mapping[Tuple[str, str], str]:	1✔
201	"""
202	Get the session credentials for the job to be written into a database
203
204	.. note::
205	May assume that there is a ``proxy_configuration`` table with
206	``kind``, ``name`` and ``value`` columns.
207	"""
208	raise NotImplementedError()
209
210	def __enter__(self):	1✔
211	"""
212	Return self on entering context.
213	"""
UNCOV 214	return self	×
215
216	def __exit__(self, exc_type, exc_value, traceback):	1✔
217	"""
218	Handle exceptions by killing the job and logging the exception in the
219	job's destroy reason.
220	"""
221	try:	×
222	self.destroy(str(exc_value))	×
UNCOV 223	except Exception: # pylint: disable=broad-except	×
224	# Ignore this exception; there's not much we can do with it
225	pass	×
UNCOV 226	return None	×

SpiNNakerManchester / SpiNNMan / 9077922839

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous