def reset_cache(self) -> None:
ping_cache_helper = PingCacheHelper()
ping_data = ping_cache_helper.get(self.rpid)
if ping_data:
self.process_ping_data(ping_data)
self.save()
ping_cache_helper.delete(self.rpid)
def get_ping_handler(self, request: HttpRequest,
rpid: str) -> JsonResponse:
ping_cache_helper = PingCacheHelper()
ping_data = ping_cache_helper.get_data_for_request(request)
ping_data['last_ping'] = timezone.now()
ping_cache_helper.set(rpid, ping_data)
self.add_log(request, rpid, 'PING {}'.format(request.GET.urlencode()))
response_data = self._get_ping_response_data(request, rpid, ping_data)
return self.json_response(request, rpid, response_data)
def restart_raspberry_pi(self, request, queryset):
for lead in queryset:
if not lead.raspberry_pi:
messages.warning(
request,
'Lead {} does not haave RaspberryPi assigned, skipping'.
format(lead.email))
continue
lead.raspberry_pi.restart_required = True
lead.raspberry_pi.save()
if lead.raspberry_pi:
PingCacheHelper().delete(lead.raspberry_pi.rpid)
messages.info(
request,
'Lead {} RPi restart successfully requested. RPi and tunnel should be online in two minutes.'
.format(lead.email))
def get(self, request):
ping_cache_helper = PingCacheHelper()
ping_keys = cache.get('ping_keys', [])
rpid = request.GET.get('rpid')
if rpid:
ping_keys = [ping_cache_helper.get_key(rpid)]
rpids_ping_map = {}
for ping_key in ping_keys:
ping_data = cache.get(ping_key)
if not ping_data:
continue
rpid = ping_data['rpid']
rpids_ping_map[rpid] = ping_data
rpids = []
invalidated_rpids = []
raspberry_pis = RaspberryPi.objects.filter(
rpid__in=rpids_ping_map.keys()).prefetch_related('lead')
ec2_instances = EC2Instance.objects.filter(
rpid__in=rpids_ping_map.keys()).select_related('lead')
ec2_instances_map = {}
for ec2_instance in ec2_instances:
ec2_instances_map[ec2_instance.rpid] = ec2_instance
for raspberry_pi in raspberry_pis:
ping_data = rpids_ping_map.get(raspberry_pi.rpid)
rpid = ping_data['rpid']
rpids.append(rpid)
ec2_instance = ec2_instances_map.get(rpid)
self.process_ping_data(ping_data, raspberry_pi, ec2_instance)
if not ping_cache_helper.is_data_consistent(
ping_data,
raspberry_pi=raspberry_pi,
ec2_instance=ec2_instance,
):
ping_cache_helper.delete(rpid)
invalidated_rpids.append(rpid)
bulk_update(raspberry_pis,
update_fields=[
'ip_address', 'first_seen', 'first_tested',
'online_since_date', 'last_seen', 'version'
])
bulk_update(ec2_instances,
update_fields=['last_troubleshoot', 'tunnel_up_date'])
return JsonResponse({
'rpids': rpids,
'invalidated': invalidated_rpids,
'result': True,
})
def get_hostname_handler(self, request: HttpRequest,
rpid: str) -> HttpResponse:
ping_cache_helper = PingCacheHelper()
ping_data = ping_cache_helper.get_data_for_request(request)
return HttpResponse(ping_data.get('hostname') or '')
def get_cache(self) -> typing.Optional[PingDataType]:
ping_cache_helper = PingCacheHelper()
ping_data = ping_cache_helper.get(self.rpid)
return ping_data
def clear_ping_cache(self, request, queryset):
for ec2_instance in queryset:
PingCacheHelper().delete(ec2_instance.rpid)
def restart_raspberry_pi(self, request, queryset):
for ec2_instance in queryset:
if ec2_instance.lead and ec2_instance.lead.raspberry_pi:
ec2_instance.lead.raspberry_pi.restart_required = True
ec2_instance.lead.raspberry_pi.save()
PingCacheHelper().delete(ec2_instance.rpid)