def events(request):
if request.is_ajax() and request.method == "POST":
event_handler = EventHandler()
if "latest" not in request.POST or request.POST["latest"] == "null":
latest_seq_num = event_handler.get_current_sequence_number()
else:
latest_seq_num = int(request.POST["latest"])
start_timestamp = time.time()
event_messages = {"events": [], "latest": latest_seq_num}
while start_timestamp + 20 > time.time():
cur_seq_num = event_handler.get_current_sequence_number()
if latest_seq_num < cur_seq_num:
events = event_handler.get_events(latest_seq_num, cur_seq_num)
for event in events:
event_messages["events"].append({"msg": event["description"], "date": event["date"]})
if len(event_messages["events"]) > 0:
event_messages["latest"] = cur_seq_num
break
time.sleep(3)
data = json.dumps(event_messages)
return HttpResponse(data, "application/json")
else:
return HttpResponse("Invalid request")
def save(self):
interface_code = self.cleaned_data['file'].read()
parser = InterfaceParser()
interface = parser.parse(interface_code)
with transaction.commit_on_success():
i = Interface(name=interface['interface_name'], interface_file=self.cleaned_data['file'])
i.save()
for method in interface['precondition_methods']:
m = Method(name=method['method_name'], interface=i)
m.save()
for parameter in method['parameters']:
mp = MethodParameter(method=m, name=parameter)
mp.save()
for trigger in interface['trigger_methods']:
m = Method.objects.get(interface__name=interface['interface_name'], name=trigger)
t = Trigger(method=m)
t.save()
# Send file to Mirri
event_handler = EventHandler()
try:
client = MirriClient()
client.upload_interface_file(interface['interface_name'], self.cleaned_data['file'])
except (MirriConnectionError, MirriTimeoutError, MirriNotFoundError), e:
logger.error('Interface file %s could not be posted to Mirri: %s' % (self.cleaned_data['file'].name, e))
event_handler.add_event('Interface file %s could not be posted to Mirri: %s' % (self.cleaned_data['file'].name, e))
else:
def schedule_file(request):
if request.method == 'POST':
form = UploadScheduleFileForm(request.POST, request.FILES)
if form.is_valid():
try:
form.save()
except Exception, e:
return HttpResponseServerError(e)
event_handler = EventHandler()
event_handler.add_event(u'Schedule file %s was uploaded and parsed successfully' % form.cleaned_data['file'].name)
return HttpResponseRedirect(reverse('admin:core_schedule_changelist'))
def parse_schedules(request):
form = UploadScheduleFileForm(request.POST, request.FILES)
if form.is_valid():
try:
form.save()
except Exception, e:
return HttpResponseBadRequest(e)
event_handler = EventHandler()
event_handler.add_event(u'Schedule file %s was uploaded and parsed successfully' % request.FILES['file'].name)
logger.debug(u'Schedule file %s was uploaded and parsed successfully' % request.FILES['file'].name)
return HttpResponse(status=201)
def save(self):
action_code = self.cleaned_data['file'].read()
parser = ActionParser()
action = parser.parse(action_code)
with transaction.commit_on_success():
a = Action(name=action['action_name'], precondition_expression=action['precondition_expression'], action_file=self.cleaned_data['file'])
a.save()
for parameter in action['parameters']:
ap = ActionParameter(action=a, name=parameter['name'], parameter_position=parameter['position'])
ap.save()
action_devices = {}
for key, device in action['devices'].items():
ad = ActionDevice(action=a, name=key, parameter_position=device['parameter_position'])
ad.save()
action_devices[key] = ad
for interface_name in device['interfaces']:
i = Interface.objects.get(name=interface_name)
adi = ActionDeviceInterface(action_device=ad, interface=i)
adi.save()
for position, replacement in enumerate(action['precondition_replacements']):
apm = ActionPreconditionMethod(expression_position=position, action=a, action_device=action_devices[replacement['device']])
m = Method.objects.get(name=replacement['method'], interface__name=replacement['interface'])
apm.method = m
apm.save()
# Send file to Mirri
event_handler = EventHandler()
try:
client = MirriClient()
client.upload_action_file(self.cleaned_data['file'])
except (MirriConnectionError, MirriTimeoutError, MirriNotFoundError), e:
logger.error('Action file %s could not be posted to Mirri: %s' % (self.cleaned_data['file'].name, e))
event_handler.add_event('Action file %s could not be posted to Mirri: %s' % (self.cleaned_data['file'].name, e))
else:
from core.clients import MirriClient, MirriConnectionError, MirriTimeoutError, \
MirriNotFoundError, CaasClient, CaasConnectionError, CaasTimeoutError, \
CaasNotFoundError, CaasInternalServerError
from core.configuration_models import KumbangModelGenerator, WcrlModelGenerator
from django.core.files.base import ContentFile
from events.event import EventHandler
from profiler.decorators import profile
from kurre.settings import *
import logging
import models
logger = logging.getLogger(__name__)
event_handler = EventHandler()
@profile
def start_kumbang_configuration_task(device, schedules):
logger.debug( "Starting configuration: self.schedules: %r" % (schedules) )
# TODO Send post to CAAS
# Get all devices in the same proximity group as the device
#devices =
#kbser = util.KumbangService( "http://caas.soberit.hut.fi", "KumbangConfigurator" )
#for sched in self.schedules:
# kbser.generateModel( sched )
# Get the precondition methods that are related to the actions in the schedules
# Requires optimization
methods = {}
for sched in schedules:
actions = sched.actions.all() #scheduleaction_set.filter(schedule=sched) #models.ScheduleAction.objects.filter( schedule = sched )
for act in actions:
from core.configuration_models import WcrlModelGenerator
from core.forms import UploadInterfaceFileForm, UploadActionFileForm, \
UploadScheduleFileForm, ConfigurationForm
from django.http import HttpResponse, HttpResponseBadRequest
from django.utils import simplejson
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_http_methods
from events.event import EventHandler
import json
import logging
import kurre.settings as settings
from models import Device
from recommenders import Recommender, RecommenderException
logger = logging.getLogger(__name__)
event_handler = EventHandler()
@csrf_exempt
@require_http_methods(['POST'])
def parse_interfaces(request):
form = UploadInterfaceFileForm(request.POST, request.FILES)
if form.is_valid():
try:
form.save()
except Exception, e:
return HttpResponseBadRequest(e)
event_handler = EventHandler()
event_handler.add_event(u'Interface file %s was uploaded and parsed successfully' % request.FILES['file'].name)
logger.debug(u'Interface file %s was uploaded and parsed successfully' % request.FILES['file'].name)
* :class:`ActionPreconditionMethod`: A model class for precondition methods
defined in actions.
"""
from core import signals
from core.clients import ProximityClient, ProximityClientConnectionError
from django.db import models, transaction
from django.db.models.signals import post_delete
from events.event import EventHandler
from django.contrib.auth.models import User
import logging
logger = logging.getLogger(__name__)
event_handler = EventHandler()
signals.state_triggered.connect(signals.start_configuration)
signals.schedule_added.connect(signals.generate_configuration_model)
signals.device_interface_added.connect(signals.update_configuration_models)
#signals.device_interface_deleted.connect(signals.update_configuration_models)
class Base(models.Model):
"""An abstract base class that can be inherited by other model classes.
This class can be used for defining database fields that are common to
many different tables.
Class attributes:
* created_at: A Django :class:`~django.db.models.DateTimeField` object
