hc
2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d
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
#
# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
# Copyright (C) 2006 - 2007  Richard Purdie
#
# SPDX-License-Identifier: GPL-2.0-only
#
 
"""
Use this class to fork off a thread to recieve event callbacks from the bitbake
server and queue them for the UI to process. This process must be used to avoid
client/server deadlocks.
"""
 
import collections, logging, pickle, socket, threading
from xmlrpc.server import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
 
import bb
 
logger = logging.getLogger(__name__)
 
class BBUIEventQueue:
    def __init__(self, BBServer, clientinfo=("localhost, 0")):
 
        self.eventQueue = []
        self.eventQueueLock = threading.Lock()
        self.eventQueueNotify = threading.Event()
 
        self.BBServer = BBServer
        self.clientinfo = clientinfo
 
        server = UIXMLRPCServer(self.clientinfo)
        self.host, self.port = server.socket.getsockname()
 
        server.register_function( self.system_quit, "event.quit" )
        server.register_function( self.send_event, "event.sendpickle" )
        server.socket.settimeout(1)
 
        self.EventHandle = None
 
        # the event handler registration may fail here due to cooker being in invalid state
        # this is a transient situation, and we should retry a couple of times before
        # giving up
 
        for count_tries in range(5):
            ret = self.BBServer.registerEventHandler(self.host, self.port)
 
            if isinstance(ret, collections.Iterable):
                self.EventHandle, error = ret
            else:
                self.EventHandle = ret
                error = ""
 
            if self.EventHandle is not None:
                break
 
            errmsg = "Could not register UI event handler. Error: %s, host %s, "\
                     "port %d" % (error, self.host, self.port)
            bb.warn("%s, retry" % errmsg)
 
            import time
            time.sleep(1)
        else:
            raise Exception(errmsg)
 
        self.server = server
 
        self.t = threading.Thread()
        self.t.setDaemon(True)
        self.t.run = self.startCallbackHandler
        self.t.start()
 
    def getEvent(self):
 
        self.eventQueueLock.acquire()
 
        if len(self.eventQueue) == 0:
            self.eventQueueLock.release()
            return None
 
        item = self.eventQueue.pop(0)
 
        if len(self.eventQueue) == 0:
            self.eventQueueNotify.clear()
 
        self.eventQueueLock.release()
        return item
 
    def waitEvent(self, delay):
        self.eventQueueNotify.wait(delay)
        return self.getEvent()
 
    def queue_event(self, event):
        self.eventQueueLock.acquire()
        self.eventQueue.append(event)
        self.eventQueueNotify.set()
        self.eventQueueLock.release()
 
    def send_event(self, event):
        self.queue_event(pickle.loads(event))
 
    def startCallbackHandler(self):
 
        self.server.timeout = 1
        bb.utils.set_process_name("UIEventQueue")
        while not self.server.quit:
            try:
                self.server.handle_request()
            except Exception as e:
                import traceback
                logger.error("BBUIEventQueue.startCallbackHandler: Exception while trying to handle request: %s\n%s" % (e, traceback.format_exc()))
 
        self.server.server_close()
 
    def system_quit( self ):
        """
        Shut down the callback thread
        """
        try:
            self.BBServer.unregisterEventHandler(self.EventHandle)
        except:
            pass
        self.server.quit = True
 
class UIXMLRPCServer (SimpleXMLRPCServer):
 
    def __init__( self, interface ):
        self.quit = False
        SimpleXMLRPCServer.__init__( self,
                                    interface,
                                    requestHandler=SimpleXMLRPCRequestHandler,
                                    logRequests=False, allow_none=True, use_builtin_types=True)
 
    def get_request(self):
        while not self.quit:
            try:
                sock, addr = self.socket.accept()
                sock.settimeout(1)
                return (sock, addr)
            except socket.timeout:
                pass
        return (None, None)
 
    def close_request(self, request):
        if request is None:
            return
        SimpleXMLRPCServer.close_request(self, request)
 
    def process_request(self, request, client_address):
        if request is None:
            return
        SimpleXMLRPCServer.process_request(self, request, client_address)