def post(self, request, *args, **kwargs):
user_id = request.user.id
redis_mem = get_redis_mem('nmap_scan_network')
last_scan = redis_mem.get(str(user_id)) or {}
if not last_scan.get('processing'):
raise JsonResponse({'message': 'No process under scanning!'}, status=400)
task_id = last_scan.get('task_id')
app.control.revoke(task_id, terminate=True)
redis_mem.delete(str(user_id))
return JsonResponse({'task_id': task_id})
def handle(self, *args, **options):
interval = options.get('interval') or settings.MON_SERVICE_INTERVAL
self._paused = False
redis_mem = get_redis_mem('feature_mon_handle')
redis_mem.clean()
while not self._paused:
try:
print("++++++++++++ Starting Round....")
self._work()
print("------------ Finished Round....")
print("!! Waiting for {} second !!".format(interval))
time.sleep(interval)
except KeyboardInterrupt:
print('Finished by KeyboardInterrupt!')
break
def feature_mon_handle(df_id):
logger.info('++++++++++++++ Start Checking for ID #%s...', df_id)
df = DeviceFeature.objects.filter(id=df_id).first()
if not df:
logger.warning('device feature with id %s does not exists!', df_id)
return
try:
_feature_mon_handle(df)
except Exception:
logger.exception('UnExpected Exception')
finally:
df.last_round = timezone.now()
df.save(update_fields=["last_round"])
logger.info('++++++++++++++ Finished Checking for ID #%s...', df_id)
redis_mem = get_redis_mem('feature_mon_handle')
redis_mem.delete(str(df_id))
def _work(self):
features = get_installed_features()
query = DeviceFeature.objects.values_list('pk', flat=True).\
filter(feature__in=features, active=True, device__active=True).\
extra(where=["last_round is NULL or (last_round<NOW() - "
"(round_interval || ' seconds')::interval)"])
q_count = query.count()
if q_count == 0:
print('No feature found for this round!')
return
print('***** Processing {} device features'.format(q_count))
redis_mem = get_redis_mem('feature_mon_handle')
for df_id in query:
if not redis_mem.get(str(df_id)):
feature_mon_handle.delay(df_id)
redis_mem.set(str(df_id), True, expire=settings.REDIS_MEM_DEFAULT_EXPIRE)
else:
print('device feature #{} is already in queue!'.format(df_id))
def post(self, request, *args, **kwargs):
user_id = request.user.id
redis_mem = get_redis_mem('nmap_scan_network')
last_scan = redis_mem.get(str(user_id)) or {}
if last_scan.get('processing'):
warning_message('Network is already under scanning!', request)
return redirect('core:device-discover')
if last_scan:
redis_mem.delete(str())
form = self.get_form()
if form.is_valid():
ip_range = form.cleaned_data['ip_range']
task = nmap_scan_network.delay(user_id, ip_range)
redis_mem.set(str(user_id), {'ip_range': ip_range, 'processing': True, 'task_id': task.task_id},
expire=settings.REDIS_MEM_DEFAULT_EXPIRE)
return redirect('core:device-discover')
else:
send_form_errors(form, request)
ctx = self.get_context_data(form=form)
return render(request, self.template_name, ctx)
def nmap_scan_network(user_id, ip_range):
logger.info('++++++++++++++ Start Scanning network [%s] by [%s] ...',
ip_range, user_id)
redis_mem = get_redis_mem('nmap_scan_network')
try:
scan = scan_network_ips(ip_range)
redis_mem.set(str(user_id), {
'ip_range': ip_range,
'success': True,
'result': scan
})
except Exception as e:
redis_mem.set(str(user_id), {
'ip_range': ip_range,
'success': False,
'errors': e.args
})
logger.exception('UnExpected Exception')
finally:
logger.info(
'++++++++++++++ Finished Scanning network [%s] by [%s] ...',
ip_range, user_id)
def get_last_scan(self):
redis_mem = get_redis_mem('nmap_scan_network')
last_scan = redis_mem.get(str(self.request.user.id)) or {}
scan_result = last_scan.pop('result', {})
last_scan['discovered_devices'] = self._get_discovered_devices(scan_result)
return last_scan