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 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 __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 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 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 endConnection(self, exit=True):
self.shellPushIntoHistory(time.time())
time.sleep(2)
if exit:
logger.info("Sending exit")
self.shellExit()
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 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 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 __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 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 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 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())
