Beispiel #1
0
def add_new(request):
    context = RequestContext(request)
    if request.method=='POST':
        n = eval(request.POST['tipo_new'])
        n.nombre=request.POST['nombre_new']
        n.desc=request.POST['desc_new']
        if su(request):
            n.active = True
        n.save()
        if not su(request):
            tipo_a = request.POST['tipo_new']
            sender = {"Idioma()":'idiomas',"Lenguaje()":'lenguajes',"Jobs()":'trabajos'}
            pager = {"Idioma()":'obj_i.html',"Lenguaje()":'obj_l.html',"Jobs()":'obj_t.html'}
            helper = "#r_" + sender[tipo_a].partition("s")[0]
            print helper
            template = get_template(pager[tipo_a])
            print template
            aux = tipo_a.partition("(")[0] + ".objects.filter(active = False)"
            objs = eval(aux)
            context[sender[tipo_a]]=objs
            print context
            html = template.render(context)
            print html
            publish(
                'proy',
                'su',
                { 'loader' : helper,
                    'data' : html},
                sender='server'  # sender id of the event, can be None.
            )
    return HttpResponse(status=202)
Beispiel #2
0
def new_message(request):
    post_data = request.POST
    message = post_data['message']
    user = request.user
    Message.objects.create(user=user, message=post_data['message'])
    publish('chatapp', 'new_msg', {'text': message, 'username': user.username}, sender='server')
    return HttpResponse(json.dumps({'success': True}), content_type="application/json")
def recargar(helper, result):
    publish(
        'module_recargar',
        'reload',
        { 'loader' : helper,
            'data' : result},
        sender='server'  # sender id of the event, can be None.
    )
Beispiel #4
0
def IrrigatorUpdated(sender, **kwargs):
  if (kwargs["update_fields"] and
      kwargs["update_fields"] == ["in_watering_cycle"]):
    publish(
        "pidrator", "irrigator-%d" % kwargs["instance"].pk,
        {"in_watering_cycle": kwargs["instance"].in_watering_cycle})
  else:
    CheckIrrigators.delay(pk=kwargs["instance"].pk)
Beispiel #5
0
def SensorUpdated(sender, **kwargs):
  CheckThermostats.delay(sensor=kwargs["instance"])
  if kwargs["instance"].temperature is not None:
    kwargs["instance"].temperature = float(kwargs["instance"].temperature)

  publish(
      "pimostat", "sensor-%d" % kwargs["instance"].pk,
      {"temperature": kwargs["instance"].temperature})
Beispiel #6
0
 def update(self, canal="chat", typ="msg", info={"msg":"alive"}):
     print("TYP> "+ typ + "INFO>" + unicode(info))
     publish(
         canal,
         typ,
         info,
         sender='server'
     )
Beispiel #7
0
def send_hello_world():
    publish(
        'foo',  # the name of the channel
        'bar',  # the `type` of the message/event, clients use this name
                  # to register event handlers
        {'text': 'Hello world'},  # payload of the event, needs to be
                                  # a dict which is JSON dumpable.
        sender='server'  # sender id of the event, can be None.
    )
Beispiel #8
0
    def server_publish(cls, channel, payload_type, data, sender='server'):
        print "Server publish in %s " % cls.form_channel_full_name(channel)

        publish(
            cls.form_channel_full_name(channel),
            # Send to the root
            payload_type,
            data,
            sender='server')
Beispiel #9
0
 def send_message(self, message):
     message = Bot.objects.create(message=message, date=timezone.now(),
                                  nickname='Бот').__str__()
     publish(
         'mychannel',
         'message',
         {'message': message},
         sender='server'
     )
    def on_success(self, data):
        if 'coordinates' in data and data['coordinates']:
            tweet = {
                'tweet_id': data['id_str'],
                'coordinates': data['coordinates']['coordinates']
            }

            logger.info('Tweet {0} from {1}'.format(
                tweet['tweet_id'], tweet['coordinates']))
            api.publish('tweets', 'tweet', tweet)
Beispiel #11
0
def mod_proy(request, proj):
    context = RequestContext(request)
    proj = Proj.objects.get(id=proj)
    if perm(request, proj.owner) and request.method == 'POST':
        print request.POST
        proj.nombre = request.POST['name']
        proj.desc = request.POST['desc_proy']
        proj.save()
        p_i = request.POST.getlist("idiomas")
        proj.nescesita_i.clear()
        for i in p_i:
            aux = Idioma.objects.get(id=i)
            proj.nescesita_i.add(aux)
        p_l = request.POST.getlist("lenguajes")
        proj.nescesita_l.clear()
        for i in p_l:
            aux = Lenguaje.objects.get(id=i)
            proj.nescesita_l.add(aux)
        for i in proj.rol_set.all():
            rol_user = Rol.objects.get(id=i.id)
            if proj in rol_user.proj_user.all():
                if discover(proj, rol_user):
                    rol_user.proj_user.add(proj)
                else:
                    rol_user.proj_user.remove(proj)
            else:
                if discover(proj, rol_user):
                    rol_user.proj_user.add(proj)
        publish(
            'proy',
            'reload',
            {"id_proy": proj.id},
            sender='server'  # sender id of the event, can be None.
        )
        return redirect('/')
    idiomas = Idioma.objects.filter(active=True)
    lenguajes = Lenguaje.objects.filter(active=True)
    trabajos = Jobs.objects.filter(active=True)
    rol_user = Rol.objects.get(user=request.user)
    return render_to_response(
        'm_proj.html', {
            'idiomas': idiomas,
            'lenguajes': lenguajes,
            'trabajos': trabajos,
            'proj': proj,
            'works': proj.nescesita_w,
            'rol_user': rol_user,
            'perm': perm(request, proj.owner)
        }, context)
Beispiel #12
0
    def post(self, request, *args, **kwargs):
        chat_user_id = request.POST.get("user_id")
        chat_room_id = request.POST.get("room_id")
        message = request.POST.get("message")

        chat_message = ChatMessage()

        chat_message.chat_user_id = int(chat_user_id)
        chat_message.chat_room_id = int(chat_room_id)
        chat_message.message = message
        chat_message.save()

        publish('chat', 'message', chat_message.to_dict(), sender=None)

        return JsonResponse(chat_message.to_dict(), safe=False)
Beispiel #13
0
def add_active(request):
    context = RequestContext(request)
    if request.method == 'POST' and su(request):
        tipo_a = request.POST['tipo']
        id_a = request.POST['id']
        print id_a, tipo_a
        pos = {"Idioma": Idioma, "Lenguaje": Lenguaje, "Jobs": Jobs}
        sender = {
            "Idioma": 'idiomas',
            "Lenguaje": 'lenguajes',
            "Jobs": 'trabajos'
        }
        pager = {
            "Idioma": 'obj_i.html',
            "Lenguaje": 'obj_l.html',
            "Jobs": 'obj_t.html'
        }
        aux = tipo_a + ".objects.get(id = " + id_a + ")"
        print aux
        obj = eval(aux, pos)
        print obj
        if request.POST['tDo'] == "True":
            obj.active = True
            obj.save()
        else:
            obj.delete()
        aux = tipo_a + ".objects.filter(active = False)"
        objs = eval(aux, pos)
        print "----"
        helper = "#r_" + sender[tipo_a].partition("s")[0]
        print helper
        template = get_template(pager[tipo_a])
        print template
        context[sender[tipo_a]] = objs
        print context
        html = template.render(context)
        print html
        publish(
            'proy',
            'su',
            {
                'loader': helper,
                'data': html
            },
            sender='server'  # sender id of the event, can be None.
        )
        return render_to_response(pager[tipo_a], {sender[tipo_a]: objs},
                                  context)
Beispiel #14
0
def mod_proy(request, proj):
    context = RequestContext(request)
    proj = Proj.objects.get(id = proj)
    if perm(request, proj.owner) and request.method=='POST':
        print request.POST
        proj.nombre = request.POST['name']
        proj.desc = request.POST['desc_proy']
        proj.save()
        p_i = request.POST.getlist("idiomas")
        proj.nescesita_i.clear()
        for i in p_i:
            aux = Idioma.objects.get(id = i)
            proj.nescesita_i.add(aux)
        p_l = request.POST.getlist("lenguajes")
        proj.nescesita_l.clear()
        for i in p_l:
            aux = Lenguaje.objects.get(id = i)
            proj.nescesita_l.add(aux)
        for i in proj.rol_set.all():
            rol_user = Rol.objects.get(id = i.id)
            if proj in rol_user.proj_user.all():
                if discover(proj,rol_user):
                    rol_user.proj_user.add(proj)
                else:
                    rol_user.proj_user.remove(proj)
            else:
                if discover(proj,rol_user):
                    rol_user.proj_user.add(proj)
        publish(
            'proy',
            'reload',
            {"id_proy":proj.id},
            sender='server'  # sender id of the event, can be None.
        )
        return redirect('/')
    idiomas = Idioma.objects.filter(active = True)
    lenguajes = Lenguaje.objects.filter(active = True)
    trabajos = Jobs.objects.filter(active = True)
    rol_user = Rol.objects.get(user = request.user)
    return render_to_response('m_proj.html',
                              {'idiomas':idiomas,
                               'lenguajes':lenguajes,
                               'trabajos':trabajos,
                               'proj':proj,
                               'works':proj.nescesita_w,
                              'rol_user':rol_user,
                              'perm':perm(request, proj.owner)},
                              context)
Beispiel #15
0
def send_hello_world():
    while True:
        time.sleep(0.5)
        message = "".join([random.choice(string.ascii_letters) for i in range(10)])
        timestamp = str(datetime.now())
        print("Sending: %s, %s" % (message, timestamp))
        publish(
            "24",  # the name of the channel
            "approval",  # the `type` of the message/event,
            # clients use this name
            # to register event handlers
            # payload of the event, needs to be
            # a dict which is JSON dumpable.
            {"message": message, "timestamp": timestamp},
            sender="server",  # sender id of the event, can be None.
        )
Beispiel #16
0
def add_new(request):
    context = RequestContext(request)
    if request.method == 'POST':
        n = eval(request.POST['tipo_new'])
        n.nombre = request.POST['nombre_new']
        n.desc = request.POST['desc_new']
        if su(request):
            n.active = True
        n.save()
        if not su(request):
            tipo_a = request.POST['tipo_new']
            sender = {
                "Idioma()": 'idiomas',
                "Lenguaje()": 'lenguajes',
                "Jobs()": 'trabajos'
            }
            pager = {
                "Idioma()": 'obj_i.html',
                "Lenguaje()": 'obj_l.html',
                "Jobs()": 'obj_t.html'
            }
            helper = "#r_" + sender[tipo_a].partition("s")[0]
            print helper
            template = get_template(pager[tipo_a])
            print template
            aux = tipo_a.partition("(")[0] + ".objects.filter(active = False)"
            objs = eval(aux)
            context[sender[tipo_a]] = objs
            print context
            html = template.render(context)
            print html
            publish(
                'proy',
                'su',
                {
                    'loader': helper,
                    'data': html
                },
                sender='server'  # sender id of the event, can be None.
            )
    return HttpResponse(status=202)
Beispiel #17
0
def main():
    while True:
        fromid = callid()
        message = {}
        cust = get_customer(fromid['phone'], fromid['NAME'])
        message['callernumber'] = fromid['phone']
        message['callername'] = fromid['NAME']
        message['calledat'] = fromid['time']
        message['NMBR'] = fromid['NMBR']
        message['customer'] = cust['name']
        message['pk'] = cust['pk']
        message['url'] = cust['url']
        message['custtype'] = cust['custtype']
        publish('callerid', 'caller', message)
        print("published...", message)

        crs.execute("insert into customers_call "
                    "values (default, '{}','{}','{}',{}) ".format(
                        fromid['phone'], fromid['NAME'], fromid['time'],
                        cust["pk"]))
        crs.execute("commit")
Beispiel #18
0
def publish(channel, payload_type, payload=None, sender=None):
    """
    calling this publish method sends a push
    notification to all the registered clients

    :param channel: name of the channel
    :param payload_type: the `type` of the message/event,
    clients use this name to register event handlers
    :param payload: payload of the event, needs to be
    a dict which is JSON dumpable.
    """
    return api.publish(channel, payload_type, payload, sender)
Beispiel #19
0
def add_active(request):
    context = RequestContext(request)
    if request.method=='POST' and su(request):
        tipo_a = request.POST['tipo']
        id_a = request.POST['id']
        print id_a, tipo_a
        pos = {"Idioma":Idioma,"Lenguaje":Lenguaje,"Jobs":Jobs}
        sender = {"Idioma":'idiomas',"Lenguaje":'lenguajes',"Jobs":'trabajos'}
        pager = {"Idioma":'obj_i.html',"Lenguaje":'obj_l.html',"Jobs":'obj_t.html'}
        aux = tipo_a + ".objects.get(id = "+ id_a + ")"
        print aux
        obj = eval(aux, pos)
        print obj
        if request.POST['tDo']=="True":
            obj.active = True
            obj.save()
        else:
            obj.delete()
        aux = tipo_a + ".objects.filter(active = False)"
        objs = eval(aux, pos)
        print "----"
        helper = "#r_" + sender[tipo_a].partition("s")[0]
        print helper
        template = get_template(pager[tipo_a])
        print template
        context[sender[tipo_a]]=objs
        print context
        html = template.render(context)
        print html
        publish(
            'proy',
            'su',
            { 'loader' : helper,
                'data' : html},
            sender='server'  # sender id of the event, can be None.
        )
        return render_to_response(pager[tipo_a],
                              {sender[tipo_a]:objs},
                              context)
Beispiel #20
0
def RelayUpdated(sender, **kwargs):
  publish(
      "pimostat", "relay-%d" % kwargs["instance"].pk,
      {"actuated": str(kwargs["instance"].actuated)})
Beispiel #21
0
def SensorUpdated(sender, **kwargs):
  CheckIrrigators.delay(sensor=kwargs["instance"])
  publish(
      "pidrator", "sensor-%d" % kwargs["instance"].pk,
      {"moisture": None if not kwargs["instance"].moisture else
           float(kwargs["instance"].moisture)})
Beispiel #22
0
 def send_message():
     api.publish('channel', 'type', {'test': 'works!'})
     time.sleep(1)
     api.publish('channel', 'type', {'test': 'works!'})
Beispiel #23
0
def RelayUpdated(sender, **kwargs):
  publish(
      "pidrator", "relay-%d" % kwargs["instance"].pk,
      {"actuated": kwargs["instance"].actuated})
Beispiel #24
0
def test_publish(publish_mock):
    result = publish('mychan', 'thetype', payload={1: 2}, sender='snd')

    assert result == publish_mock.return_value
    assert publish_mock.call_args[0] == ('mychan', 'thetype', {1: 2}, 'snd')
Beispiel #25
0
def RelayUpdated(sender, **kwargs):
  publish(
      "lazylight", "update-relay",
      {"relay_pk": kwargs["instance"].pk,
       "actuated": kwargs["instance"].actuated})
Beispiel #26
0
 def send_message():
     api.publish('channel', 'type', {'test': 'works!'})
     time.sleep(1)
     api.publish('channel', 'type', {'test': 'works!'})
Beispiel #27
0
 def update(self, canal="chat", typ="msg", info={"msg": "alive"}):
     print("TYP> " + typ + "INFO>" + unicode(info))
     publish(canal, typ, info, sender='server')
Beispiel #28
0
def aws_create(request, playground):
    reqData = request.POST
    sgroups = str(reqData.getlist('secGroups[]', []))

    """
    Create the instance and initiate chef-zero using Vagrant

    """

    aws_access_key = UserConfig.objects.findOrCreate_AwsKey(request.user).val
    aws_secret_key = UserConfig.objects.findOrCreate_AwsSecret(request.user).val

    create_private_key(aws_access_key, aws_secret_key)    

    http_proxy = UserConfig.objects.findOrCreate_ProxyHttp(request.user).val
    https_proxy = UserConfig.objects.findOrCreate_ProxyHttps(request.user).val

    print("Printing create post", flush=True)
    print(request.POST)
    # Names rather than django ids are used since the sandbox id isn't generated until later.  This is a chicken/egg problem.
    sandbox_name = request.POST['name']
    m = hashlib.sha256()
    m.update(sandbox_name.encode('utf-8'))
    m.update(playground.name.encode('utf-8'))
    vm_id = m.hexdigest()

    # We already track sandbox's through the SandboxVM model, the check should occur there.
    if os.path.exists(VAGRANT_PATH + vm_id):
       print("VM already exists: " + VAGRANT_PATH + vm_id, flush=True)
       return "error" # Consider better error handling
    else:
       os.makedirs(VAGRANT_PATH + vm_id)

    # Fix Berksfile path resolution to work with both 'geoq' and 'geoq::default' formats
    berksfile_dirname = request.POST['recipe'].split("::")[0]

    #Generate the Vagrantfile in the cookbook directory
    file = open(VAGRANT_PATH + vm_id + '/Vagrantfile', 'w')
    file.write('Vagrant.configure(2) do |config|\n')
    if platform.system() == "Windows":
        file.write('  ENV["VAGRANT_DETECTED_OS"] = ENV["VAGRANT_DETECTED_OS"].to_s + " cygwin"\n')
    else:
        file.write('  ENV["VAGRANT_DETECTED_OS"] = ENV["VAGRANT_DETECTED_OS"].to_s\n')
    file.write('  config.ssh.username = "******"\n')

    file.write('  config.ssh.private_key_path = "' + PRIVATE_KEY_PATH + '"\n')
    file.write('  config.ssh.pty = true\n')
    # The Berksfile is located in the specific cookbook directory
    file.write('  config.berkshelf.berksfile_path = "' + COOKBOOK_PATH + berksfile_dirname + '/Berksfile"\n')
    file.write('  config.berkshelf.enabled = true\n')
    file.write('  config.vm.synced_folder "", "/vagrant", type: "rsync", rsync__exclude: ".git/"\n')
    file.write('  config.proxy.http = "' + http_proxy + '"\n')
    file.write('  config.proxy.https = "' + https_proxy + '"\n')
    file.write('  config.vm.box = "dummy"\n')
    file.write('  config.trigger.before [:reload, :up, :provision], stdout: true do\n')
    file.write('      SYNCED_FOLDER = ".vagrant/machines/default/aws/synced_folders"\n')
    file.write('      info "Trying to delete folder #{SYNCED_FOLDER}"\n')
    file.write('      # Delete synced folders as workaround to known vagrant bug.\n')
    file.write('      begin\n')
    file.write('          File.delete(SYNCED_FOLDER)\n')
    file.write('      rescue Exception => ex\n')
    file.write('          warn "Could not delete folder #{SYNCED_FOLDER}."\n')
    file.write('          warn ex.message\n')
    file.write('      end\n')
    file.write('  end\n')
    file.write('  config.vm.provider :aws do |aws|\n')
    file.write('    aws.user_data = "#!/bin/bash\\nsed -i -e \'s/^Defaults.*requiretty/# Defaults requiretty/g\' /etc/sudoers"\n')
    file.write('    aws.access_key_id = "'+ aws_access_key + '"\n')
    file.write('    aws.secret_access_key = "'+aws_secret_key+'"\n')
    file.write('    aws.keypair_name = "'+ COCREATELITE_KEYNAME +'"\n')
    file.write('    aws.instance_type = "'+ request.POST['type'] +'"\n')
    file.write('    aws.region = "'+ DEFAULT_REGION + '"\n')
    file.write('    aws.security_groups = '+ sgroups +'\n')
    file.write('    aws.ami = "'+ request.POST['ami'] + '"\n')
    file.write('    aws.subnet_id = "'+ request.POST['subnet']+'"\n')
    file.write('    aws.tags = {\n')
    file.write('      "Name" => "'+ request.POST['name'] +' "\n')
    file.write('    }\n')
    file.write('    aws.associate_public_ip = true\n')
    file.write('  end\n')
    file.write('  config.vm.provision "chef_zero" do |chef|\n')
    file.write('    chef.cookbooks_path = "'+ COOKBOOK_PATH + '"\n')
    file.write('    chef.nodes_path = "/tmp"\n')
    file.write('    chef.add_recipe "' + request.POST['recipe'] + '"\n')
    file.write('    chef.environment = "cocreatelite"\n')
    file.write('    chef.environments_path = "' + ENVIRONMENT_PATH + '"\n')
    file.write('  end\n')
    file.write('end')
    file.close()

    # TODO: a separate process using something like Celery or Twisted to 
    #       create/provision the new resource and provide better status info
    
    # Run 

    cwd_path = VAGRANT_PATH + vm_id
    aws_name = request.POST['name']

    # needed to force the provider in some environments (like mine)
    os.environ['VAGRANT_DEFAULT_PROVIDER'] = 'aws'
    os.environ['HOME'] = '/root'

    vagrant_cmd = 'vagrant up --no-provision --provider=aws'
    print("executing: " + vagrant_cmd, flush=True)
    api.publish('vagrants', aws_name, {'text': ''}) # omnibus appears to eat first event
    api.publish('vagrants', aws_name, {'text': vagrant_cmd})

    vagrantProcess = subprocess.Popen(vagrant_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, cwd=cwd_path)

    print("bout to print stdout", flush=True)

    if vagrantProcess.stdout is not None:
        for line in iter(vagrantProcess.stdout.readline, b''):
            line = line.decode("utf-8").rstrip()
            print("<stdout> " + line, flush=True)
            api.publish('vagrants', aws_name, {'text': line})

    print("bout to print stderror", flush=True)

    if vagrantProcess.stderr is not None:
        for line in iter(vagrantProcess.stderr.readline, b''):
            line = line.decode("utf-8").rstrip()
            print("<stderr> " + line, flush=True)
            api.publish('vagrants', aws_name, {'text': line})

    # add space between
    api.publish('vagrants', aws_name, {'text': ''})


    vagrant_cmd = 'vagrant awsinfo -m default -p'
    print("executing: " + vagrant_cmd, flush=True)
    api.publish('vagrants', aws_name, {'text': vagrant_cmd})

    vagrantProcess = subprocess.Popen(vagrant_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, cwd=cwd_path)

    instance_id = ''

    if vagrantProcess.stdout is not None:
        aws_info = ''
        for line in iter(vagrantProcess.stdout.readline, b''):
            line = line.decode("utf-8").rstrip()
            print("<stdout> " + line, flush=True)
            api.publish('vagrants', aws_name, {'text': line})  
            aws_info += line   
        
        # TODO:  so this will fail if aws_stdout doesn't hhave the expected string
        #        need to trap and better handle either here or by what calls this
        #        method
        
        instance_id = json.loads(aws_info)['instance_id']
        print("set instance_id = " + instance_id)        

    if vagrantProcess.stderr is not None:
        for line in iter(vagrantProcess.stderr.readline, b''):
            line = line.decode("utf-8").rstrip()
            print("<stderr> " + line, flush=True)
            api.publish('vagrants', aws_name, {'text': line})


    # add space between
    api.publish('vagrants', aws_name, {'text': ''})

    
    vagrant_cmd = 'vagrant provision'
    print("executing: " + vagrant_cmd, flush=True)
    api.publish('vagrants', aws_name, {'text': vagrant_cmd})
    vagrantProcess = subprocess.Popen(vagrant_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, cwd=cwd_path)

    if vagrantProcess.stdout is not None:
        for line in iter(vagrantProcess.stdout.readline, b''):
            line = line.decode("utf-8").rstrip()
            print("<stdout> " + line, flush=True)
            api.publish('vagrants', aws_name, {'text': line})


    if vagrantProcess.stderr is not None:
        for line in iter(vagrantProcess.stderr.readline, b''):
            line = line.decode("utf-8").rstrip()
            print("<stderr> " + line, flush=True)
            api.publish('vagrants', aws_name, {'text': line})

    # add space between 
    api.publish('vagrants', aws_name, {'text': ''})

    api.publish('vagrants', aws_name, {'text': 'Done.  Goodbye.'})

    return instance_id