def started(scanner, address): logger.info('scan_started %s' % address) dongle = ScannerBluetoothDongle.objects.get(address=address) record = DeviceRecord() record.action = signals.CYCLE_SCAN_DONGLE record.dongle = dongle record.save()
def handle_adapter_added_or_removed(path, signal): ''' When ever a dongle is added or removed this function gets called, so we can restart the rpc client. ''' logger.info("bluez.%s: %s" % (signal, path)) stop()
def handle_parent(signum, frame): ''' When the parent gets the kill signal it will stop it self no forking more childrens. ''' logger.info("Parent killed, doing exit") sys.exit(0)
def latest_picture(request): try: b = models.CameraRecord.objects.latest('time').picture.name except: b = None logger.info(b) return HttpResponse( json.dumps({'name': b}), 'application/json')
def handle_connection(self, conn, remote): request = conn.recv(4096) conn.setblocking(0) command, url = request.splitlines()[0].split()[:2] if command.strip() != 'GET': conn.shutdown(sk.SHUT_RDWR) conn.close() return True if url.strip() != '/': conn.shutdown(sk.SHUT_RDWR) conn.close() return True logger.info("Got a connection to the http stream, redirecting") host = '' for line in request.splitlines(): if line.find('Host') > -1: host = line.strip().split()[1].split(':', 1)[0] conn.sendall('HTTP/1.0 200 OK\r\n') conn.sendall( 'Content-type:multipart/x-mixed-replace; boundary=--myboundary\r\n' ) conn.sendall('\r\n') self.clientsockets[remote] = conn logger.info("Connection ready for streamming") return True
def __init__(self, path=None, name=None, egg=None): ''' Try to register a new plugin. @path=Path to the plugin @name=Name of the plugin it self @egg=True if the plugin is stored into an egg file ''' if not egg: self.path = os.path.join(path, name) else: self.path = path if not egg: self.name = 'plugins.%s' % name else: self.name = name self.egg = egg if not self.egg: self.__loadFromFile(self.path) else: self.__loadFromEgg(self.path) self.enabled = self.provides.get('enabled', False) self.__module = None self.__version = None self.__version_info = None self.__rpc = None logger.info("Plugin: %s registered" % self.name)
def getMatchingCampaigns(remote=None, time_=None, enabled=None, classes=None, record=None): out = list() classes = classes or Campaign.__subclasses__() time_ = time_ or datetime(*time.gmtime()[:-2]) logger.info("getMatchingCampaigns %s %s %s %s %s" % (remote, time_, enabled, classes, record)) for model in classes: rules = model.objects if enabled is not None: rules = rules.filter(enabled=enabled) rules = rules.all() rules = rules.filter(start__isnull=True) | rules.filter( start__lte=time_) rules = rules.filter(end__isnull=True) | rules.filter(end__gte=time_) if remote is None: out.extend(rules) continue for rule in rules: if rule.matches(remote, record): out.append(rule) if len(out): logger.info("There's a match") logger.debug(out) return out
def handle_file_failed(dongle, remote, pending, channel, files, ret, err, services): logger.info("handle file failed %s[%s]: %s" % (remote, channel, files)) logger.debug(err) try: try_again = [] rules = get_campaign_rule(files) if rules is None or len(rules) == 0: raise Exception("Couldn't find rule") for rule in rules: record = save_file_failed(rule, dongle, ret, remote) # from here we try again either on timeout or if rejected count is # smaller than filter if rule.tryAgain(record=record): try_again.append(rule) # if we can't try again this method will raise an exception # and the try/catch will make sure the remote device gets out # of our pending list if upload_after_rejected(try_again, services, dongle=dongle, remote=remote): return except Exception, err: logger.error("OOOPS!!!") logger.exception(err)
def exposed_setConcurrent(self, val): ''' Exposed method that lets the server tell us if we should do concurrent scanning (all the scanners work at the same time), or sequence scanning. ''' self.concurrent = val logger.info("setConcurrent %s" % val)
def disconnect(self, force=False): if not force: self.checkConnected("Can't close if it's opened"); logger.info("Closing socket"); self.socket.shutdown(socket.SHUT_RDWR); self.socket.close() self.socket = None
def handle_adapter_added(path, signal): ''' When ever a new dongle is attached, or bluez starts a signal is generated, that's when we register the agent for that adapter. ''' logger.info("bluez.%s: %s" % (signal, path)) registerAgent(path)
def getTemperature(self, reading): # calculate real temperature if (self.Vref / reading - 1) < 0: out = -9000 # return back a non real temperature out = (-1.0 / self.alpha) * math.log( (self.Vref / reading - 1) * self.R / self.Ro) logger.info('getTemperature: %s->%s°C' % (reading, out))
def endConnection(self, exit=True): self.shellPushIntoHistory(time.time()) time.sleep(2) if exit: logger.info("Sending exit") self.shellExit()
def handle_file_failed(dongle, remote, pending, channel, files, ret, err, services): logger.info("handle file failed %s[%s]: %s" % (remote, channel, files)) logger.debug(err) try: try_again = [] rules = get_campaign_rule(files) if rules is None or len(rules)==0: raise Exception("Couldn't find rule") for rule in rules: record = save_file_failed(rule, dongle, ret, remote) # from here we try again either on timeout or if rejected count is # smaller than filter if rule.tryAgain(record=record): try_again.append(rule) # if we can't try again this method will raise an exception # and the try/catch will make sure the remote device gets out # of our pending list if upload_after_rejected(try_again, services, dongle=dongle, remote=remote): return except Exception, err: logger.error("OOOPS!!!") logger.exception(err)
def shellGrabFile(self, file): out = "" self.sendLine("s%s" % file) while [1]: try: line = self.readLine() except socket.error: logger.info("Connection lost connection") break logger.debug("line=%s" % line) if (line != None and line.find("DONE") > -1): logger.debug("EOF") break elif line.startswith(">") or len(line) > 1 or line.find( "GO") == -1: out += line out += "\n" #self.sendLine("GO") out = out.replace('>', '') logger.debug("Got:\n%s" % out) return out
def exposed_uploader_register(self, client = None, remote_quit=None, dongles=None): global enabled all_dongles.update(dongles) self.dongles = set() self.add_dongle = async(client.add_dongle) self.upload = async(client.upload) self.remote_quit = async(remote_quit) self.refreshUploaders = async(client.refreshUploaders) self.uploader = client if not enabled: return if not db_ready(): return logger.info("uploader register") for dongle in dongles: self.dongles.add( str(dongle), ) for dongle, max_conn, name in rpc.uploader.get_dongles(dongles): logger.info("%s: %s[%s]" % (dongle, name, max_conn)) self.add_dongle(dongle, max_conn, name) self.refreshUploaders()
def handle(services, signal, uploader, *args, **kwargs): logger.info("uploader signal: %s" % signals.TEXT[signal]) logl = LogLine() logl.content += signals.TEXT[signal] if signal == signals.SDP_RESOLVED: logl.content += ' %s:%s' % (kwargs['address'], kwargs['port']) handle_sdp_resolved(kwargs['dongle'], kwargs['address'], kwargs['port']) elif signal == signals.SDP_NORECORD: logl.content += ' %s' % (kwargs['address']) handle_sdp_norecord(kwargs['dongle'], kwargs['address'], kwargs['pending']) elif signal == signals.SDP_TIMEOUT: logl.content += ' %s' % (kwargs['address']) handle_sdp_timeout(kwargs['dongle'], kwargs['address'], kwargs['pending']) elif signal == signals.FILE_UPLOADED: logl.content += ' %s' % (kwargs['address']) handle_file_uploaded(kwargs['dongle'], kwargs['address'], kwargs['pending'], kwargs['port'], kwargs['files']) elif signal == signals.FILE_FAILED: logl.content += ' %s, ret:%s' % (kwargs['address'], kwargs['ret']) handle_file_failed(kwargs['dongle'], kwargs['address'], kwargs['pending'], kwargs['port'], kwargs['files'], kwargs['ret'], kwargs['stderr'], services) else: logger.error("signal ignored") logl.save()
def disconnect(self, force=False): if not force: self.checkConnected("Can't close if it's opened") logger.info("Closing socket") self.socket.shutdown(socket.SHUT_RDWR) self.socket.close() self.socket = None
def exposed_uploader_register(self, client=None, remote_quit=None, dongles=None): global enabled all_dongles.update(dongles) self.dongles = set() self.add_dongle = async (client.add_dongle) self.upload = async (client.upload) self.remote_quit = async (remote_quit) self.refreshUploaders = async (client.refreshUploaders) self.uploader = client if not enabled: return if not db_ready(): return logger.info("uploader register") for dongle in dongles: self.dongles.add(str(dongle), ) for dongle, max_conn, name in rpc.uploader.get_dongles(dongles): logger.info("%s: %s[%s]" % (dongle, name, max_conn)) self.add_dongle(dongle, max_conn, name) self.refreshUploaders()
def handle_sdp_timeout(dongle, remote, pending): logger.info("SDP timeout: %s" % remote ) pending.pop(remote) record = RemoteBluetoothDeviceSDPTimeout() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.setRemoteDevice(remote) record.save()
def handle_sdp_timeout(dongle, remote, pending): logger.info("SDP timeout: %s" % remote) pending.pop(remote) record = RemoteBluetoothDeviceSDPTimeout() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.setRemoteDevice(remote) record.save()
def on_disconnect(self): a = [ p for p in pending if pending[p]==self] if len(a) > 0: logger.info("a client disconnected, clearing %s pending transactions" % len(a)) for p in a: pending.pop(p) services.remove(self)
def Authorize(self, device, uuid): ''' This method gets called when the service daemon needs to authorize a connection/service request. Don't raise any exception so BlueZ knows we accept. ''' logger.info("Authorize (%s, %s)" % (device, uuid))
def handle_connection(self, conn, remote): request = conn.recv(4096) conn.setblocking(0) command, url = request.splitlines()[0].split()[:2] if command.strip() != "GET": conn.shutdown(sk.SHUT_RDWR) conn.close() return True if url.strip() != "/": conn.shutdown(sk.SHUT_RDWR) conn.close() return True logger.info("Got a connection to the http stream, redirecting") host = "" for line in request.splitlines(): if line.find("Host") > -1: host = line.strip().split()[1].split(":", 1)[0] conn.sendall("HTTP/1.0 200 OK\r\n") conn.sendall("Content-type:multipart/x-mixed-replace; boundary=--myboundary\r\n") conn.sendall("\r\n") self.clientsockets[remote] = conn logger.info("Connection ready for streamming") return True
def __restart_server(): logger.info("restarting server") try: server = rpyc.connect('localhost', 8010) server.root.restart() except: #could be that we're only running the web server pass
def handle_name_owner_changed(self, own, old, new): ''' detect if a name owner is gone, this prevents dead locks ''' if own in self.connections: if new is None or len(new) is 0: for client in self.connections[own]: logger.info("%s lost connection, killing it" % client.path) client.force_disconnect() self.connections[own] = None
def connected(self, local, remote): ''' Callback that lets us know when we got connected to the remote scanner ''' if self.bt_address.lower() == remote.lower(): logger.info("scanner connected %s" % remote) self.scanner_manager.property_changed('Discovering', 0, self.dbus_path)
def configure_dongle(request, address=None): logger.info("configure_dongle %s" % address) errors = [] messages = [] form = None if request.method == "POST": form = DongleForm(request.POST) if form.is_valid(): cd = form.cleaned_data add_dongle( cd['address'], cd['name'], cd["scan"], cd["upload"], cd["scan_pri"], cd["upload_max"], ) return HttpResponseRedirect('/') #messages.append("Dongle Configured") scanner = None scanner_pri = 1 uploader = None uploader_max = 7 name = "OpenProximity 2.0" search = BluetoothDongle.objects.filter(address=address) if search.count() > 0: dongle = search.all()[0] name = dongle.name search = ScannerBluetoothDongle.objects.filter(address=address) if search.count() > 0: scanner = True scanner_pri = search.get().priority search = UploaderBluetoothDongle.objects.filter(address=address) if search.count() > 0: uploader = True uploader_max = search.get().max_conn form = form or DongleForm( initial={ 'address': address, 'name': name, 'scan': scanner, 'scan_pri': scanner_pri, 'upload': uploader, 'upload_max': uploader_max }) return render_to_response('op/dongle_form.html', { 'form': form, 'messages': messages, }, context_instance=RequestContext(request))
def Release(self): ''' Release the agent, and exit the loop. Gets called by BlueZ when it needs us to release the agent. ''' logger.info("Agent Release") if self.exit_on_release: logger.info("Exiting from loop") mainloop.quit()
def db_ready(): try: from openproximity.models import BluetoothDongle BluetoothDongle.objects.count() return True except Exception, err: logger.info("Database not ready") logger.exception(err) return False
def RequestPasskey(self, device): ''' This method gets called when the service daemon needs to get the passkey for an authentication. The return value should be a numeric value between 0-999999. ''' logger.info("RequestPasskey (%s): %s" % (device, PIN)) return dbus.UInt32(PIN)
def configure_campaign(request, name=None): logger.info("configure_campaign %s" % name) form = CampaignForm() logger.debug(form.as_table()) return render_to_response('op/campaign_form.html', { 'form': form, }, context_instance=RequestContext(request))
def __sanitize(self): try: if self.tree is None: self.__getXmlTree() except Exception, err: logger.info("failed while loading file settings, trying to simulate" " config file") logger.exception(err) self.tree=etree.fromstring(DEFAULT)
def registerAgent(path): ''' Register an agent on the given dbus path. ''' adapter = dbus.Interface(bus.get_object("org.bluez", path), "org.bluez.Adapter") adapter.RegisterAgent(PATH, "NoInputNoOutput") # should we change this to NoInputNoOutput? logger.info("adapter registered for path %s" % path)
def handle_file_uploaded(dongle, remote, pending, channel, files): logger.info("files uploaded: %s[%s]: %s" % ( remote, channel, files) ) pending.pop(remote) for rule in get_campaign_rule(files): record = RemoteBluetoothDeviceFilesSuccess() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.campaign = rule record.setRemoteDevice(remote) record.save()
def handle_sdp_norecord(dongle, remote, pending): logger.info("No SDP: %s" % remote) pending.pop(remote) remote = RemoteDevice.objects.filter(address=remote).get() if RemoteBluetoothDeviceNoSDP.objects.filter(remote=remote).count() == 0: record = RemoteBluetoothDeviceNoSDP() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.remote = remote record.save()
def handle_sdp_norecord(dongle, remote, pending): logger.info("No SDP: %s" % remote) pending.pop(remote) remote=RemoteDevice.objects.filter(address=remote).get() if RemoteBluetoothDeviceNoSDP.objects.filter(remote=remote).count() == 0: record = RemoteBluetoothDeviceNoSDP() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.remote = remote record.save()
def handle_file_uploaded(dongle, remote, pending, channel, files): logger.info("files uploaded: %s[%s]: %s" % (remote, channel, files)) pending.pop(remote) for rule in get_campaign_rule(files): record = RemoteBluetoothDeviceFilesSuccess() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.campaign = rule record.setRemoteDevice(remote) record.save()
def on_disconnect(self): a = [p for p in pending if pending[p] == self] if len(a) > 0: logger.info( "a client disconnected, clearing %s pending transactions" % len(a)) for p in a: pending.pop(p) services.remove(self)
def configure_dongle(request, address=None): logger.info("configure_dongle %s" % address) errors = [] messages = [] form = None if request.method == "POST": form=DongleForm(request.POST) if form.is_valid(): cd=form.cleaned_data add_dongle( cd['address'], cd['name'], cd["scan"], cd["upload"], cd["scan_pri"], cd["upload_max"], ) return HttpResponseRedirect('/') #messages.append("Dongle Configured") scanner = None scanner_pri = 1 uploader = None uploader_max = 7 name = "OpenProximity 2.0" search=BluetoothDongle.objects.filter(address=address) if search.count()>0: dongle = search.all()[0] name=dongle.name search=ScannerBluetoothDongle.objects.filter(address=address) if search.count() > 0: scanner = True scanner_pri=search.get().priority search=UploaderBluetoothDongle.objects.filter(address=address) if search.count() > 0: uploader = True uploader_max=search.get().max_conn form = form or DongleForm( initial = { 'address': address, 'name': name, 'scan': scanner, 'scan_pri': scanner_pri, 'upload': uploader, 'upload_max': uploader_max}) return render_to_response('op/dongle_form.html', { 'form': form, 'messages': messages, }, context_instance=RequestContext(request))
def exposed_noCampaigns(self): ''' this method gets called when there was no matching campaigns on the server, so we tell the server until it's ready ''' def request_server(self): self.tellListenersAsync(CYCLE_COMPLETE) return False logger.info("no campaigns, scheduling request") gobject.timeout_add(60*1000, request_server, self)
def configure_campaign(request, name=None): logger.info("configure_campaign %s" % name) form = CampaignForm() logger.debug(form.as_table()) return render_to_response('op/campaign_form.html', { 'form': form, }, context_instance=RequestContext(request) )
def grab_latest_by_camera(request, addr): camera = ':'.join([ addr[i*2:i*2+2] for i in range(len(addr)/2) ]) f = models.CameraRecord.objects.filter(remote__address=camera).latest('time').picture mime = guess_mime(f.name) logger.info('%s -> %s' % (camera, f.name)) parts = [ (mime[0], f.read()) ] return http.StreamingMultipartHttpResponse(parts, type="multipart/x-mixed-replace")
def handle_sdp_resolved(dongle, remote, channel): logger.info("Valid SDP: %s %s" % (remote, channel) ) remote=RemoteDevice.objects.filter(address=remote).get() if RemoteBluetoothDeviceSDP.objects.filter(remote=remote).count() == 0: logger.info("New SDP result") record = RemoteBluetoothDeviceSDP() record.dongle = UploaderBluetoothDongle.objects.get(address=dongle) record.channel = channel record.remote = remote record.save()
def getSettingsByAddress(self, address=""): """ In [1]: from lxmltool import XMLTool In [2]: xt = XMLTool() In [3]: xt.getSettingsByAddress() Out[3]: {} In [4]: xt.getSettingsByAddress('f4:50:C2:00:00:02') Out[4]: {'scanner': ['1', 'True'], 'uploader': ['1', 'False']} In [5]: dic = xt.getSettingsByAddress('f4:50:C2:00:00:02') In [6]: dic Out[6]: {'scanner': ['1', 'True'], 'uploader': ['1', 'False']} In [7]: dic['scanner'] Out[7]: ['1', 'True'] In [8]: dic['uploader'] Out[8]: ['1', 'False'] # if the address doesnt exist, return default values declared in the # xml file In [9]: xt = XMLTool() In [9]: xt.getSettingsByAddress('f4:50:C2:00:00:06') Out[9]: {'scanner': ['1337', 'False'], 'uploader': ['20', 'True']} """ if not VALID_ADDRESS.match(address.lower()): raise Exception("Not Valid Bluetooth Address %s" % address) try: self.__sanitize() blocks = self.tree.findall('dongle/block') for block in blocks: addr = block.find('address').text.lower() if address.lower().startswith(addr): logger.info("%s passes filter %s" %( address, addr)) return self.__todict(block) # back to default default = self.tree.findall('dongle/default') if len(default) > 0: block = default[-1] return self.__todict(block) # not even default settings return {} except AttributeError: return {}
def Connect(self, sender): ''' Connect to the manager, add disconnection handler ''' path="%s/%i" % (CONNECTION, self.i) self.i+=1 remote = RemoteScanner(self.bus, path) logger.info("%s connected on %s" % (sender, path)) if sender not in self.connections: self.connections[sender] = list() self.connections[sender].append(remote) return path
def save(self, *args, **kwargs): super(RemoteBluetoothDeviceFilesSuccess, self).save(*args, **kwargs) if self.campaign.accepted_count > -1: c = self.campaign.getAcceptedCount() logger.info("accepted filter: %s, count: %s" % ( self.campaign.accepted_count, c ) ) if c >= self.campaign.accepted_count: self.campaign.enabled = False self.campaign.no_restart = True self.campaign.save()
def handle(signal, services, manager, *args, **kwargs): if not signals.isCameraSignal(signal): return global handlers logger.info("Camera HANDLE %s %s %s" % (signals.TEXT[signal], args, kwargs) ) if signal in handlers: return handlers[signal](manager=manager, *args, **kwargs) logger.error("Camera, no handler %s" % signals.TEXT[signal])
def connected(self, local, remote): ''' Callback that lets us know when we got connected to the remote scanner ''' if self.bt_address.lower() == remote.lower(): logger.info("scanner connected %s" % remote) self.scanner_manager.property_changed( 'Discovering', 0, self.dbus_path )
def logline_signal(instance, **kwargs): ''' gets called when ever there is a new logline''' if isinstance(instance, LogLine): if LogLine.objects.count()<100: return logger.info('logline cache clean up') logger.debug("logline count: %s" % LogLine.objects.count()) qs = LogLine.objects.all().order_by('time') idm = qs[0].pk idM = qs[qs.count()-50].pk LogLine.objects.filter(pk__gte=idm, pk__lte=idM).delete() logger.debug("logline count: %s" % LogLine.objects.count())