[41] | 1 |
|
---|
[919] | 2 | from . import const
|
---|
| 3 | from . import util
|
---|
[1044] | 4 | from .rpc import Registration, BookedFlight
|
---|
[919] | 5 | from . import rpc
|
---|
| 6 | from . import rpccommon
|
---|
[41] | 7 |
|
---|
[919] | 8 | from .common import MAVA_BASE_URL
|
---|
| 9 | from .pirep import PIREP
|
---|
[740] | 10 |
|
---|
[41] | 11 | import threading
|
---|
| 12 | import sys
|
---|
[919] | 13 | import urllib.request, urllib.parse, urllib.error
|
---|
| 14 | import urllib.request, urllib.error, urllib.parse
|
---|
[41] | 15 | import hashlib
|
---|
[66] | 16 | import time
|
---|
[930] | 17 | import re
|
---|
[41] | 18 | import datetime
|
---|
| 19 | import codecs
|
---|
[106] | 20 | import traceback
|
---|
[63] | 21 | import xml.sax
|
---|
[919] | 22 | import xmlrpc.client
|
---|
| 23 | import html.parser
|
---|
[962] | 24 | import certifi
|
---|
[41] | 25 |
|
---|
| 26 | #---------------------------------------------------------------------------------------
|
---|
| 27 |
|
---|
[298] | 28 | ## @package mlx.web
|
---|
| 29 | #
|
---|
| 30 | # Web interface.
|
---|
| 31 | #
|
---|
| 32 | # This module implements a thread that can perform (HTTP) requests
|
---|
| 33 | # asynchronously. When the request is performed, a callback is called. The main
|
---|
| 34 | # interface is the \ref Handler class. Each of its functions creates a \ref
|
---|
| 35 | # Request subclass instance and puts it to the request queue. The handler
|
---|
| 36 | # thread then takes the requests one by one, and executes them.
|
---|
| 37 | #
|
---|
| 38 | # This module also defines some data classes the contents of which are
|
---|
| 39 | # retrieved or sent via HTTP. \ref BookedFlight contains data of a flight
|
---|
| 40 | # booked on the MAVA website, \ref Fleet and \ref Plane represents the MAVA
|
---|
| 41 | # fleet and the gates at Ferihegy and \ref NOTAM is a NOTAM.
|
---|
| 42 |
|
---|
| 43 | #---------------------------------------------------------------------------------------
|
---|
| 44 |
|
---|
[41] | 45 | def readline(f):
|
---|
| 46 | """Read a line from the given file.
|
---|
| 47 |
|
---|
| 48 | The line is stripped and empty lines are discarded."""
|
---|
| 49 | while True:
|
---|
| 50 | line = f.readline()
|
---|
| 51 | if not line: return ""
|
---|
| 52 | line = line.strip()
|
---|
| 53 | if line:
|
---|
| 54 | return line
|
---|
| 55 |
|
---|
| 56 | #------------------------------------------------------------------------------
|
---|
| 57 |
|
---|
[742] | 58 | class Plane(rpccommon.Plane):
|
---|
[51] | 59 | """Information about an airplane in the fleet."""
|
---|
| 60 | def __init__(self, s):
|
---|
| 61 | """Build a plane info based on the given string.
|
---|
| 62 |
|
---|
| 63 | The string consists of three, space-separated fields.
|
---|
| 64 | The first field is the tail number, the second field is the gate
|
---|
| 65 | number, the third field is the plane's status as a character."""
|
---|
[742] | 66 | super(Plane, self).__init__()
|
---|
| 67 |
|
---|
[51] | 68 | try:
|
---|
| 69 | words = s.split(" ")
|
---|
| 70 | tailNumber = words[0]
|
---|
| 71 | self.tailNumber = tailNumber
|
---|
| 72 |
|
---|
| 73 | status = words[2] if len(words)>2 else None
|
---|
[742] | 74 | self._setStatus(status)
|
---|
[51] | 75 |
|
---|
| 76 | gateNumber = words[1] if len(words)>1 else ""
|
---|
| 77 | self.gateNumber = gateNumber if gateNumber else None
|
---|
| 78 |
|
---|
| 79 | except:
|
---|
[919] | 80 | print("Plane string is invalid: '" + s + "'", file=sys.stderr)
|
---|
[51] | 81 | self.tailNumber = None
|
---|
| 82 |
|
---|
| 83 | #------------------------------------------------------------------------------
|
---|
| 84 |
|
---|
[742] | 85 | class Fleet(rpccommon.Fleet):
|
---|
[51] | 86 | """Information about the whole fleet."""
|
---|
| 87 | def __init__(self, f):
|
---|
| 88 | """Construct the fleet information by reading the given file object."""
|
---|
[742] | 89 | super(Fleet, self).__init__()
|
---|
| 90 |
|
---|
[51] | 91 | while True:
|
---|
| 92 | line = readline(f)
|
---|
| 93 | if not line or line == "#END": break
|
---|
| 94 |
|
---|
| 95 | plane = Plane(line)
|
---|
[742] | 96 | self._addPlane(plane)
|
---|
[443] | 97 |
|
---|
[51] | 98 | #------------------------------------------------------------------------------
|
---|
| 99 |
|
---|
[63] | 100 | class NOTAM(object):
|
---|
| 101 | """A NOTAM for an airport."""
|
---|
[570] | 102 | def __init__(self, ident, basic,
|
---|
| 103 | begin, notice, end = None, permanent = False,
|
---|
[63] | 104 | repeatCycle = None):
|
---|
| 105 | """Construct the NOTAM."""
|
---|
[570] | 106 | self.ident = ident
|
---|
| 107 | self.basic = basic
|
---|
[63] | 108 | self.begin = begin
|
---|
| 109 | self.notice = notice
|
---|
| 110 | self.end = end
|
---|
| 111 | self.permanent = permanent
|
---|
[570] | 112 | self.repeatCycle = repeatCycle
|
---|
[63] | 113 |
|
---|
| 114 | def __repr__(self):
|
---|
| 115 | """Get the representation of the NOTAM."""
|
---|
| 116 | s = "<NOTAM " + str(self.begin)
|
---|
| 117 | if self.end:
|
---|
| 118 | s += " - " + str(self.end)
|
---|
| 119 | elif self.permanent:
|
---|
| 120 | s += " - PERMANENT"
|
---|
| 121 | if self.repeatCycle:
|
---|
| 122 | s += " (" + self.repeatCycle + ")"
|
---|
| 123 | s += ": " + self.notice
|
---|
| 124 | s += ">"
|
---|
| 125 | return s
|
---|
[443] | 126 |
|
---|
[570] | 127 | def __str__(self):
|
---|
| 128 | """Get the string representation of the NOTAM."""
|
---|
| 129 | s = ""
|
---|
| 130 | s += str(self.ident) + " " + str(self.basic) + "\n"
|
---|
| 131 | s += str(self.begin)
|
---|
| 132 | if self.end is not None:
|
---|
| 133 | s += " - " + str(self.end)
|
---|
| 134 | elif self.permanent:
|
---|
| 135 | s += " - PERMANENT"
|
---|
| 136 | s += "\n"
|
---|
| 137 | if self.repeatCycle:
|
---|
| 138 | s += "Repeat cycle: " + self.repeatCycle + "\n"
|
---|
| 139 | s += self.notice + "\n"
|
---|
| 140 | return s
|
---|
| 141 |
|
---|
[63] | 142 | #------------------------------------------------------------------------------
|
---|
| 143 |
|
---|
| 144 | class NOTAMHandler(xml.sax.handler.ContentHandler):
|
---|
| 145 | """A handler for the NOTAM database."""
|
---|
| 146 | def __init__(self, airportICAOs):
|
---|
| 147 | """Construct the handler for the airports with the given ICAO code."""
|
---|
| 148 | self._notams = {}
|
---|
| 149 | for icao in airportICAOs:
|
---|
| 150 | self._notams[icao] = []
|
---|
| 151 |
|
---|
| 152 | def startElement(self, name, attrs):
|
---|
| 153 | """Start an element."""
|
---|
| 154 | if name!="notam" or \
|
---|
[570] | 155 | "ident" not in attrs or not attrs["ident"] or \
|
---|
| 156 | "Q" not in attrs or not attrs["Q"] or \
|
---|
[63] | 157 | "A" not in attrs or not attrs["A"] or \
|
---|
| 158 | "B" not in attrs or not attrs["B"] or \
|
---|
| 159 | "E" not in attrs or not attrs["E"]:
|
---|
| 160 | return
|
---|
[443] | 161 |
|
---|
[63] | 162 | icao = attrs["A"]
|
---|
| 163 | if icao not in self._notams:
|
---|
| 164 | return
|
---|
[443] | 165 |
|
---|
[63] | 166 | begin = datetime.datetime.strptime(attrs["B"], "%Y-%m-%d %H:%M:%S")
|
---|
| 167 |
|
---|
| 168 | c = attrs["C"] if "C" in attrs else None
|
---|
| 169 | end = datetime.datetime.strptime(c, "%Y-%m-%d %H:%M:%S") if c else None
|
---|
[443] | 170 |
|
---|
[63] | 171 | permanent = attrs["C_flag"]=="PERM" if "C_flag" in attrs else False
|
---|
[443] | 172 |
|
---|
[63] | 173 | repeatCycle = attrs["D"] if "D" in attrs else None
|
---|
| 174 |
|
---|
[570] | 175 | self._notams[icao].append(NOTAM(attrs["ident"], attrs["Q"],
|
---|
| 176 | begin, attrs["E"], end = end,
|
---|
[63] | 177 | permanent = permanent,
|
---|
| 178 | repeatCycle = repeatCycle))
|
---|
| 179 |
|
---|
| 180 | def get(self, icao):
|
---|
| 181 | """Get the NOTAMs for the given ICAO code."""
|
---|
| 182 | return self._notams[icao] if icao in self._notams else []
|
---|
| 183 |
|
---|
| 184 | #------------------------------------------------------------------------------
|
---|
| 185 |
|
---|
[919] | 186 | class PilotsWebNOTAMsParser(html.parser.HTMLParser):
|
---|
[570] | 187 | """XML handler for the NOTAM query results on the PilotsWeb website."""
|
---|
| 188 | def __init__(self):
|
---|
| 189 | """Construct the handler."""
|
---|
[919] | 190 | html.parser.HTMLParser.__init__(self)
|
---|
[570] | 191 |
|
---|
| 192 | self._notams = []
|
---|
| 193 | self._currentNOTAM = ""
|
---|
| 194 | self._stage = 0
|
---|
| 195 |
|
---|
| 196 | def handle_starttag(self, name, attrs):
|
---|
| 197 | """Start an element."""
|
---|
| 198 | if (self._stage==0 and name=="div" and ("id", "notamRight") in attrs) or \
|
---|
| 199 | (self._stage==1 and name=="span") or \
|
---|
| 200 | (self._stage==2 and name=="pre"):
|
---|
| 201 | self._stage += 1
|
---|
| 202 | if self._stage==1:
|
---|
| 203 | self._currentNOTAM = ""
|
---|
| 204 |
|
---|
| 205 | def handle_data(self, content):
|
---|
| 206 | """Handle characters"""
|
---|
| 207 | if self._stage==3:
|
---|
| 208 | self._currentNOTAM += content
|
---|
| 209 |
|
---|
| 210 | def handle_endtag(self, name):
|
---|
| 211 | """End an element."""
|
---|
| 212 | if (self._stage==3 and name=="pre") or \
|
---|
| 213 | (self._stage==2 and name=="span") or \
|
---|
| 214 | (self._stage==1 and name=="div"):
|
---|
| 215 | self._stage -= 1
|
---|
| 216 | if self._stage==0:
|
---|
| 217 | self._processCurrentNOTAM()
|
---|
| 218 |
|
---|
| 219 | def getNOTAMs(self):
|
---|
| 220 | """Get the NOTAMs collected"""
|
---|
| 221 | return self._notams
|
---|
| 222 |
|
---|
| 223 | def _processCurrentNOTAM(self):
|
---|
| 224 | """Parse the current NOTAM and append its contents to the list of
|
---|
| 225 | NOTAMS."""
|
---|
| 226 | notam = None
|
---|
| 227 | try:
|
---|
| 228 | notam = self._parseCurrentNOTAM2()
|
---|
[919] | 229 | except Exception as e:
|
---|
| 230 | print("Error parsing current NOTAM: " + str(e))
|
---|
[570] | 231 |
|
---|
| 232 | if notam is None:
|
---|
[919] | 233 | print("Could not parse NOTAM: " + self._currentNOTAM)
|
---|
[570] | 234 | if self._currentNOTAM:
|
---|
| 235 | self._notams.append(self._currentNOTAM + "\n")
|
---|
| 236 | else:
|
---|
| 237 | self._notams.append(notam)
|
---|
| 238 |
|
---|
| 239 | def _parseCurrentNOTAM(self):
|
---|
| 240 | """Parse the current NOTAM, if possible, and return a NOTAM object."""
|
---|
| 241 | lines = self._currentNOTAM.splitlines()
|
---|
[919] | 242 | lines = [line.strip() for line in lines]
|
---|
[570] | 243 |
|
---|
| 244 | if len(lines)<4:
|
---|
| 245 | return None
|
---|
| 246 |
|
---|
| 247 | if not lines[1].startswith("Q)") or \
|
---|
| 248 | not lines[2].startswith("A)") or \
|
---|
| 249 | not (lines[3].startswith("E)") or
|
---|
| 250 | (lines[3].startswith("D)") and lines[4].startswith("E)"))):
|
---|
| 251 | return None
|
---|
| 252 |
|
---|
| 253 | ident = lines[0].split()[0]
|
---|
| 254 | basic = lines[1][2:].strip()
|
---|
| 255 |
|
---|
| 256 | words = lines[2].split()
|
---|
| 257 | if len(words)<4 or words[0]!="A)" or words[2]!="B)":
|
---|
| 258 | return None
|
---|
| 259 |
|
---|
| 260 | begin = datetime.datetime.strptime(words[3], "%y%m%d%H%M")
|
---|
| 261 | end = None
|
---|
| 262 | permanent = False
|
---|
| 263 | if words[4]=="C)" and len(words)>=6:
|
---|
| 264 | if words[5] in ["PERM", "UFN"]:
|
---|
| 265 | permanent = True
|
---|
| 266 | else:
|
---|
| 267 | end = datetime.datetime.strptime(words[5], "%y%m%d%H%M")
|
---|
| 268 | else:
|
---|
| 269 | permanent = True
|
---|
| 270 |
|
---|
| 271 | repeatCycle = None
|
---|
| 272 | noticeStartIndex = 3
|
---|
| 273 | if lines[3].startswith("D)"):
|
---|
| 274 | repeatCycle = lines[3][2:].strip()
|
---|
| 275 | noticeStartIndex = 4
|
---|
| 276 |
|
---|
| 277 | notice = ""
|
---|
| 278 | for index in range(noticeStartIndex, len(lines)):
|
---|
| 279 | line = lines[index][2:] if index==noticeStartIndex else lines[index]
|
---|
| 280 | line = line.strip()
|
---|
| 281 |
|
---|
| 282 | if line.lower().startswith("created:") or \
|
---|
| 283 | line.lower().startswith("source:"):
|
---|
| 284 | break
|
---|
| 285 |
|
---|
| 286 | if notice: notice += " "
|
---|
| 287 | notice += line
|
---|
| 288 |
|
---|
| 289 | return NOTAM(ident, basic, begin, notice, end = end,
|
---|
| 290 | permanent = permanent, repeatCycle = repeatCycle)
|
---|
| 291 |
|
---|
| 292 | def _parseCurrentNOTAM2(self):
|
---|
| 293 | """Parse the current NOTAM with a second, more flexible method."""
|
---|
[930] | 294 | self._currentNOTAM = self._currentNOTAM.replace("\\n", "\n")
|
---|
[570] | 295 | lines = self._currentNOTAM.splitlines()
|
---|
[930] | 296 | if len(lines)==1:
|
---|
| 297 | lines = lines[0].splitlines()
|
---|
[919] | 298 | lines = [line.strip() for line in lines]
|
---|
[570] | 299 |
|
---|
| 300 | if not lines:
|
---|
| 301 | return None
|
---|
| 302 |
|
---|
| 303 | ident = lines[0].split()[0]
|
---|
| 304 |
|
---|
| 305 | lines = lines[1:]
|
---|
| 306 | for i in range(0, 2):
|
---|
| 307 | l = lines[-1].lower()
|
---|
| 308 | if l.startswith("created:") or l.startswith("source:"):
|
---|
| 309 | lines = lines[:-1]
|
---|
| 310 |
|
---|
[919] | 311 | lines = [line.strip() for line in lines]
|
---|
[570] | 312 | contents = " ".join(lines).split()
|
---|
| 313 |
|
---|
| 314 | items = {}
|
---|
| 315 | for i in ["Q)", "A)", "B)", "C)", "D)", "E)"]:
|
---|
| 316 | items[i] = ""
|
---|
| 317 |
|
---|
| 318 | currentItem = None
|
---|
| 319 | for word in contents:
|
---|
| 320 | if word in items:
|
---|
| 321 | currentItem = word
|
---|
| 322 | elif currentItem in items:
|
---|
| 323 | s = items[currentItem]
|
---|
| 324 | if s: s+= " "
|
---|
| 325 | s += word
|
---|
| 326 | items[currentItem] = s
|
---|
| 327 |
|
---|
| 328 | if not items["Q)"] or not items["A)"] or not items["B)"] or \
|
---|
| 329 | not items["E)"]:
|
---|
| 330 | return None
|
---|
| 331 |
|
---|
[806] | 332 | def parseTime(item):
|
---|
[930] | 333 | item = re.sub("([0-9]+).*", "\\1", item)
|
---|
[806] | 334 | try:
|
---|
| 335 | return datetime.datetime.strptime(item, "%y%m%d%H%M")
|
---|
| 336 | except ValueError:
|
---|
| 337 | return datetime.datetime.strptime(item, "%Y%m%d%H%M")
|
---|
| 338 |
|
---|
[570] | 339 | basic = items["Q)"]
|
---|
[806] | 340 | begin = parseTime(items["B)"])
|
---|
[570] | 341 |
|
---|
| 342 | end = None
|
---|
| 343 | permanent = False
|
---|
| 344 | if items["C)"]:
|
---|
| 345 | endItem = items["C)"]
|
---|
| 346 | if endItem in ["PERM", "UFN"]:
|
---|
| 347 | permanent = True
|
---|
| 348 | else:
|
---|
[806] | 349 | end = parseTime(items["C)"])
|
---|
[570] | 350 | else:
|
---|
| 351 | permanent = True
|
---|
| 352 |
|
---|
| 353 | repeatCycle = None
|
---|
| 354 | if items["D)"]:
|
---|
| 355 | repeatCycle = items["D)"]
|
---|
| 356 |
|
---|
| 357 | notice = items["E)"]
|
---|
| 358 |
|
---|
| 359 | return NOTAM(ident, basic, begin, notice, end = end,
|
---|
| 360 | permanent = permanent, repeatCycle = repeatCycle)
|
---|
| 361 |
|
---|
| 362 | #------------------------------------------------------------------------------
|
---|
| 363 |
|
---|
[41] | 364 | class Result(object):
|
---|
| 365 | """A result object.
|
---|
| 366 |
|
---|
| 367 | An instance of this filled with the appropriate data is passed to the
|
---|
| 368 | callback function on each request."""
|
---|
| 369 |
|
---|
| 370 | def __repr__(self):
|
---|
| 371 | """Get a representation of the result."""
|
---|
| 372 | s = "<Result:"
|
---|
[919] | 373 | for (key, value) in self.__dict__.items():
|
---|
| 374 | s += " " + key + "=" + str(value)
|
---|
[41] | 375 | s += ">"
|
---|
| 376 | return s
|
---|
| 377 |
|
---|
| 378 | #------------------------------------------------------------------------------
|
---|
| 379 |
|
---|
| 380 | class Request(object):
|
---|
| 381 | """Base class for requests.
|
---|
| 382 |
|
---|
| 383 | It handles any exceptions and the calling of the callback.
|
---|
| 384 |
|
---|
| 385 | If an exception occurs during processing, the callback is called with
|
---|
| 386 | the two parameters: a boolean value of False, and the exception object.
|
---|
| 387 |
|
---|
| 388 | If no exception occurs, the callback is called with True and the return
|
---|
| 389 | value of the run() function.
|
---|
| 390 |
|
---|
| 391 | If the callback function throws an exception, that is caught and logged
|
---|
| 392 | to the debug log."""
|
---|
| 393 | def __init__(self, callback):
|
---|
| 394 | """Construct the request."""
|
---|
| 395 | self._callback = callback
|
---|
| 396 |
|
---|
| 397 | def perform(self):
|
---|
| 398 | """Perform the request.
|
---|
| 399 |
|
---|
| 400 | The object's run() function is called. If it throws an exception,
|
---|
| 401 | the callback is called with False, and the exception. Otherwise the
|
---|
| 402 | callback is called with True and the return value of the run()
|
---|
| 403 | function. Any exceptions thrown by the callback are caught and
|
---|
| 404 | reported."""
|
---|
| 405 | try:
|
---|
| 406 | result = self.run()
|
---|
| 407 | returned = True
|
---|
[919] | 408 | except Exception as e:
|
---|
[106] | 409 | traceback.print_exc()
|
---|
[41] | 410 | result = e
|
---|
| 411 | returned = False
|
---|
| 412 |
|
---|
| 413 | try:
|
---|
| 414 | self._callback(returned, result)
|
---|
[919] | 415 | except Exception as e:
|
---|
| 416 | print("web.Handler.Request.perform: callback throwed an exception: " + util.utf2unicode(str(e)), file=sys.stderr)
|
---|
[570] | 417 | #traceback.print_exc()
|
---|
[41] | 418 |
|
---|
| 419 | #------------------------------------------------------------------------------
|
---|
| 420 |
|
---|
[746] | 421 | class RPCRequest(Request):
|
---|
| 422 | """Common base class for RPC requests.
|
---|
| 423 |
|
---|
| 424 | It stores the RPC client received from the handler."""
|
---|
| 425 | def __init__(self, client, callback):
|
---|
| 426 | """Construct the request."""
|
---|
| 427 | super(RPCRequest, self).__init__(callback)
|
---|
| 428 | self._client = client
|
---|
| 429 |
|
---|
| 430 | #------------------------------------------------------------------------------
|
---|
| 431 |
|
---|
[756] | 432 | class Register(RPCRequest):
|
---|
| 433 | """A registration request."""
|
---|
| 434 | def __init__(self, client, callback, registrationData):
|
---|
| 435 | """Construct the request."""
|
---|
| 436 | super(Register, self).__init__(client, callback)
|
---|
| 437 | self._registrationData = registrationData
|
---|
| 438 |
|
---|
| 439 | def run(self):
|
---|
| 440 | """Perform the registration."""
|
---|
| 441 |
|
---|
| 442 | registrationData = self._registrationData
|
---|
| 443 |
|
---|
| 444 | (resultCode, pilotID) = self._client.register(registrationData)
|
---|
| 445 | result = Result()
|
---|
| 446 | result.registered = resultCode==rpc.Client.RESULT_OK
|
---|
| 447 | if result.registered:
|
---|
| 448 | result.pilotID = pilotID
|
---|
| 449 |
|
---|
| 450 | self._client.setCredentials(pilotID, registrationData.password)
|
---|
[771] | 451 | LoginRPC.setupLoginResult(result, self._client, pilotID,
|
---|
| 452 | registrationData.password)
|
---|
[756] | 453 |
|
---|
| 454 | result.invalidData = \
|
---|
| 455 | resultCode==rpc.Client.RESULT_INVALID_DATA
|
---|
| 456 | result.emailAlreadyRegistered = \
|
---|
| 457 | resultCode==rpc.Client.RESULT_EMAIL_ALREADY_REGISTERED
|
---|
| 458 |
|
---|
| 459 | return result
|
---|
| 460 |
|
---|
| 461 | #------------------------------------------------------------------------------
|
---|
| 462 |
|
---|
[746] | 463 | class LoginRPC(RPCRequest):
|
---|
| 464 | """An RPC-based login request."""
|
---|
[771] | 465 | @staticmethod
|
---|
| 466 | def setupLoginResult(result, client, pilotID, password):
|
---|
| 467 | """Setup the login result with the given client, pilot ID and
|
---|
| 468 | password."""
|
---|
| 469 | loginResult = client.login()
|
---|
| 470 | result.loggedIn = loginResult is not None
|
---|
| 471 | if result.loggedIn:
|
---|
| 472 | result.pilotID = pilotID
|
---|
| 473 | result.pilotName = loginResult[0]
|
---|
| 474 | result.rank = loginResult[1]
|
---|
[858] | 475 | result.types = loginResult[2]
|
---|
[771] | 476 | result.password = password
|
---|
[1044] | 477 | result.fleet = client.getFleet()
|
---|
[809] | 478 | flights = client.getFlights()
|
---|
| 479 | result.flights = flights[0]
|
---|
| 480 | result.reportedFlights = flights[1]
|
---|
| 481 | result.rejectedFlights = flights[2]
|
---|
[771] | 482 | if result.rank=="STU":
|
---|
| 483 | reply = client.getEntryExamStatus()
|
---|
| 484 | result.entryExamPassed = reply[0]
|
---|
| 485 | result.entryExamLink = reply[1]
|
---|
| 486 | result.checkFlightStatus = reply[2]
|
---|
| 487 | if reply[3]:
|
---|
| 488 | result.rank = "FO"
|
---|
| 489 |
|
---|
[858] | 490 |
|
---|
[760] | 491 | def __init__(self, client, callback, pilotID, password):
|
---|
[746] | 492 | """Construct the login request with the given pilot ID and
|
---|
| 493 | password."""
|
---|
| 494 | super(LoginRPC, self).__init__(client, callback)
|
---|
| 495 |
|
---|
| 496 | self._pilotID = pilotID
|
---|
| 497 | self._password = password
|
---|
| 498 |
|
---|
| 499 | def run(self):
|
---|
| 500 | """Perform the login request."""
|
---|
| 501 | result = Result()
|
---|
| 502 |
|
---|
| 503 | self._client.setCredentials(self._pilotID, self._password)
|
---|
[771] | 504 | LoginRPC.setupLoginResult(result, self._client,
|
---|
| 505 | self._pilotID, self._password)
|
---|
[761] | 506 |
|
---|
| 507 | return result
|
---|
| 508 |
|
---|
| 509 | #------------------------------------------------------------------------------
|
---|
| 510 |
|
---|
| 511 | class GetEntryExamStatus(RPCRequest):
|
---|
| 512 | """A request to get the entry exam status."""
|
---|
| 513 | def __init__(self, client, callback):
|
---|
| 514 | """Construct the request."""
|
---|
| 515 | super(GetEntryExamStatus, self).__init__(client, callback)
|
---|
| 516 |
|
---|
| 517 | def run(self):
|
---|
| 518 | """Perform the query."""
|
---|
| 519 | result = Result()
|
---|
| 520 |
|
---|
| 521 | reply = self._client.getEntryExamStatus()
|
---|
| 522 |
|
---|
| 523 | result.entryExamPassed = reply[0]
|
---|
[764] | 524 | result.entryExamLink = reply[1]
|
---|
| 525 | result.checkFlightStatus = reply[2]
|
---|
[769] | 526 | result.madeFO = reply[3]
|
---|
[746] | 527 |
|
---|
| 528 | return result
|
---|
| 529 |
|
---|
| 530 | #------------------------------------------------------------------------------
|
---|
| 531 |
|
---|
| 532 | class GetFleetRPC(RPCRequest):
|
---|
| 533 | """Request to get the fleet from the website using RPC."""
|
---|
| 534 | def __init__(self, client, callback):
|
---|
| 535 | """Construct the request with the given client and callback function."""
|
---|
| 536 | super(GetFleetRPC, self).__init__(client, callback)
|
---|
| 537 |
|
---|
| 538 | def run(self):
|
---|
| 539 | """Perform the login request."""
|
---|
| 540 | result = Result()
|
---|
| 541 |
|
---|
| 542 | result.fleet = self._client.getFleet()
|
---|
| 543 |
|
---|
| 544 | return result
|
---|
| 545 |
|
---|
| 546 | #------------------------------------------------------------------------------
|
---|
| 547 |
|
---|
| 548 | class UpdatePlaneRPC(RPCRequest):
|
---|
| 549 | """RPC request to update the status and the position of a plane in the
|
---|
| 550 | fleet."""
|
---|
| 551 | def __init__(self, client, callback, tailNumber, status, gateNumber = None):
|
---|
| 552 | """Construct the request."""
|
---|
| 553 | super(UpdatePlaneRPC, self).__init__(client, callback)
|
---|
| 554 | self._tailNumber = tailNumber
|
---|
| 555 | self._status = status
|
---|
| 556 | self._gateNumber = gateNumber
|
---|
| 557 |
|
---|
| 558 | def run(self):
|
---|
| 559 | """Perform the plane update."""
|
---|
| 560 | self._client.updatePlane(self._tailNumber, self._status, self._gateNumber)
|
---|
| 561 |
|
---|
| 562 | # Otherwise an exception is thrown
|
---|
| 563 | result = Result()
|
---|
| 564 | result.success = True
|
---|
| 565 |
|
---|
| 566 | return result
|
---|
| 567 |
|
---|
| 568 | #------------------------------------------------------------------------------
|
---|
| 569 |
|
---|
[63] | 570 | class GetNOTAMs(Request):
|
---|
| 571 | """Get the NOTAMs from EURoutePro and select the ones we are interested
|
---|
| 572 | in."""
|
---|
| 573 | def __init__(self, callback, departureICAO, arrivalICAO):
|
---|
| 574 | """Construct the request for the given airports."""
|
---|
| 575 | super(GetNOTAMs, self).__init__(callback)
|
---|
| 576 | self._departureICAO = departureICAO
|
---|
| 577 | self._arrivalICAO = arrivalICAO
|
---|
| 578 |
|
---|
| 579 | def run(self):
|
---|
[66] | 580 | """Perform the retrieval of the NOTAMs."""
|
---|
[570] | 581 | departureNOTAMs = self.getPilotsWebNOTAMs(self._departureICAO)
|
---|
| 582 | arrivalNOTAMs = self.getPilotsWebNOTAMs(self._arrivalICAO)
|
---|
[63] | 583 |
|
---|
[570] | 584 | icaos = []
|
---|
| 585 | if not departureNOTAMs: icaos.append(self._departureICAO)
|
---|
| 586 | if not arrivalNOTAMs: icaos.append(self._arrivalICAO)
|
---|
| 587 |
|
---|
| 588 | if icaos:
|
---|
| 589 | xmlParser = xml.sax.make_parser()
|
---|
| 590 | notamHandler = NOTAMHandler(icaos)
|
---|
| 591 | xmlParser.setContentHandler(notamHandler)
|
---|
[63] | 592 |
|
---|
[570] | 593 | url = "http://notams.euroutepro.com/notams.xml"
|
---|
| 594 |
|
---|
[919] | 595 | f = urllib.request.urlopen(url, timeout = 10.0)
|
---|
[570] | 596 | try:
|
---|
| 597 | xmlParser.parse(f)
|
---|
| 598 | finally:
|
---|
| 599 | f.close()
|
---|
| 600 |
|
---|
| 601 | for icao in icaos:
|
---|
| 602 | if icao==self._departureICAO:
|
---|
| 603 | departureNOTAMs = notamHandler.get(icao)
|
---|
| 604 | else:
|
---|
| 605 | arrivalNOTAMs = notamHandler.get(icao)
|
---|
[63] | 606 |
|
---|
| 607 | result = Result()
|
---|
[570] | 608 | result.departureNOTAMs = departureNOTAMs
|
---|
| 609 | result.arrivalNOTAMs = arrivalNOTAMs
|
---|
[63] | 610 |
|
---|
| 611 | return result
|
---|
| 612 |
|
---|
[570] | 613 | def getPilotsWebNOTAMs(self, icao):
|
---|
| 614 | """Try to get the NOTAMs from FAA's PilotsWeb site for the given ICAO
|
---|
| 615 | code.
|
---|
| 616 |
|
---|
| 617 | Returns a list of PilotsWEBNOTAM objects, or None in case of an error."""
|
---|
| 618 | try:
|
---|
| 619 | parser = PilotsWebNOTAMsParser()
|
---|
| 620 |
|
---|
| 621 | url = "https://pilotweb.nas.faa.gov/PilotWeb/notamRetrievalByICAOAction.do?method=displayByICAOs&formatType=ICAO&retrieveLocId=%s&reportType=RAW&actionType=notamRetrievalByICAOs" % \
|
---|
| 622 | (icao.upper(),)
|
---|
| 623 |
|
---|
[1053] | 624 | request = urllib.request.Request(url, headers = {
|
---|
| 625 | "cookie": "akamai_pilotweb_access=true;"
|
---|
| 626 | });
|
---|
| 627 | f = urllib.request.urlopen(request, timeout = 10.0, cafile=certifi.where())
|
---|
[570] | 628 | try:
|
---|
| 629 | data = f.read(16384)
|
---|
| 630 | while data:
|
---|
[928] | 631 | parser.feed(str(data))
|
---|
[570] | 632 | data = f.read(16384)
|
---|
| 633 | finally:
|
---|
| 634 | f.close()
|
---|
| 635 |
|
---|
| 636 | return parser.getNOTAMs()
|
---|
| 637 |
|
---|
[919] | 638 | except Exception as e:
|
---|
[570] | 639 | traceback.print_exc()
|
---|
[919] | 640 | print("mlx.web.GetNOTAMs.getPilotsWebNOTAMs: failed to get NOTAMs for '%s': %s" % \
|
---|
| 641 | (icao, str(e)))
|
---|
[570] | 642 | return None
|
---|
| 643 |
|
---|
[63] | 644 | #------------------------------------------------------------------------------
|
---|
| 645 |
|
---|
[66] | 646 | class GetMETARs(Request):
|
---|
[443] | 647 | """Get the METARs from the NOAA website for certain airport ICAOs."""
|
---|
[66] | 648 |
|
---|
| 649 | def __init__(self, callback, airports):
|
---|
| 650 | """Construct the request for the given airports."""
|
---|
| 651 | super(GetMETARs, self).__init__(callback)
|
---|
| 652 | self._airports = airports
|
---|
| 653 |
|
---|
| 654 | def run(self):
|
---|
| 655 | """Perform the retrieval opf the METARs."""
|
---|
[74] | 656 | url = "http://www.aviationweather.gov/adds/dataserver_current/httpparam?"
|
---|
[919] | 657 | data = urllib.parse.urlencode([ ("dataSource" , "metars"),
|
---|
[443] | 658 | ("requestType", "retrieve"),
|
---|
[74] | 659 | ("format", "csv"),
|
---|
| 660 | ("stationString", " ".join(self._airports)),
|
---|
| 661 | ("hoursBeforeNow", "24"),
|
---|
| 662 | ("mostRecentForEachStation", "constraint")])
|
---|
[963] | 663 | result = Result()
|
---|
| 664 | result.metars = {}
|
---|
[66] | 665 | try:
|
---|
[963] | 666 | url += data
|
---|
| 667 | f = urllib.request.urlopen(url, timeout = 10.0, cafile = certifi.where())
|
---|
| 668 | try:
|
---|
| 669 | for line in f.readlines():
|
---|
| 670 | line = str(line, "iso-8859-1")
|
---|
| 671 | if len(line)>5 and line[4]==' ':
|
---|
| 672 | icao = line[0:4]
|
---|
| 673 | if icao in self._airports:
|
---|
| 674 | result.metars[icao] = line.strip().split(",")[0]
|
---|
| 675 | finally:
|
---|
| 676 | f.close()
|
---|
| 677 | except Exception as e:
|
---|
| 678 | traceback.print_exc()
|
---|
| 679 | print("mlx.web.GetMETARs.run: failed to get METARs for %s: %s" % \
|
---|
| 680 | (self._airports, str(e)))
|
---|
[66] | 681 |
|
---|
| 682 | return result
|
---|
| 683 |
|
---|
| 684 | #------------------------------------------------------------------------------
|
---|
| 685 |
|
---|
[746] | 686 | class SendPIREPRPC(RPCRequest):
|
---|
| 687 | """A request to send a PIREP to the MAVA website via the RPC interface."""
|
---|
| 688 |
|
---|
[853] | 689 | def __init__(self, client, callback, pirep, update):
|
---|
[746] | 690 | """Construct the sending of the PIREP."""
|
---|
| 691 | super(SendPIREPRPC, self).__init__(client, callback)
|
---|
| 692 | self._pirep = pirep
|
---|
[853] | 693 | self._update = update
|
---|
[746] | 694 |
|
---|
| 695 | def run(self):
|
---|
| 696 | """Perform the sending of the PIREP."""
|
---|
| 697 | pirep = self._pirep
|
---|
[853] | 698 | resultCode = self._client.addPIREP(pirep.bookedFlight.id, pirep,
|
---|
| 699 | self._update)
|
---|
[746] | 700 |
|
---|
| 701 | result = Result()
|
---|
| 702 | result.success = resultCode==rpc.Client.RESULT_OK
|
---|
| 703 | result.alreadyFlown = resultCode==rpc.Client.RESULT_FLIGHT_ALREADY_REPORTED
|
---|
| 704 | result.notAvailable = resultCode==rpc.Client.RESULT_FLIGHT_NOT_EXISTS
|
---|
| 705 |
|
---|
| 706 | return result
|
---|
| 707 |
|
---|
| 708 | #------------------------------------------------------------------------------
|
---|
| 709 |
|
---|
| 710 | class SendACARSRPC(RPCRequest):
|
---|
| 711 | """A request to send an ACARS to the MAVA website via JSON-RPC."""
|
---|
| 712 | def __init__(self, client, callback, acars):
|
---|
| 713 | """Construct the request for the given PIREP."""
|
---|
| 714 | super(SendACARSRPC, self).__init__(client, callback)
|
---|
| 715 | self._acars = acars
|
---|
| 716 |
|
---|
| 717 | def run(self):
|
---|
| 718 | """Perform the sending of the ACARS."""
|
---|
[919] | 719 | print("Sending the online ACARS via JSON-RPC")
|
---|
[746] | 720 |
|
---|
| 721 | self._client.updateOnlineACARS(self._acars)
|
---|
| 722 | return Result()
|
---|
| 723 |
|
---|
| 724 | #------------------------------------------------------------------------------
|
---|
| 725 |
|
---|
[484] | 726 | class SendBugReport(Request):
|
---|
| 727 | """A request to send a bug report to the project homepage."""
|
---|
| 728 | _latin2Encoder = codecs.getencoder("iso-8859-2")
|
---|
| 729 |
|
---|
| 730 | def __init__(self, callback, summary, description, email):
|
---|
| 731 | """Construct the request for the given bug report."""
|
---|
| 732 | super(SendBugReport, self).__init__(callback)
|
---|
| 733 | self._summary = summary
|
---|
| 734 | self._description = description
|
---|
| 735 | self._email = email
|
---|
| 736 |
|
---|
| 737 | def run(self):
|
---|
| 738 | """Perform the sending of the bug report."""
|
---|
[919] | 739 | serverProxy = xmlrpc.client.ServerProxy("http://mlx.varadiistvan.hu/rpc")
|
---|
[484] | 740 |
|
---|
| 741 | result = Result()
|
---|
[491] | 742 | result.success = False
|
---|
[488] | 743 |
|
---|
| 744 | attributes = {}
|
---|
| 745 | if self._email:
|
---|
| 746 | attributes["reporter"] = self._email
|
---|
| 747 |
|
---|
[491] | 748 | result.ticketID = serverProxy.ticket.create(self._summary, self._description,
|
---|
| 749 | attributes, True)
|
---|
[919] | 750 | print("Created ticket with ID:", result.ticketID)
|
---|
[484] | 751 | result.success = True
|
---|
| 752 |
|
---|
| 753 | return result
|
---|
| 754 |
|
---|
| 755 | #------------------------------------------------------------------------------
|
---|
| 756 |
|
---|
[769] | 757 | class SetCheckFlightPassed(RPCRequest):
|
---|
| 758 | """A request to mark the user as one having passed the check flight."""
|
---|
| 759 | def __init__(self, client, callback, aircraftType):
|
---|
| 760 | """Construct the request for the given type."""
|
---|
| 761 | super(SetCheckFlightPassed, self).__init__(client, callback)
|
---|
| 762 | self._aircraftType = aircraftType
|
---|
| 763 |
|
---|
| 764 | def run(self):
|
---|
| 765 | """Perform the update."""
|
---|
| 766 | aircraftType = BookedFlight.TYPE2TYPECODE[self._aircraftType]
|
---|
| 767 | self._client.setCheckFlightPassed(aircraftType)
|
---|
| 768 | return Result()
|
---|
| 769 |
|
---|
| 770 | #------------------------------------------------------------------------------
|
---|
| 771 |
|
---|
[829] | 772 | class GetPIREP(RPCRequest):
|
---|
| 773 | """A request to retrieve the PIREP of a certain flight."""
|
---|
| 774 | def __init__(self, client, callback, flightID):
|
---|
| 775 | """Construct the request."""
|
---|
| 776 | super(GetPIREP, self).__init__(client, callback)
|
---|
| 777 | self._flightID = flightID
|
---|
| 778 |
|
---|
| 779 | def run(self):
|
---|
| 780 | """Perform the update."""
|
---|
| 781 | result = Result()
|
---|
| 782 |
|
---|
| 783 | pirepData = self._client.getPIREP(self._flightID)
|
---|
[919] | 784 | print("pirepData:", pirepData)
|
---|
[829] | 785 |
|
---|
[1044] | 786 | bookedFlight = BookedFlight(id = self._flightID)
|
---|
[829] | 787 | bookedFlight.setupFromPIREPData(pirepData)
|
---|
| 788 |
|
---|
| 789 | result.pirep = PIREP(None)
|
---|
| 790 | result.pirep.setupFromPIREPData(pirepData, bookedFlight)
|
---|
| 791 |
|
---|
| 792 | return result
|
---|
| 793 |
|
---|
| 794 | #------------------------------------------------------------------------------
|
---|
| 795 |
|
---|
[821] | 796 | class ReflyFlights(RPCRequest):
|
---|
| 797 | """A request to mark certain flights for reflying."""
|
---|
| 798 | def __init__(self, client, callback, flightIDs):
|
---|
| 799 | """Construct the request."""
|
---|
| 800 | super(ReflyFlights, self).__init__(client, callback)
|
---|
| 801 | self._flightIDs = flightIDs
|
---|
| 802 |
|
---|
| 803 | def run(self):
|
---|
| 804 | """Perform the update."""
|
---|
| 805 | self._client.reflyFlights(self._flightIDs)
|
---|
| 806 | return Result()
|
---|
| 807 |
|
---|
| 808 | #------------------------------------------------------------------------------
|
---|
| 809 |
|
---|
[824] | 810 | class DeleteFlights(RPCRequest):
|
---|
| 811 | """A request to delete certain flights."""
|
---|
| 812 | def __init__(self, client, callback, flightIDs):
|
---|
| 813 | """Construct the request."""
|
---|
| 814 | super(DeleteFlights, self).__init__(client, callback)
|
---|
| 815 | self._flightIDs = flightIDs
|
---|
| 816 |
|
---|
| 817 | def run(self):
|
---|
| 818 | """Perform the update."""
|
---|
| 819 | self._client.deleteFlights(self._flightIDs)
|
---|
| 820 | return Result()
|
---|
| 821 |
|
---|
| 822 | #------------------------------------------------------------------------------
|
---|
| 823 |
|
---|
[854] | 824 | class GetAcceptedFlights(RPCRequest):
|
---|
| 825 | """Request to get the accepted flights."""
|
---|
| 826 | def __init__(self, client, callback):
|
---|
| 827 | """Construct the request with the given client and callback function."""
|
---|
| 828 | super(GetAcceptedFlights, self).__init__(client, callback)
|
---|
| 829 |
|
---|
| 830 | def run(self):
|
---|
| 831 | """Perform the login request."""
|
---|
| 832 | result = Result()
|
---|
| 833 |
|
---|
| 834 | result.flights = self._client.getAcceptedFlights()
|
---|
| 835 |
|
---|
| 836 | return result
|
---|
| 837 |
|
---|
| 838 | #------------------------------------------------------------------------------
|
---|
| 839 |
|
---|
[858] | 840 | class GetTimetable(RPCRequest):
|
---|
| 841 | """Request to get the timetable."""
|
---|
| 842 | def __init__(self, client, callback, date, types):
|
---|
| 843 | """Construct the request with the given client and callback function."""
|
---|
| 844 | super(GetTimetable, self).__init__(client, callback)
|
---|
| 845 | self._date = date
|
---|
| 846 | self._types = types
|
---|
| 847 |
|
---|
| 848 | def run(self):
|
---|
| 849 | """Perform the login request."""
|
---|
| 850 | result = Result()
|
---|
| 851 |
|
---|
| 852 | result.flightPairs = self._client.getTimetable(self._date, self._types)
|
---|
| 853 |
|
---|
| 854 | return result
|
---|
| 855 |
|
---|
| 856 | #------------------------------------------------------------------------------
|
---|
| 857 |
|
---|
[859] | 858 | class BookFlights(RPCRequest):
|
---|
| 859 | """Request to book flights."""
|
---|
| 860 | def __init__(self, client, callback, flightIDs, date, tailNumber):
|
---|
| 861 | """Construct the request with the given client and callback function."""
|
---|
| 862 | super(BookFlights, self).__init__(client, callback)
|
---|
| 863 | self._flightIDs = flightIDs
|
---|
| 864 | self._date = date
|
---|
| 865 | self._tailNumber = tailNumber
|
---|
| 866 |
|
---|
| 867 | def run(self):
|
---|
| 868 | """Perform the login request."""
|
---|
| 869 | result = Result()
|
---|
| 870 |
|
---|
| 871 | result.bookedFlights = self._client.bookFlights(self._flightIDs,
|
---|
| 872 | self._date,
|
---|
| 873 | self._tailNumber)
|
---|
| 874 |
|
---|
| 875 | return result
|
---|
| 876 |
|
---|
| 877 | #------------------------------------------------------------------------------
|
---|
| 878 |
|
---|
[41] | 879 | class Handler(threading.Thread):
|
---|
| 880 | """The handler for the web services.
|
---|
| 881 |
|
---|
| 882 | It can process one request at a time. The results are passed to a callback
|
---|
| 883 | function."""
|
---|
[746] | 884 | def __init__(self, config, getCredentialsFn):
|
---|
[41] | 885 | """Construct the handler."""
|
---|
| 886 | super(Handler, self).__init__()
|
---|
| 887 |
|
---|
| 888 | self._requests = []
|
---|
| 889 | self._requestCondition = threading.Condition()
|
---|
| 890 |
|
---|
| 891 | self.daemon = True
|
---|
[746] | 892 | self._config = config
|
---|
| 893 | self._rpcClient = rpc.Client(getCredentialsFn)
|
---|
| 894 | if config.rememberPassword:
|
---|
| 895 | self._rpcClient.setCredentials(config.pilotID, config.password)
|
---|
[41] | 896 |
|
---|
[756] | 897 | def register(self, callback, registrationData):
|
---|
| 898 | """Enqueue a registration request."""
|
---|
| 899 | self._addRequest(Register(self._rpcClient, callback, registrationData))
|
---|
| 900 |
|
---|
[760] | 901 | def login(self, callback, pilotID, password):
|
---|
[41] | 902 | """Enqueue a login request."""
|
---|
[1044] | 903 | request = LoginRPC(self._rpcClient, callback, pilotID, password)
|
---|
[746] | 904 |
|
---|
| 905 | self._addRequest(request)
|
---|
[41] | 906 |
|
---|
[761] | 907 | def getEntryExamStatus(self, callback):
|
---|
| 908 | """Get the entry exam status."""
|
---|
| 909 | self._addRequest(GetEntryExamStatus(self._rpcClient, callback))
|
---|
| 910 |
|
---|
[51] | 911 | def getFleet(self, callback):
|
---|
| 912 | """Enqueue a fleet retrieval request."""
|
---|
[1044] | 913 | request = GetFleetRPC(self._rpcClient, callback,)
|
---|
[746] | 914 | self._addRequest(request)
|
---|
[443] | 915 |
|
---|
[51] | 916 | def updatePlane(self, callback, tailNumber, status, gateNumber = None):
|
---|
[443] | 917 | """Update the status of the given plane."""
|
---|
[1044] | 918 | request = UpdatePlaneRPC(self._rpcClient, callback,
|
---|
| 919 | tailNumber, status, gateNumber)
|
---|
[746] | 920 | self._addRequest(request)
|
---|
[63] | 921 |
|
---|
| 922 | def getNOTAMs(self, callback, departureICAO, arrivalICAO):
|
---|
| 923 | """Get the NOTAMs for the given two airports."""
|
---|
| 924 | self._addRequest(GetNOTAMs(callback, departureICAO, arrivalICAO))
|
---|
[443] | 925 |
|
---|
[66] | 926 | def getMETARs(self, callback, airports):
|
---|
| 927 | """Get the METARs for the given airports."""
|
---|
| 928 | self._addRequest(GetMETARs(callback, airports))
|
---|
[97] | 929 |
|
---|
[853] | 930 | def sendPIREP(self, callback, pirep, update = False):
|
---|
[97] | 931 | """Send the given PIREP."""
|
---|
[1044] | 932 | request = SendPIREPRPC(self._rpcClient, callback, pirep, update)
|
---|
[746] | 933 | self._addRequest(request)
|
---|
[139] | 934 |
|
---|
| 935 | def sendACARS(self, callback, acars):
|
---|
| 936 | """Send the given ACARS"""
|
---|
[1044] | 937 | request = SendACARSRPC(self._rpcClient, callback, acars)
|
---|
[746] | 938 | self._addRequest(request)
|
---|
[443] | 939 |
|
---|
[484] | 940 | def sendBugReport(self, callback, summary, description, email):
|
---|
| 941 | """Send a bug report with the given data."""
|
---|
| 942 | self._addRequest(SendBugReport(callback, summary, description, email))
|
---|
| 943 |
|
---|
[769] | 944 | def setCheckFlightPassed(self, callback, aircraftType):
|
---|
| 945 | """Mark the check flight as passed."""
|
---|
| 946 | self._addRequest(SetCheckFlightPassed(self._rpcClient,
|
---|
| 947 | callback, aircraftType))
|
---|
| 948 |
|
---|
[829] | 949 | def getPIREP(self, callback, flightID):
|
---|
| 950 | """Query the PIREP for the given flight."""
|
---|
| 951 | self._addRequest(GetPIREP(self._rpcClient, callback, flightID))
|
---|
| 952 |
|
---|
[821] | 953 | def reflyFlights(self, callback, flightIDs):
|
---|
| 954 | """Mark the flights with the given IDs for reflying."""
|
---|
| 955 | self._addRequest(ReflyFlights(self._rpcClient, callback, flightIDs))
|
---|
| 956 |
|
---|
[824] | 957 | def deleteFlights(self, callback, flightIDs):
|
---|
| 958 | """Delete the flights with the given IDs."""
|
---|
| 959 | self._addRequest(DeleteFlights(self._rpcClient, callback, flightIDs))
|
---|
| 960 |
|
---|
[854] | 961 | def getAcceptedFlights(self, callback):
|
---|
| 962 | """Enqueue a request to get the accepted flights."""
|
---|
| 963 | self._addRequest(GetAcceptedFlights(self._rpcClient, callback))
|
---|
| 964 |
|
---|
[858] | 965 | def getTimetable(self, callback, date, types):
|
---|
| 966 | """Enqueue a request to get the timetable."""
|
---|
| 967 | self._addRequest(GetTimetable(self._rpcClient, callback, date, types))
|
---|
| 968 |
|
---|
[859] | 969 | def bookFlights(self, callback, flightIDs, date, tailNumber):
|
---|
| 970 | """Enqueue a request to book some flights."""
|
---|
| 971 | self._addRequest(BookFlights(self._rpcClient, callback,
|
---|
| 972 | flightIDs, date, tailNumber))
|
---|
| 973 |
|
---|
[41] | 974 | def run(self):
|
---|
| 975 | """Process the requests."""
|
---|
| 976 | while True:
|
---|
| 977 | with self._requestCondition:
|
---|
| 978 | while not self._requests:
|
---|
| 979 | self._requestCondition.wait()
|
---|
| 980 | request = self._requests[0]
|
---|
| 981 | del self._requests[0]
|
---|
| 982 |
|
---|
| 983 | request.perform()
|
---|
[443] | 984 |
|
---|
[41] | 985 | def _addRequest(self, request):
|
---|
| 986 | """Add the given request to the queue."""
|
---|
| 987 | with self._requestCondition:
|
---|
| 988 | self._requests.append(request)
|
---|
| 989 | self._requestCondition.notify()
|
---|
| 990 |
|
---|
| 991 | #------------------------------------------------------------------------------
|
---|
| 992 |
|
---|
| 993 | if __name__ == "__main__":
|
---|
| 994 | import time
|
---|
[443] | 995 |
|
---|
[41] | 996 | def callback(returned, result):
|
---|
[919] | 997 | print(returned, str(result))
|
---|
[443] | 998 |
|
---|
[41] | 999 | handler = Handler()
|
---|
| 1000 | handler.start()
|
---|
| 1001 |
|
---|
[51] | 1002 | #handler.login(callback, "P096", "V5fwj")
|
---|
| 1003 | #handler.getFleet(callback)
|
---|
| 1004 | # Plane: HA-LEG home (gate 67)
|
---|
[63] | 1005 | #handler.updatePlane(callback, "HA-LQC", const.PLANE_AWAY, "72")
|
---|
[443] | 1006 | #time.sleep(3)
|
---|
[63] | 1007 | #handler.getFleet(callback)
|
---|
| 1008 | #time.sleep(3)
|
---|
| 1009 |
|
---|
[66] | 1010 | #handler.getNOTAMs(callback, "LHBP", "EPWA")
|
---|
[204] | 1011 | #handler.getMETARs(callback, ["LHBP", "EPWA"])
|
---|
| 1012 | #time.sleep(5)
|
---|
[443] | 1013 |
|
---|
[204] | 1014 | handler.updatePlane(callback, "HA-LON", const.PLANE_AWAY, "")
|
---|
[443] | 1015 | time.sleep(3)
|
---|
[41] | 1016 |
|
---|
| 1017 | #------------------------------------------------------------------------------
|
---|