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 tryAgain(self, record=None, remote=None):
assert record or remote, "Can't pass both record and remote as none"
if remote:
qs = RemoteBluetoothDeviceFilesRejected.\
objects.\
filter(
campaign=self,
remote=remote
).\
order_by('-time')
if qs.count() == 0:
logger.info("first time ever")
return True
record = qs.all()[0]
logger.debug("got record, %s" % record)
delta = time.mktime(time.gmtime()) - time.mktime(
record.time.timetuple())
logger.info("delta: %s" % delta)
if record.isTimeout():
logger.info("record timeout")
return delta >= self.tries_timeout and (
self.tries_count==-1 or \
self.tries_count > self.getTriesCount(record.remote)
)
else:
logger.info("record rejected")
return delta >= self.rejected_timeout and \
(self.rejected_count==-1 or
self.rejected_count > self.getRejectedCount(record.remote)
)
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 get_dongles(dongles):
out = list()
for address in dongles:
print address
try:
if not is_known_dongle(address, UploaderBluetoothDongle) and \
isAIRcable(address):
logger.info('not known uploader %s' % address)
settings = SET.getSettingsByAddress(address)
if not 'uploader' in settings:
logger.info('no settings for uploaders')
continue
logger.info('default settings where found')
logger.debug(settings['uploader'])
max_conn = settings['uploader'].get('max_conn', 1)
enabled = settings['uploader'].get('enable', True)
name = settings['uploader'].get('name', _("Autodiscovered Bluetooth dongle"))
UploaderBluetoothDongle.objects.get_or_create(address=address,
defaults={
'name': name,
'enabled': enabled,
'max_conn': max_conn
}
)
dongle = UploaderBluetoothDongle.objects.get(address=address, enabled=True)
out.append( (address, dongle.max_conn, dongle.name) )
except Exception, err:
logger.exception(err)
def device_found(self, address, values, path=None):
'''
This callback gets called when ever a device has been found over dbus.
We add the result to our discovered buffer, so we then tell the server
all the results together. With real discovery time.
'''
dongle = self.__getScannerForPath(path)
if address not in dongle.found:
dongle.found[address] = dict()
dongle.found[address]['rssi'] = list()
dongle.found[address]['time'] = list()
if 'name' not in dongle.found[address] and 'Name' in values:
dongle.found[address]['name']=smart_str(values['Name'])
if 'devclass' not in dongle.found[address] and 'Class' in values:
dongle.found[address]['devclass'] = int(values['Class'])
dongle.found[address]['rssi'].append(int(values['RSSI']))
dongle.found[address]['time'].append(time.time())
logger.debug(
'%s device found: %s, %s' % (
path,
address,
values.get('Name', None)
)
)
def tellListenersAsync(self, *args, **kwargs):
'''
Dispatch the given signal with the given arguments to our listener.
'''
logger.debug("ScanManager telling listener - async: %s" % POST[args[0]])
self.remote_listener(*args, **kwargs)
logger.debug("ScanManager message dispatched")
def do_work(cls, record):
'''
This method gets called each time a new record is stored into the database.
The method is responsible of checking if there\'s any registered alarm for
this instance, and in case there is check if any of the fields has gone
outside the spected values.
'''
logger.info("do_work on AlertDefinition")
remote = get_subclass(record.remote)
record = get_subclass(record)
for notif in remote.alertdefinition_set.filter(enabled=True).exclude(
mode=-1).all():
val = getattr(record, notif.field)
set = ALERT_INFO[notif.mode]['set'](val, notif.set, notif.clr)
clear = ALERT_INFO[notif.mode]['clear'](val, notif.clr, notif.set)
logger.debug("checking for alarm %s %s %s %s %s %s" %
(ALERT_INFO[notif.mode]['name'], val, notif.set,
notif.clr, set, clear))
if clear is True:
qs = notif.alert_set.filter(target=remote, active=True)
if qs.count() > 0:
logger.info("clearing alarm")
qs.update(active=False, auto_cleared=True)
elif set is True:
logger.info("setting alarm")
notif.sendNotification(target=remote, value=val)
def tryAgain(self, record=None, remote=None):
assert record or remote, "Can't pass both record and remote as none"
if remote:
qs = RemoteBluetoothDeviceFilesRejected.\
objects.\
filter(
campaign=self,
remote=remote
).\
order_by('-time')
if qs.count() == 0:
logger.info("first time ever")
return True
record=qs.all()[0]
logger.debug("got record, %s" % record)
delta = time.mktime(time.gmtime())-time.mktime(record.time.timetuple())
logger.info("delta: %s" % delta)
if record.isTimeout():
logger.info("record timeout")
return delta >= self.tries_timeout and (
self.tries_count==-1 or \
self.tries_count > self.getTriesCount(record.remote)
)
else:
logger.info("record rejected")
return delta >= self.rejected_timeout and \
(self.rejected_count==-1 or
self.rejected_count > self.getRejectedCount(record.remote)
)
def exposed_refreshScanners(self):
'''
When called by the server this method will create ScanAdapter or
RemoteScanAdapter for each one of our scanner dongles and then will
create the can sequence. Letting the server know when we are ready
to start scanning by triggering DONGLES_ADDED
'''
logger.debug("ScanManager refresh scanners %s" % self.scanners)
if self.scanners is None or len(self.scanners) == 0:
self.__dongles = dict()
return False
try:
for i in self.scanners.keys():
try:
path=self.manager.FindAdapter(i)
adapter = ScanAdapter(self.scanners[i][0],
name=self.scanners[i][1],
bus=self.bus, path=path)
except Exception, err:
print err
print "trying with a remote scanner"
adapter = RemoteScanAdapter(self.scanners[i][0],
local=self.scanners[i][1], address=i,
bus=self.bus, scanner_manager=self)
self.__dongles[i] = adapter
self.__generateSequence()
self.tellListenersAsync(DONGLES_ADDED)
def read(self, bytes=10, log=True, timeout=None):
'''
Read binary data from the port.
Arguments:
bytes: Amount of bytes to read
'''
self.checkConnected('Can\'t read if not connected');
ret = None
if timeout is None:
timeout = self.socket.gettimeout()
if timeout is not None:
start = time.time()
while [ 1 ]:
sel = select( (self.socket,), (), (), 0)
if len(sel[0]) > 0:
ret = self.socket.recv(bytes);
break
if timeout is not None and time.time() - start > timeout:
raise SPPException("timeout reached on read")
time.sleep(0.1)
if( log ):
logger.debug("<< %s" % ret)
return ret
def read(self, bytes=10, log=True, timeout=None):
'''
Read binary data from the port.
Arguments:
bytes: Amount of bytes to read
'''
self.checkConnected('Can\'t read if not connected')
ret = None
if timeout is None:
timeout = self.socket.gettimeout()
if timeout is not None:
start = time.time()
while [1]:
sel = select((self.socket, ), (), (), 0)
if len(sel[0]) > 0:
ret = self.socket.recv(bytes)
break
if timeout is not None and time.time() - start > timeout:
raise SPPException("timeout reached on read")
time.sleep(0.1)
if (log):
logger.debug("<< %s" % ret)
return ret
def exposed_refreshScanners(self):
'''
When called by the server this method will create ScanAdapter or
RemoteScanAdapter for each one of our scanner dongles and then will
create the can sequence. Letting the server know when we are ready
to start scanning by triggering DONGLES_ADDED
'''
logger.debug("ScanManager refresh scanners %s" % self.scanners)
if self.scanners is None or len(self.scanners) == 0:
self.__dongles = dict()
return False
try:
for i in self.scanners.keys():
try:
path = self.manager.FindAdapter(i)
adapter = ScanAdapter(self.scanners[i][0],
name=self.scanners[i][1],
bus=self.bus,
path=path)
except Exception, err:
print err
print "trying with a remote scanner"
adapter = RemoteScanAdapter(self.scanners[i][0],
local=self.scanners[i][1],
address=i,
bus=self.bus,
scanner_manager=self)
self.__dongles[i] = adapter
self.__generateSequence()
self.tellListenersAsync(DONGLES_ADDED)
def get_dongles(dongles):
out = list()
for address in dongles:
print address
try:
if not is_known_dongle(address, UploaderBluetoothDongle) and \
isAIRcable(address):
logger.info('not known uploader %s' % address)
settings = SET.getSettingsByAddress(address)
if not 'uploader' in settings:
logger.info('no settings for uploaders')
continue
logger.info('default settings where found')
logger.debug(settings['uploader'])
max_conn = settings['uploader'].get('max_conn', 1)
enabled = settings['uploader'].get('enable', True)
name = settings['uploader'].get(
'name', _("Autodiscovered Bluetooth dongle"))
UploaderBluetoothDongle.objects.get_or_create(address=address,
defaults={
'name':
name,
'enabled':
enabled,
'max_conn':
max_conn
})
dongle = UploaderBluetoothDongle.objects.get(address=address,
enabled=True)
out.append((address, dongle.max_conn, dongle.name))
except Exception, err:
logger.exception(err)
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 tellListenersAsync(self, *args, **kwargs):
'''
Dispatch the given signal with the given arguments to our listener.
'''
logger.debug("ScanManager telling listener - async: %s" %
POST[args[0]])
self.remote_listener(*args, **kwargs)
logger.debug("ScanManager message dispatched")
def __init__(self, priority, *args, **kwargs):
Adapter.__init__(self, *args, **kwargs)
if priority is None or priority < 0:
priority = 0
self.priority = int(priority)
logger.debug("Initializated ScannerDongle: %s" % priority)
def __sendCommand(self, command):
logger.debug('__sendCommand %s' % command)
#self.makeShellReady()
self.sendLine(command)
while [1]:
line = self.readLine()
if line.find('error') == -1:
return line
def __sendCommand(self, command):
logger.debug('__sendCommand %s' % command)
#self.makeShellReady()
self.sendLine(command)
while [ 1 ]:
line=self.readLine()
if line.find('error')==-1:
return line
def __init__(self, priority, *args, **kwargs):
Adapter.__init__(self, *args, **kwargs)
if priority is None or priority < 0:
priority=0
self.priority=int(priority)
logger.debug("Initializated ScannerDongle: %s" % priority)
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 exposed_doScan(self):
'''
Exposed method that tells us to start scanning.
'''
logger.debug('ScanManager scanning')
if not self.concurrent:
self.__do_scan_no_concurrent()
else:
self.__multi_scan()
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 exposed_doScan(self):
'''
Exposed method that tells us to start scanning.
'''
logger.debug('ScanManager scanning')
if not self.concurrent:
self.__do_scan_no_concurrent()
else:
self.__multi_scan()
def shellAskLine(self, number):
'''Function wrapper for a shell operation'''
logger.debug('shellAskLine %s' % number)
#self.makeShellReady()
self.sendLine("p%04i" % number)
while [1]:
line = self.readLine()
if line.find("error") == -1:
return line.replace('>', '').strip()
else:
return ""
def shellAskLine(self, number):
'''Function wrapper for a shell operation'''
logger.debug('shellAskLine %s' % number)
#self.makeShellReady()
self.sendLine("p%04i" % number)
while [ 1 ]:
line = self.readLine()
if line.find("error")==-1:
return line.replace('>', '').strip()
else:
return ""
def exposed_getPIN(self, remote, local):
logger.info("getPIN request for %s->%s" % (local, remote) )
remote = RemoteDevice.getRemoteDevice(address=remote)
try:
camps = getMatchingCampaigns(remote=remote, enabled=True)
for camp in camps:
if camp.pin_code:
logger.debug("pin code: %s" % camp.pin_code)
return camp.pin_code
except Exception, err:
logger.error(err)
logger.exception(err)
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())
def __multi_scan(self):
'''
internal method that starts a concurrent scan
'''
logger.debug("Concurrent scan")
if self.pending is not None and len(self.pending) > 0:
raise Exception("Can't do multiple concurrent scans if pending")
self.pending = list()
for dongle in self.__dongles.itervalues():
logger.debug("%s scanning" % dongle.dbus_path)
dongle.scan()
self.pending.append(dongle.dbus_path)
def __multi_scan(self):
'''
internal method that starts a concurrent scan
'''
logger.debug("Concurrent scan")
if self.pending is not None and len(self.pending) > 0:
raise Exception("Can't do multiple concurrent scans if pending")
self.pending = list()
for dongle in self.__dongles.itervalues():
logger.debug("%s scanning" % dongle.dbus_path)
dongle.scan()
self.pending.append(dongle.dbus_path)
def exposed_getPIN(self, remote, local):
logger.info("getPIN request for %s->%s" % (local, remote))
remote = RemoteDevice.getRemoteDevice(address=remote)
try:
camps = getMatchingCampaigns(remote=remote, enabled=True)
for camp in camps:
if camp.pin_code:
logger.debug("pin code: %s" % camp.pin_code)
return camp.pin_code
except Exception, err:
logger.error(err)
logger.exception(err)
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())
def readLine(self):
'''
Reads until \n is detected
'''
out = buffer("");
while ( 1 ):
out += self.read(bytes=1, log=False);
if self.__pattern.match(out):
out = out.replace('\n', '');
logger.debug("<< %s" % out )
return out
def create_new_discovered_dongle(address, settings):
logger.info("going to setup as scanner")
priority = settings['scanner'].get('priority', 1)
enabled = settings['scanner'].get('enable', True)
name = settings['scanner'].get('name', _("Auto Discovered Dongle"))
obj, created = ScannerBluetoothDongle.objects.get_or_create(
address=address,
defaults={
'priority': priority,
'enabled': enabled,
'name': name
})
logger.debug("%s %s[%s]" % (address, name, priority))
def readLine(self):
'''
Reads until \n is detected
'''
out = buffer("")
while (1):
out += self.read(bytes=1, log=False)
if self.__pattern.match(out):
out = out.replace('\n', '')
logger.debug("<< %s" % out)
return out
def send(self, text):
'''
Send something to the port.
Arguments: what to send
'''
self.checkConnected('Can\'t send if not connected')
logger.debug(">> %s" % text)
ret = self.socket.sendall(text, socket.MSG_WAITALL)
if ret and int(ret) != text.length():
raise SPPException, "Failed to send all data"
def get_campaign_rule(files):
logger.info('get_campaign_rule %s' % files)
out = set()
for file, camp_id in files:
logger.debug(file)
try:
camp = MarketingCampaign.objects.get(pk=camp_id)
logger.debug(camp)
if len(out) > 0 and camp not in out:
logger.error("multiple return values")
out.add(camp)
except Exception, err:
logger.exception(err)
def get_campaign_rule(files):
logger.info('get_campaign_rule %s' % files)
out = set()
for file, camp_id in files:
logger.debug(file)
try:
camp = MarketingCampaign.objects.get(pk=camp_id)
logger.debug(camp)
if len(out) > 0 and camp not in out:
logger.error("multiple return values")
out.add(camp)
except Exception, err:
logger.exception(err)
def send(self, text):
'''
Send something to the port.
Arguments: what to send
'''
self.checkConnected('Can\'t send if not connected');
logger.debug(">> %s" % text)
ret = self.socket.sendall(text, socket.MSG_WAITALL);
if ret and int(ret) != text.length():
raise SPPException, "Failed to send all data"
def scan(self):
'''
Start a scan in the remote scanner
'''
if self.sending:
return
if not self.iface.isConnected():
self.iface.Connect(self.local, self.bt_address)
return
self.sending = True
self.found = dict()
self.iface.StartScan(1)
logger.debug("Scan started")
def scan(self):
'''
Start a scan in the remote scanner
'''
if self.sending:
return
if not self.iface.isConnected():
self.iface.Connect(self.local, self.bt_address)
return
self.sending = True
self.found = dict()
self.iface.StartScan(1)
logger.debug("Scan started")
def register(client=None, dongles=None):
logger.info("register %s %s" % (client, dongles))
if repr(client).find('camera.serverxr.CameraManager') == -1:
logger.debug("no match")
return False
client=Client(client)
dongles = get_dongles(list(dongles))
for dongle, max_conn in dongles:
clients[dongle]=client
client.add_dongle(dongle, max_conn)
client.refreshDongles()
return True
def __rotate_dongle(self):
'''
Internal method used for concurrent scan, each time each one of the
scanners completets it's work this method gets called until there
are no more dongles in the sequence.
When that happens we tell the server we're done.
'''
self.__index += 1
if self.__index >= len(self.__sequence):
self.tellListenersAsync(CYCLE_COMPLETE)
self.__index = 0
logger.debug('ScanManager dongle cycle completed')
return True
logger.debug('ScanManager dongle rotated, dongle: %s' % self.__sequence[self.__index])
return False
def __rotate_dongle(self):
'''
Internal method used for concurrent scan, each time each one of the
scanners completets it's work this method gets called until there
are no more dongles in the sequence.
When that happens we tell the server we're done.
'''
self.__index += 1
if self.__index >= len(self.__sequence):
self.tellListenersAsync(CYCLE_COMPLETE)
self.__index = 0
logger.debug('ScanManager dongle cycle completed')
return True
logger.debug('ScanManager dongle rotated, dongle: %s' %
self.__sequence[self.__index])
return False
def do_upload(uploader,
files,
remote,
service='opp',
dongle_name=None,
channel=None,
dongle=None):
logger.info("do_upload")
logger.debug("About to call upload")
uploader.upload(ByValWrapper(files),
remote,
service,
dongle_name=dongle_name,
channel=channel,
uploader=dongle.address if dongle else None)
logger.debug("upload called async")
def doAlert(cls, alert, target, value):
Alert.updateActive()
logger.info("alert %s %s" % (alert.field, target.address))
qs = Alert.objects.filter(alert=alert, target=target)
if qs.filter(active=True).count() > 0:
logger.debug("Alert all ready set for target")
return False
logger.debug("Alert will be sent")
a = Alert()
a.active = True
a.alert = alert
a.target = target
a.setAlarm()
a.value = value
a.save()
return True
def do_upload(uploader,
files,
remote,
service='opp',
dongle_name=None,
channel=None,
dongle=None):
logger.info("do_upload")
logger.debug("About to call upload")
uploader.upload(ByValWrapper(files),
remote,
service,
dongle_name=dongle_name,
channel=channel,
uploader=dongle.address if dongle else None)
logger.debug("upload called async")
def parsereading(device=None,
seconds=None,
battery=None,
reading=None,
dongle=None):
'''This method expects to get a valid reading, generating a record out of it'''
#extract parameters from reading string
m = lin.match(reading)
if not m:
logger.error("NO MATCH %s" % reading)
return
m = m.groupdict()
value = int(m['value'])
mode = m['mode']
slope = int(m['slope'])
offset = int(m['offset'])
if mode == 'A':
slope = 1.0 / slope
logger.debug("reading %s, slope %s, offset %s, mode %s" %
(value, slope, offset, mode))
#find ambient device, or create if there's none yet created
device, created = GenericLinearDevice.objects.get_or_create(
address=device,
defaults={
'friendly_name': _('Auto Discovered Generic Linear Sensor'),
'sensor': _('Temperature'),
'mode': _('Monitor'),
'slope': slope,
'offset': offset
})
reading = device.getValue(value)
record = GenericLinearRecord()
record.slope = slope
record.offset = offset
record.remote = device
record.dongle = dongle
record.reading = reading
record.reading_mv = value
record.time = datetime.fromtimestamp(seconds)
record.battery = battery
record.save()
def exposed_listener(self, signal, *args, **kwargs):
global enabled
if not enabled:
logger.debug("rpc is locked, dropping signal %s" % signal)
return
logger.debug("exposed_listener %s %s %s" % ( signal, args, kwargs) )
kwargs['pending']=pending
try:
for plugin in pluginsystem.get_plugins('rpc'):
plugin.rpc['handle'](signal=signal, services=services, manager=self, *args, **kwargs)
transaction.commit() # commit only after all the plugins have handled
except Exception, err:
logger.error("rpc listener while doing plugins")
logger.exception(err)
transaction.rollback() # oops rollback
def __init__(self, bus, listener=None, rpc=None):
logger.debug("ScanManager created")
self.bus = bus
self.manager = dbus.Interface(
bus.get_object(const.BLUEZ, const.BLUEZ_PATH),
const.BLUEZ_MANAGER
)
if listener is not None:
for x in listener:
self.exposed_addListener(x)
self.exposed_refreshScanners()
# Subscribe to signals
self.bus.add_signal_receiver(
self.device_found, # callback
'DeviceFound', # signal name
'org.bluez.Adapter', # interface name
'org.bluez', # sender bus name
path_keyword='path') #
self.bus.add_signal_receiver(
self.property_changed, # callback
'PropertyChanged', # signal name
'org.bluez.Adapter', # interface name
'org.bluez', # sender bus name
path_keyword='path') #
# call back for remote scanner
self.bus.add_signal_receiver(
self.property_changed, # callback
signal_name='PropertyChanged', # signal name
dbus_interface=remotescanner_url, # interface name
path_keyword='path'
)
self.bus.add_signal_receiver(
self.device_found, # callback
signal_name='DeviceFound', # signal name
dbus_interface=remotescanner_url, # interface name
path_keyword='path'
)
self.rpc = rpc
if self.rpc:
self.remote_listener=rpyc.async(self.rpc.root.listener)
def handle_addrecord(services, remote_, dongle, pending):
address = remote_['address']
name = smart_unicode(remote_['name']) if remote_['name'] else None
logger.info("handle_addrecord %s" % address)
remote=RemoteDevice.getRemoteDevice(
address=address,
name=name,
devclass=remote_['devclass']
)
record = RemoteBluetoothDeviceFoundRecord()
record.action = signals.FOUND_DEVICE
record.dongle = dongle
record.remote = remote
record.remote.save() # update last seen
record.setRSSI(remote_['rssi'])
if not isinstance(dongle, RemoteScannerBluetoothDongle):
if name is not None and record.remote.name!=name:
record.remote.name = name
record.remote.save()
if remote_['devclass'] != -1 and \
record.remote.devclass!=remote_['devclass']:
record.remote.devclass = remote_['devclass']
record.remote.save()
logger.debug(record)
logger.debug(record.remote)
record.save() # this will set the time field to now
logl = LogLine()
logl.content="Found: %s %s %s" % (
record.remote.address,
record.remote.name,
record.getRSSI())
logl.save()
if address not in pending:
return found_action(services, address, record, pending, dongle=dongle)
return True
def get_files_from_campaign(camp, record):
if camp.hasAccepted(record.remote):
logger.info("Allready accepted")
raise StopIteration
c = camp.getRejectedCount(record.remote)
d = camp.getTimeoutCount(record.remote)
if c > 0 or d > 0:
logger.debug("All ready rejected %s times, and timedout %s" % (c, d))
try_ = camp.tryAgain(remote=record.remote, record=None)
logger.info("try again: %s" % try_)
if not try_:
raise StopIteration
files__ = camp.campaignfile_set
files__ = files__.filter(chance__isnull=True) | files__.filter(
chance__gte=str(random()))
for f in files__:
logger.debug('going to upload %s' % f.file)
yield str(f.file.name), camp.pk
def device_found(self, address, values, path=None):
'''
This callback gets called when ever a device has been found over dbus.
We add the result to our discovered buffer, so we then tell the server
all the results together. With real discovery time.
'''
dongle = self.__getScannerForPath(path)
if address not in dongle.found:
dongle.found[address] = dict()
dongle.found[address]['rssi'] = list()
dongle.found[address]['time'] = list()
if 'name' not in dongle.found[address] and 'Name' in values:
dongle.found[address]['name'] = smart_str(values['Name'])
if 'devclass' not in dongle.found[address] and 'Class' in values:
dongle.found[address]['devclass'] = int(values['Class'])
dongle.found[address]['rssi'].append(int(values['RSSI']))
dongle.found[address]['time'].append(time.time())
logger.debug('%s device found: %s, %s' %
(path, address, values.get('Name', None)))
def __scan(self, times):
try:
self.client.socket.settimeout(30)
self.client.sendLine("r%i" % times)
logger.debug(self.client.readBuffer())
flag = True
while ( flag ):
lines=self.client.readBuffer(honnor_eol=True,timeout=1)
for line in lines.splitlines():
if self.record_pattern.match(line.strip()):
address, rssi = line.split('RSSI')
self.DeviceFound( AddDots(address) , {'RSSI': int(rssi)})
elif line.find('COMMAND') >-1:
logger.info("RSSI completed")
flag = False
break
except (SPPException, SPPNotConnectedException, TypeError), e:
logger.error("error while scanning, could be that we lost connection")
logger.exception(e)
def found_action(record, services):
dongle = record.dongle.address
logger.info("camera device_found %s: %s[%s]" % (dongle , record.remote.address, record.remote.name))
camps = getMatchingCampaigns(record.remote, enabled=True, classes=[CameraCampaign,])
if len(camps) == 0:
return False
if len(camps) > 1:
e = Exception("There's more than one campaign that matches, check settings")
logger.exception(e)
raise e
logger.debug("found campaign")
camp = camps[0]
global clients
if clients.get(dongle, None) is None:
logger.debug("dongle not registered as client")
logger.debug(clients)
logger.debug(dongle)
return False # there's no registered service I can't do a thing
address = record.remote.address
if not check_if_service(address):
return False
latest = CameraRemoteDevice.objects.filter(address=address)
if latest.count() > 0:
for k in latest.all():
k.save() # mark elements as served, so timeout can exist
service[address] = time.time()
logger.info("handling device %s" % address)
client = clients[dongle]
client.setZoneMinderBackend(camp.enable_zm)
client.setOpenProximityBackend(camp.use_backend)
client.connect(record.remote.address)
logger.debug("connecting")
return client
def get_files_from_campaign(camp, record):
if camp.hasAccepted(record.remote):
logger.info("Allready accepted")
raise StopIteration
c = camp.getRejectedCount(record.remote)
d = camp.getTimeoutCount(record.remote)
if c>0 or d>0:
logger.debug("All ready rejected %s times, and timedout %s" % (c, d))
try_ = camp.tryAgain(remote=record.remote, record=None)
logger.info("try again: %s" % try_)
if not try_ :
raise StopIteration
files__ = camp.campaignfile_set
files__ = files__.filter(chance__isnull=True) | files__.filter(
chance__gte=str(random())
)
for f in files__:
logger.debug('going to upload %s' % f.file)
yield str(f.file.name), camp.pk
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
