def run(self): self.error = {} attachThreadToJVM() try: cone_beam_projector = ConeBeamProjector() if self.use_cl: if self.proj_idx is None: sino = OpenCLGrid3D( Grid3D(*pyconrad.config.get_sino_size())) cone_beam_projector.fastProjectRayDrivenCL( sino, OpenCLGrid3D(self.phantom)) self.fwd_proj = Grid3D(sino) #self.fwd_proj = cone_beam_projector.projectRayDrivenCL(self.phantom) else: size = Grid3D(*pyconrad.config.get_sino_size()).getSize() sino = OpenCLGrid2D(Grid2D(size[0], size[1])) cone_beam_projector.fastProjectRayDrivenCL( sino, OpenCLGrid3D(self.phantom), self.proj_idx) self.fwd_proj = Grid2D(sino) else: if self.proj_idx is None: self.fwd_proj = cone_beam_projector.projectPixelDriven( self.phantom) else: self.fwd_proj = cone_beam_projector.projectPixelDriven( self.phantom, self.proj_idx) except JavaException as exception: if old_exception_type: self.error['message'] = exception.message() else: self.error['message'] = exception.message self.error['stacktrace'] = exception.stacktrace() detachThreadFromJVM() self.fwd_proj_finished.emit('finished')
def checkTextStandardLicense(license, compareText): """Compares the license text to the license text of SPDX Standard License. Arguments: license {string} -- SPDX standard license. compareText {string} -- Text to compare with the standard license. Returns: string -- Difference message if any differences found or None. """ if (jpype.isJVMStarted()==0): # If JVM not already started, start it, attach a Thread and start processing the request dirpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) classpath = os.path.join(dirpath, "tool.jar") jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s"%classpath) # Attach a Thread and start processing the request jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.compare") compareclass = package.LicenseCompareHelper try: # Call the java method isTextStandardLicense present in the SPDX Tools diff = compareclass.isTextStandardLicense(license, compareText) isDifferenceFound = jpype.JBoolean(diff.isDifferenceFound()) jpype.detachThreadFromJVM() return isDifferenceFound except: jpype.detachThreadFromJVM() raise
def getListedLicense(licenseId): """Get a SPDX listed license if the given SPDX license ID is present in the SPDX license list otherwise null. Arguments: licenseId {string} -- SPDX listed license ID Returns: string -- SPDX listed license or null """ if (jpype.isJVMStarted()==0): # If JVM not already started, start it, attach a Thread and start processing the request dirpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) classpath = os.path.join(dirpath, "tool.jar") jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s"%classpath) # Attach a Thread and start processing the request jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.rdfparser.license") licenseinfofactoryclass = package.LicenseInfoFactory try: # Call the method getListedLicenseById present in the SPDX Tools listed_license = licenseinfofactoryclass.getListedLicenseById(licenseId) jpype.detachThreadFromJVM() return listed_license except: jpype.detachThreadFromJVM() raise
def run(self): jpype.attachThreadToJVM() if self.use_cl: self.fanogram = self.ForwardProj.projectRayDrivenCL(self.Phantom) else: self.fanogram = self.ForwardProj.projectRayDriven(self.Phantom) # time.sleep(5) jpype.detachThreadFromJVM() self.forward_project_finsihed.emit('finished')
def run(self): jpype.attachThreadToJVM() # time.sleep(5) if self.use_cl: self.back = self.Backprojection.backprojectPixelDrivenCL( self.fanogram) else: self.back = self.Backprojection.backprojectPixelDriven( self.fanogram) jpype.detachThreadFromJVM() self.back_project_finsihed.emit('finished')
def convertError(status): print("Error while converting file") if status == '400': message = "Select valid conversion types." returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 elif status == '404': message = "File Not Found" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() return (message, returnstatus, httpstatus)
def wrapper(*args, **kwargs): #Sanity check before we start using JPype if not jpype.isThreadAttachedToJVM(): jpype.attachThreadToJVM() #Can't have too many sanity checks since something might be amiss if jpype.isThreadAttachedToJVM(): return_value = function(*args, **kwargs) #Detach from the JVM after we are done jpype.detachThreadFromJVM() return return_value
def validate(request): """ Handle Validate api request """ if request.method == 'GET': """ Return all validate api request """ query = ValidateFileUpload.objects.all() serializer = ValidateSerializer(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return validate tool result on the post file""" serializer = ValidateSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted() == 0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath = abspath(".") + "/tool.jar" jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath) """Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") verifyclass = package.Verify try: if request.FILES["file"]: """ Saving file to the media directory """ myfile = request.FILES['file'] folder = "api/" + str(request.user) + "/" + str(int( time())) fs = FileSystemStorage( location=settings.MEDIA_ROOT + "/" + folder, base_url=urljoin(settings.MEDIA_URL, folder + '/')) filename = fs.save(myfile.name, myfile) uploaded_file_url = fs.url(filename) """ Call the java function with parameter""" retval = verifyclass.verify(settings.APP_DIR + uploaded_file_url) if (len(retval) > 0): result = "The following error(s)/warning(s) were raised: " + str( retval) returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() else: result = "This SPDX Document is valid." returnstatus = status.HTTP_201_CREATED httpstatus = 201 jpype.detachThreadFromJVM() else: result = "File Not Uploaded" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except jpype.JavaException, ex: """ Error raised by verifyclass.verify without exiting the application""" result = jpype.JavaException.message( ex ) #+ "This SPDX Document is not a valid RDF/XML or tag/value format" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except:
def validate(request): """ Handle Validate api request """ if request.method == 'GET': """ Return all validate api request """ query = ValidateFileUpload.objects.all() serializer = ValidateSerializer(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return validate tool result on the post file""" serializer = ValidateSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted() == 0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath = settings.JAR_ABSOLUTE_PATH jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath) """Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") verifyclass = package.Verify query = ValidateFileUpload.objects.create( owner=request.user, file=request.data.get('file')) uploaded_file = str(query.file) uploaded_file_path = str(query.file.path) try: if request.FILES["file"]: """ Call the java function with parameter""" retval = verifyclass.verify(uploaded_file_path) if (len(retval) > 0): result = "The following error(s)/warning(s) were raised: " + str( retval) returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() else: result = "This SPDX Document is valid." returnstatus = status.HTTP_201_CREATED httpstatus = 201 jpype.detachThreadFromJVM() else: result = "File Not Uploaded" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except jpype.JavaException, ex: """ Error raised by verifyclass.verify without exiting the application""" result = jpype.JavaException.message( ex ) #+ "This SPDX Document is not a valid RDF/XML or tag/value format" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except:
def run(self): self.error = {} attachThreadToJVM() try: if False: focalLength = float(self.geo.getSourceToDetectorDistance()) maxU_PX = self.geo.getDetectorWidth() maxV_PX = self.geo.getDetectorHeight() deltaU = float(self.geo.getPixelDimensionX()) deltaV = float(self.geo.getPixelDimensionY()) maxU = float(maxU_PX * deltaU) maxV = float(maxV_PX * deltaV) cbFilter = ConeBeamCosineFilter(focalLength, maxU, maxV, deltaU, deltaV) ramK = RamLakKernel(maxU_PX, deltaU) for i in range(self.geo.getProjectionStackSize()): if self.apply_cosine: cbFilter.applyToGrid(self.fwd_proj.getSubGrid(i)) if self.apply_ramlak: for j in range(maxV_PX): ramK.applyToGrid( self.fwd_proj.getSubGrid(i).getSubGrid(j)) else: if self.apply_cosine: cosine_filter = CosineWeightingTool() cosine_filter.configure() self.fwd_proj = ImageUtil.applyFilterInParallel( self.fwd_proj, cosine_filter, True) if self.apply_ramlak: filter = SheppLoganRampFilter() filter.configure() filtertool = RampFilteringTool() filtertool.setRamp(filter) self.fwd_proj = ImageUtil.applyFilterInParallel( self.fwd_proj, filtertool, True) except JavaException as exception: if old_exception_type: self.error['message'] = exception.message() else: self.error['message'] = exception.message self.error['stacktrace'] = exception.stacktrace() detachThreadFromJVM() self.filter_finished.emit('finished')
def testAttach(self): # Make sure we are attached to start the test jpype.attachThreadToJVM() self.assertTrue(jpype.isThreadAttachedToJVM()) # Detach from the thread jpype.detachThreadFromJVM() self.assertFalse(jpype.isThreadAttachedToJVM()) # Reattach to the thread jpype.attachThreadToJVM() self.assertTrue(jpype.isThreadAttachedToJVM()) # Detach again jpype.detachThreadFromJVM() self.assertFalse(jpype.isThreadAttachedToJVM()) # Call a Java method which will cause it to attach automatically s = jpype.JString("foo") self.assertTrue(jpype.isThreadAttachedToJVM())
def run(self): self.error = {} attachThreadToJVM() try: if self.use_cl: if self.proj_idx is None: #self.back_proj = self.cone_beam_back_projector.backprojectPixelDrivenCL(self.fwd_proj) back_proj = OpenCLGrid3D( Grid3D(*pyconrad.config.get_reco_size())) self.cone_beam_back_projector.fastBackprojectPixelDrivenCL( OpenCLGrid3D(self.fwd_proj), back_proj) self.back_proj = Grid3D(back_proj) else: fwd_proj = OpenCLGrid2D( self.fwd_proj.getSubGrid(self.proj_idx)) back_proj = OpenCLGrid3D( Grid3D(*pyconrad.config.get_reco_size())) self.cone_beam_back_projector.fastBackprojectPixelDrivenCL( fwd_proj, back_proj, self.proj_idx) self.back_proj = Grid3D(back_proj) else: if self.proj_idx is None: self.back_proj = self.cone_beam_back_projector.backprojectPixelDriven( self.fwd_proj) else: fwd_proj = self.fwd_proj.getSubGrid(self.proj_idx) self.back_proj = self.cone_beam_back_projector.backprojectPixelDriven( fwd_proj, self.proj_idx) except JavaException as exception: if old_exception_type: self.error['message'] = exception.message() else: self.error['message'] = exception.message self.error['stacktrace'] = exception.stacktrace() detachThreadFromJVM() self.back_proj_finished.emit('finished')
def validate(request): """ View for validate tool returns validate.html template """ if request.user.is_authenticated() or settings.ANONYMOUS_LOGIN_ENABLED: context_dict={} if request.method == 'POST': if (jpype.isJVMStarted()==0): """ If JVM not already started, start it.""" classpath =abspath(".")+"/tool.jar" jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=%s"%classpath) """ Attach a Thread and start processing the request. """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") verifyclass = package.Verify ajaxdict=dict() try : if request.FILES["file"]: """ Saving file to the media directory """ myfile = request.FILES['file'] folder = str(request.user) + "/" + str(int(time())) fs = FileSystemStorage(location=settings.MEDIA_ROOT +"/"+ folder, base_url=urljoin(settings.MEDIA_URL, folder+'/') ) filename = fs.save(myfile.name, myfile) uploaded_file_url = fs.url(filename) """ Call the java function with parameters """ retval = verifyclass.verify(str(settings.APP_DIR+uploaded_file_url)) if (len(retval) > 0): """ If any warnings are returned """ if (request.is_ajax()): ajaxdict["type"] = "warning" ajaxdict["data"] = "The following warning(s) were raised: " + str(retval) response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=400) context_dict["error"] = retval jpype.detachThreadFromJVM() return render(request, 'app/validate.html',context_dict,status=400 ) if (request.is_ajax()): """ Valid SPDX Document """ ajaxdict["data"] = "This SPDX Document is valid." response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=200) jpype.detachThreadFromJVM() return HttpResponse("This SPDX Document is valid.",status=200) else : """ If no file uploaded.""" if (request.is_ajax()): ajaxdict=dict() ajaxdict["type"] = "error" ajaxdict["data"] = "No file uploaded" response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = "No file uploaded" jpype.detachThreadFromJVM() return render(request, 'app/validate.html',context_dict,status=404 ) except jpype.JavaException,ex : """ Error raised by verifyclass.verify without exiting the application""" if (request.is_ajax()): ajaxdict=dict() ajaxdict["type"] = "error" ajaxdict["data"] = jpype.JavaException.message(ex) response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=400) context_dict["error"] = jpype.JavaException.message(ex) jpype.detachThreadFromJVM() return render(request, 'app/validate.html',context_dict,status=400 ) except MultiValueDictKeyError: """ If no files selected""" if (request.is_ajax()): ajaxdict=dict() ajaxdict["type"] = "error" ajaxdict["data"] = "No files selected." response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = "No files selected." jpype.detachThreadFromJVM() return render(request, 'app/validate.html',context_dict,status=404 ) except :
def convert(request): """ View for convert tool returns convert.html template """ if request.user.is_authenticated() or settings.ANONYMOUS_LOGIN_ENABLED: context_dict={} if request.method == 'POST': if (jpype.isJVMStarted()==0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath =abspath(".")+"/tool.jar" jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=%s"%classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") ajaxdict=dict() try : if request.FILES["file"]: """ Saving file to media directory """ folder = str(request.user) + "/" + str(int(time())) myfile = request.FILES['file'] fs = FileSystemStorage(location=settings.MEDIA_ROOT +"/"+ folder,base_url=urljoin(settings.MEDIA_URL, folder+'/')) filename = fs.save(myfile.name, myfile) uploaded_file_url = fs.url(filename) option1 = request.POST["from_format"] option2 = request.POST["to_format"] functiontocall = option1 + "To" + option2 warningoccurred = False content_type ="" if "cfileformat" in request.POST : cfileformat = request.POST["cfileformat"] else : cfileformat = getFileFormat(option2) convertfile = request.POST["cfilename"] + cfileformat """ Call the java function with parameters as list """ if (option1=="Tag"): print ("Verifing for Tag/Value Document") if (option2=="RDF"): content_type = "application/rdf+xml" tagtordfclass = package.TagToRDF retval = tagtordfclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True elif (option2=="Spreadsheet"): content_type = "application/vnd.ms-excel" tagtosprdclass = package.TagToSpreadsheet retval = tagtosprdclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True else : jpype.detachThreadFromJVM() context_dict["error"] = "Select the available conversion types." return render(request, 'app/convert.html',context_dict,status=400 ) elif (option1=="RDF"): print ("Verifing for RDF Document") if (option2=="Tag"): content_type = "text/tag-value" rdftotagclass = package.RdfToTag retval = rdftotagclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True elif (option2=="Spreadsheet"): content_type = "application/vnd.ms-excel" rdftosprdclass = package.RdfToSpreadsheet retval = rdftosprdclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True elif (option2=="HTML"): content_type = "text/html" rdftohtmlclass = package.RdfToHtml retval = rdftohtmlclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True else : jpype.detachThreadFromJVM() context_dict["error"] = "Select the available conversion types." return render(request, 'app/convert.html',context_dict,status=400 ) elif (option1=="Spreadsheet"): print ("Verifing for Spreadsheet Document") if (option2=="Tag"): content_type = "text/tag-value" sprdtotagclass = package.SpreadsheetToTag retval = sprdtotagclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True elif (option2=="RDF"): content_type = "application/rdf+xml" sprdtordfclass = package.SpreadsheetToRDF retval = sprdtordfclass.onlineFunction([settings.APP_DIR+uploaded_file_url,settings.MEDIA_ROOT+"/"+folder+"/"+"/"+convertfile]) if (len(retval) > 0): warningoccurred = True else : jpype.detachThreadFromJVM() context_dict["error"] = "Select the available conversion types." return render(request, 'app/convert.html',context_dict,status=400 ) if (warningoccurred==False) : """ If no warnings raised """ if (request.is_ajax()): ajaxdict["medialink"] = settings.MEDIA_URL + folder + "/"+ convertfile response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response) context_dict['Content-Disposition'] = 'attachment; filename="{}"'.format(convertfile) context_dict["medialink"] = settings.MEDIA_URL + folder + "/"+ convertfile context_dict["Content-Type"] = content_type jpype.detachThreadFromJVM() return render(request, 'app/convert.html',context_dict,status=200 ) #return HttpResponseRedirect(settings.MEDIA_URL + folder + "/" + convertfile) else : if (request.is_ajax()): ajaxdict["type"] = "warning" ajaxdict["data"] = "The following warning(s) were raised by "+ myfile.name + ": " + str(retval) ajaxdict["medialink"] = settings.MEDIA_URL + folder + "/"+ convertfile response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=406) context_dict["error"] = str(retval) context_dict["type"] = "warning" context_dict['Content-Disposition'] = 'attachment; filename="{}"'.format(convertfile) context_dict["Content-Type"] = content_type context_dict["medialink"] = settings.MEDIA_URL + folder + "/"+ convertfile jpype.detachThreadFromJVM() return render(request, 'app/convert.html',context_dict,status=406 ) else : context_dict["error"] = "No file uploaded" context_dict["type"] = "error" jpype.detachThreadFromJVM() return render(request, 'app/convert.html',context_dict,status=404 ) except jpype.JavaException,ex : """ Java exception raised without exiting the application""" if (request.is_ajax()): ajaxdict["type"] = "error" ajaxdict["data"] = jpype.JavaException.message(ex) response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=400) context_dict["type"] = "error" context_dict["error"] = jpype.JavaException.message(ex) jpype.detachThreadFromJVM() return render(request, 'app/convert.html',context_dict,status=400 ) except MultiValueDictKeyError: """ If no files uploaded""" if (request.is_ajax()): ajaxdict["type"] = "error" ajaxdict["data"] = "No files selected." response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["type"] = "error" context_dict["error"] = "No files selected." jpype.detachThreadFromJVM() return render(request, 'app/convert.html',context_dict,status=404 ) except :
def compare(request): """ View for compare tool returns compare.html template """ if request.user.is_authenticated() or settings.ANONYMOUS_LOGIN_ENABLED: context_dict={} if request.method == 'POST': if (jpype.isJVMStarted()==0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath =abspath(".")+"/tool.jar" jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=%s"%classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") verifyclass = package.Verify compareclass = package.CompareMultpleSpdxDocs ajaxdict = dict() filelist = list() errorlist = list() if 'compare' in request.POST: """ If files submitted one by one """ try: if request.FILES["file1"]: nofile = int(request.POST["nofile"]) rfilename = request.POST["rfilename"]+".xlsx" folder = str(request.user)+"/"+ str(int(time())) callfunc = [settings.MEDIA_ROOT+"/"+folder + "/" +rfilename] erroroccurred = False warningoccurred = False fs = FileSystemStorage(location=settings.MEDIA_ROOT +"/"+ folder, base_url=urljoin(settings.MEDIA_URL, folder+'/') ) for i in range(1,nofile+1): """ Check if file selected or not""" try: a = 'file'+str(i) myfile = request.FILES['file'+str(i)] except MultiValueDictKeyError: """ If no files selected""" if (request.is_ajax()): filelist.append("File " + str(i) + " not selected.") errorlist.append("Please select a file.") ajaxdict["type"] = "error" ajaxdict["files"] = filelist ajaxdict["errors"] = errorlist response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = "No files selected." context_dict["type"] = "error" jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=404 ) """ If file exist and uploaded, save it""" filename = fs.save(myfile.name, myfile) uploaded_file_url = fs.url(filename) callfunc.append(settings.APP_DIR+uploaded_file_url) try : """Call the java function to verify for valid RDF Files.""" retval = verifyclass.verifyRDFFile(settings.APP_DIR+uploaded_file_url) if (len(retval) > 0): """ If warnings raised""" warningoccurred = True filelist.append(myfile.name) errorlist.append("The following warning(s) were raised: " +str(retval)) else : filelist.append(myfile.name) errorlist.append("No errors found") except jpype.JavaException,ex : """ Error raised by verifyclass.verifyRDFFile without exiting the application""" erroroccurred = True filelist.append(myfile.name) errorlist.append(jpype.JavaException.message(ex)) except : """ Other Exceptions""" erroroccurred = True filelist.append(myfile.name) errorlist.append(format_exc()) if (erroroccurred==False): """If no errors in any of the file, call the java function with parameters as list""" try : compareclass.onlineFunction(callfunc) except : """Error raised by onlineFunction""" if (request.is_ajax()): ajaxdict["type"] = "warning2" ajaxdict["files"] = filelist ajaxdict["errors"] = errorlist ajaxdict["toolerror"] = format_exc() response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=400) context_dict["type"] = "warning2" context_dict["error"]= errorlist jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=400 ) if (warningoccurred==False): """If no warnings raised """ if (request.is_ajax()): newajaxdict=dict() newajaxdict["medialink"] = settings.MEDIA_URL + folder + "/" + rfilename response = dumps(newajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response) context_dict['Content-Disposition'] = 'attachment; filename="{}"'.format(rfilename) context_dict["Content-Type"] = "application/vnd.ms-excel" context_dict["medialink"] = settings.MEDIA_URL + folder + "/" + rfilename jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=200 ) #return HttpResponseRedirect(settings.MEDIA_URL+ folder + "/" +rfilename) else : if (request.is_ajax()): ajaxdict["type"] = "warning" ajaxdict["files"] = filelist ajaxdict["errors"] = errorlist ajaxdict["medialink"] = settings.MEDIA_URL + folder + "/" + rfilename response = dumps(newajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=406) context_dict['Content-Disposition'] = 'attachment; filename="{}"'.format(rfilename) context_dict["Content-Type"] = "application/vnd.ms-excel" context_dict["type"] = "warning" context_dict["medialink"] = settings.MEDIA_URL + folder + "/" + rfilename jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=406 ) else : if (request.is_ajax()): ajaxdict["type"] = "error" ajaxdict["files"] = filelist ajaxdict["errors"] = errorlist response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=400) context_dict["error"]= errorlist context_dict["type"] = "error" jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=400 ) else : context_dict["error"]= "File Not Uploaded" context_dict["type"] = "error" jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=404 ) except MultiValueDictKeyError: """ If no files uploaded""" if (request.is_ajax()): filelist.append("File-1 not selected.") errorlist.append("Please select a file.") ajaxdict["type"] = "error" ajaxdict["files"] = filelist ajaxdict["errors"] = errorlist response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = "No files selected." context_dict["type"] = "error" jpype.detachThreadFromJVM() return render(request, 'app/compare.html',context_dict,status=404 )
response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = "No files selected." jpype.detachThreadFromJVM() return render(request, 'app/validate.html',context_dict,status=404 ) except : """ Other error raised """ if (request.is_ajax()): ajaxdict=dict() ajaxdict["type"] = "error" ajaxdict["data"] = format_exc() response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=400) context_dict["error"] = format_exc() jpype.detachThreadFromJVM() return render(request, 'app/validate.html',context_dict,status=400 ) else : """ GET,HEAD """ return render(request, 'app/validate.html',context_dict ) else : return HttpResponseRedirect(settings.LOGIN_URL) def compare(request):
def detach(): if jp.isThreadAttachedToJVM(): jp.detachThreadFromJVM()
def check_license(request): """ Handle Check License api request """ if request.method == 'GET': """ Return all check license api request """ query = CheckLicenseFileUpload.objects.all() serializer = CheckLicenseSerializer(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return check license tool result on the post file""" serializer = CheckLicenseSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted() == 0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath = settings.JAR_ABSOLUTE_PATH jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.compare") compareclass = package.LicenseCompareHelper query = CheckLicenseFileUpload.objects.create( owner=request.user, file=request.data.get('file')) uploaded_file = str(query.file) uploaded_file_path = str(query.file.path) """ Reading the license text file into a string variable """ licensetext = query.file.read() try: if request.FILES["file"]: """Call the java function with parameter""" matching_licenses = compareclass.matchingStandardLicenseIds( licensetext) if (matching_licenses and len(matching_licenses) > 0): matching_str = "The following license ID(s) match: " matching_str += matching_licenses[0] for i in range(1, len(matching_licenses)): matching_str += ", " matching_str += matching_licenses[i] result = matching_str returnstatus = status.HTTP_201_CREATED httpstatus = 201 jpype.detachThreadFromJVM() else: result = "There are no matching SPDX listed licenses" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() else: result = "File Not Uploaded" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except jpype.JavaException as ex: """ Java exception raised without exiting the application """ result = jpype.JavaException.message(ex) returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except: """ Other errors raised""" result = format_exc() returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() query.result = result query.status = httpstatus CheckLicenseFileUpload.objects.filter(file=uploaded_file).update( result=result, status=httpstatus) serial = CheckLicenseSerializerReturn(instance=query) return Response(serial.data, status=returnstatus) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def detach_jvm(): if jpype.isThreadAttachedToJVM(): jpype.detachThreadFromJVM()
def convert(request): """ Handle Convert api request """ if request.method == 'GET': """ Return all convert api request """ query = ConvertFileUpload.objects.all() serializer = ConvertSerializer(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return convert tool result on the post file""" serializer = ConvertSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted()==0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath =settings.JAR_ABSOLUTE_PATH jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=%s"%classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") result = "" message = "" try : if request.FILES["file"]: """ Saving file to the media directory """ myfile = request.FILES['file'] folder = "api/"+str(request.user) +"/"+ str(int(time())) fs = FileSystemStorage(location=settings.MEDIA_ROOT +"/"+ folder, base_url=urljoin(settings.MEDIA_URL, folder+'/') ) filename = fs.save(myfile.name, myfile) uploaded_file_url = fs.url(filename) option1 = request.POST["from_format"] option2 = request.POST["to_format"] convertfile = request.POST["cfilename"] warningoccurred = False if (extensionGiven(convertfile)==False): extension = getFileFormat(option2) convertfile = convertfile + extension """ Call the java function with parameters as list""" if (option1=="Tag"): print ("Verifing for Tag/Value Document") if (option2=="RDF"): tagtordfclass = package.TagToRDF retval = tagtordfclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2=="Spreadsheet"): tagtosprdclass = package.TagToSpreadsheet retval = tagtosprdclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True else : message = "Select valid conversion types." returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() elif (option1=="RDF"): print ("Verifing for RDF Document") if (option2=="Tag"): rdftotagclass = package.RdfToTag retval = rdftotagclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2=="Spreadsheet"): rdftosprdclass = package.RdfToSpreadsheet retval = rdftosprdclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2=="HTML"): rdftohtmlclass = package.RdfToHtml retval = rdftohtmlclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True else : message = "Select valid conversion types." returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() elif (option1=="Spreadsheet"): print ("Verifing for Spreadsheet Document") if (option2=="Tag"): sprdtotagclass = package.SpreadsheetToTag retval = sprdtotagclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2=="RDF"): sprdtordfclass = package.SpreadsheetToRDF retval = sprdtordfclass.onlineFunction([ settings.APP_DIR+uploaded_file_url, settings.MEDIA_ROOT+"/"+ folder+"/"+convertfile ]) if (len(retval) > 0): warningoccurred = True else : message = "Select valid conversion types." returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() if (warningoccurred == True ): message = "The following error(s)/warning(s) were raised: " + str(retval) result = "/media/" + folder+"/"+ convertfile returnstatus = status.HTTP_406_NOT_ACCEPTABLE httpstatus = 406 jpype.detachThreadFromJVM() else : result = "/media/" + folder+"/"+ convertfile returnstatus = status.HTTP_201_CREATED httpstatus = 201 jpype.detachThreadFromJVM() else : message = "File Not Found" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except jpype.JavaException,ex : message = jpype.JavaException.message(ex) returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except :
def run(self): global mbeanHelper, mbeans jpype.attachThreadToJVM() while config.estado in config.estados[0]: time.sleep(1) os.chdir(ruta_tablas) eventoActual = 1 numEventos = self.cursor.rowcount eventos = [w for w in self.resultado] dnsSg = 05 dnsMs = 12 rutaNoSenal = '11_1322587936515' pesnum = 1 iniPes = False pespres = [0, 0, 0] pestimes = [0, 0, 0] args = shlex.split( 'rm -f fifo_out.ts fifo_tdt.ts fifo_audio.ts fifo_video.ts 1.video.pes 2.video.pes 1.audio.pes 2.audio.pes 1.audio.pes.length 2.audio.pes.length' ) try: call(args, shell=False) except: pass if os.path.exists(ruta_iptv + rutaNoSenal + '.mp4') is True: tablas() if modo_transmision is 1: tsout_bitrate = tsout_bitrate_t else: tsout_bitrate = tsout_bitrate_c if iptv: instance.vlm_add_broadcast( 'iptv', ruta_iptv + rutaNoSenal + '.mp4', '#gather:udp{mux=ts,dst=' + dir_ip_destino + ':' + puerto_destino + '}', 1, ("sout-keep", 1), True, True) args = shlex.split( 'mkfifo fifo_out.ts fifo_tdt.ts fifo_audio.ts fifo_video.ts') self.p1 = Popen(args, shell=False) if modo_transmision is 1: args = shlex.split( 'DtPlay fifo_tdt.ts -n ' + str(numTarjeta) + ' -t ' + str(modulador) + ' -mt DVBT -mC QAM16 -mG 1/4 -mc 2/3 -mf 578 -mS ON') else: args = shlex.split('DtPlay fifo_tdt.ts -n ' + str(numTarjeta) + ' -t ' + str(modulador) + ' -r ' + tsout_bitrate_c + ' -mt QAM64 -mf 578 -ma A -mS ON') self.p2 = Popen(args, shell=False) args = shlex.split('tstdt fifo_out.ts') fifo1 = open('fifo_tdt.ts', 'w') self.p3 = Popen(args, shell=False, stdout=fifo1) args = shlex.split( 'tscbrmuxer b:' + ts_video_bitrate + ' fifo_video.ts b:' + ts_audio_bitrate + ' fifo_audio.ts b:4000000 ocdir1.ts b:3008 pat.ts b:3008 pmt.ts b:2000 tdt.ts b:2000 ste.ts b:2000 ait.ts b:1500 sdt.ts b:1400 nit.ts o:' + tsout_bitrate + ' null.ts') fifo2 = open('fifo_out.ts', 'w') self.p4 = Popen(args, shell=False, stdout=fifo2) print 'Lista de Eventos' for i in eventos: print 'Hora: ' + str(i[1]) + ' Duracion: ' + str( i[2]) + ' Ruta: ' + str(i[3]) for ie in self.resultado: if datetime.today().strftime("%H:%M:%S.%f") < str(ie[1]): break else: del eventos[0] numEventos -= 1 print "Numero de Eventos Siguientes=" + str(numEventos) eventCount = 1 #delta=0 numeventopres = 0 while config.estado in config.estados[1]: if eventCount % 2 == 1: pesnum = 1 else: pesnum = 2 #Configurando evento inicial y siguiente if not iniPes: print '************************Configurando evento inicial y siguiente***********************************************************************' horaact = datetime.today() horaactst = horaact.strftime("%H:%M:%S.%f") print 'horaActual=' + horaactst #Evento inicial if numEventos > 0: evento = eventos[eventoActual - 1] if horaactst < str(evento[1]): print 'Set noSenal 1' pespres[1] = 0 self.setContent(rutaNoSenal, 1) if iptv: instance.vlm_set_input( 'iptv', ruta_iptv + rutaNoSenal + '.mp4') horaact1 = horaact + timedelta(seconds=dnsSg, milliseconds=dnsMs) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[1] = horaact1 print 'horasumada=' + horaactst1 #Evento Siguiente if horaactst1 < str(evento[1]): print 'Set noSenal 2' pespres[2] = 0 self.setContent(rutaNoSenal, 2) horaact2 = horaact1 + timedelta( seconds=dnsSg, milliseconds=dnsMs) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2] = horaact2 print 'horasumada=' + horaactst2 else: print 'Set evento 2' pespres[2] = 1 self.setContent(evento[3], 2) horaevt = datetime.strptime( str(evento[2]), "%H:%M:%S.%f") print horaactst1 print str(horaevt.minute) print str(horaevt.second) print str(horaevt.microsecond) horaact2 = horaact1 + timedelta( minutes=horaevt.minute, seconds=horaevt.second, milliseconds=(horaevt.microsecond / 1000)) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2] = horaact2 print 'horasumada=' + horaactst2 if numEventos + 1 > eventoActual: eventoActual += 1 else: print 'Set evento 1' pespres[1] = 1 self.setContent(evento[3], 1) if iptv: instance.vlm_set_input( 'iptv', ruta_iptv + evento[3] + '.mp4') horaevt = datetime.strptime( str(evento[2]), "%H:%M:%S.%f") horaact1 = horaact + timedelta( minutes=horaevt.minute, seconds=horaevt.second, milliseconds=(horaevt.microsecond / 1000)) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[1] = horaact1 print 'horasumada=' + horaactst1 if numEventos + 1 > eventoActual: eventoActual += 1 #Evento Siguiente if horaactst1 < str( eventos[eventoActual - 1][1]): print 'Set noSenal 2' pespres[2] = 0 self.setContent(rutaNoSenal, 2) horaact2 = horaact1 + timedelta( seconds=dnsSg, milliseconds=dnsMs) horaactst2 = horaact2.strftime( "%H:%M:%S.%f") pestimes[2] = horaact2 print 'horasumada=' + horaactst2 else: print 'Set evento 2' pespres[2] = 1 evento = eventos[eventoActual - 1] self.setContent(evento[3], 2) horaevt = datetime.strptime( str(evento[2]), "%H:%M:%S.%f") horaact2 = horaact1 + timedelta( minutes=horaevt.minute, seconds=horaevt.second, milliseconds=(horaevt.microsecond / 1000)) horaactst2 = horaact2.strftime( "%H:%M:%S.%f") pestimes[2] = horaact2 print 'horasumada=' + horaactst2 if numEventos + 1 > eventoActual: eventoActual += 1 else: print 'Set noSenal 2' pespres[2] = 0 self.setContent(rutaNoSenal, 2) horaact2 = horaact1 + timedelta( seconds=dnsSg, milliseconds=dnsMs) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2] = horaact2 print 'horasumada=' + horaactst2 else: self.setContent(rutaNoSenal, 1) if iptv: instance.vlm_set_input( 'iptv', ruta_iptv + rutaNoSenal + '.mp4') self.setContent(rutaNoSenal, 2) if iptv: instance.vlm_play_media('iptv') args = shlex.split('pesvideo2ts ' + pid_video + ' 25 112 ' + ts_video_bitrate + ' 1 1.video.pes 2.video.pes') fifo3 = open('fifo_video.ts', 'w') self.p5 = Popen(args, shell=False, stdout=fifo3, stderr=PIPE) args = shlex.split( 'pesaudio2ts ' + pid_audio + ' 1152 48000 384 1 1.audio.pes 2.audio.pes') fifo4 = open('fifo_audio.ts', 'w') self.p6 = Popen(args, shell=False, stdout=fifo4, stderr=PIPE) print '-----' + self.p5.stderr.readline() print '-----' + self.p5.stderr.readline() if numEventos > 0: t0 = TimerInfo( 1, '{\"id\" : \"1\" , \"tipo\" : \"1\", \"texto\" : \"kalash, kalash\" , \"duracion\" : \"1\"}\n' ) t0.start() iniPes = True else: break print '*************************Presentando evento**********************************************************************' if pespres[pesnum] is 1: eventopres = eventos[numeventopres] duraevt = datetime.strptime(eventopres[2], "%H:%M:%S.%f") tiempo = float( float((duraevt.minute * 60 * 1000000) + (duraevt.second * 1000000) + duraevt.microsecond) / float(1000000)) self.iniInfoAsociada(eventopres[0]) self.iniVotacion(eventopres[0], tiempo) numeventopres += 1 while True: line = self.p6.stderr.readline() parts1 = line.split(",") parts2 = parts1[0].split(" ") if len(parts2) > 1: sync1 = parts2[10] else: sync1 = None line = self.p5.stderr.readline() parts1 = line.split(",") parts2 = parts1[0].split(" ") if len(parts2) > 1: sync2 = parts2[9] else: sync2 = None if sync1 is not None and sync2 is not None: if sync1 != sync2: print '--- Out of Synchronization --- ' + sync1 + ' different of ' + sync2 mbeanHelper.sendNotification( mbeans[0], 'gestv.error.audioVideoOutOfSynchronization', 'empty') break horaact = datetime.today() horaactst = horaact.strftime("%H:%M:%S.%f") print 'horafintimer=' + horaactst #Configurando evento posterior print '************************Configurando evento posterior***********************************************************************' if pesnum is 1: pesevt = 2 else: pesevt = 1 horaactst1 = pestimes[pesevt].strftime("%H:%M:%S.%f") print 'hora siguiente=' + horaactst1 if numEventos + 1 > eventoActual: evento = eventos[eventoActual - 1] if horaactst1 < str(evento[1]): print 'Set noSenal ' + str(pesnum) pespres[pesnum] = 0 self.setContent(rutaNoSenal, pesnum) horaact1 = pestimes[pesevt] + timedelta( seconds=dnsSg, milliseconds=dnsMs) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[pesnum] = horaact1 print 'horasumada=' + horaactst1 else: print 'Set evento id=' + str( evento[0]) + ' ' + str(pesnum) pespres[pesnum] = 1 self.setContent(evento[3], pesnum) horaevt = datetime.strptime(str(evento[2]), "%H:%M:%S.%f") horaact1 = pestimes[pesevt] + timedelta( minutes=horaevt.minute, seconds=horaevt.second, milliseconds=(horaevt.microsecond / 1000)) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[pesnum] = horaact1 print 'horasumada=' + horaactst1 if numEventos + 1 > eventoActual: eventoActual += 1 else: if pespres[1] is 0 and pespres[2] is 0: break else: print 'Set noSenal ' + str(pesnum) pespres[pesnum] = 0 self.setContent(rutaNoSenal, pesnum) horaact1 = pestimes[pesevt] + timedelta( seconds=dnsSg, milliseconds=dnsMs) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[pesnum] = horaact1 print 'horasumada=' + horaactst1 eventCount += 1 if iptv: instance.vlm_set_input('iptv', ruta_iptv + rutaNoSenal + '.mp4') while config.estado in config.estados[1]: print 'colocando ciclo no senal' #tiempo=float(float((duraNoSenal.minute*60*1000000)+(duraNoSenal.second*1000000)+duraNoSenal.microsecond)/float(1000000)) #time.sleep(tiempo-1) #while True: line = self.p6.stderr.readline() print '-- ' + line + ' --' line = self.p5.stderr.readline() print '-- ' + line + ' --' else: mbeanHelper.sendNotification( mbeans[0], 'gestv.error.contentRepositoryNotFound', 'empty') print "Error: No pudo conectarse al repositorio de contenidos." jpype.detachThreadFromJVM() self.parar() jpype.detachThreadFromJVM()
def disconnect(self): self.device.disconnect() jpype.detachThreadFromJVM()
def check_license(request): """ View for check license tool returns check_license.html template """ if request.user.is_authenticated() or settings.ANONYMOUS_LOGIN_ENABLED: context_dict={} if request.method == 'POST': licensetext = request.POST.get('licensetext') if (jpype.isJVMStarted()==0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath =abspath(".")+"/tool.jar" jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=%s"%classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.compare") compareclass = package.LicenseCompareHelper try: """Call the java function with parameter""" matching_licenses = compareclass.matchingStandardLicenseIds(licensetext) if (matching_licenses and len(matching_licenses) > 0): matching_str = "The following license ID(s) match: " matching_str+= matching_licenses[0] for i in range(1,len(matching_licenses)): matching_str += ", " matching_str += matching_licenses[i] if (request.is_ajax()): ajaxdict=dict() ajaxdict["data"] = matching_str response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response) context_dict["success"] = str(matching_str) jpype.detachThreadFromJVM() return render(request, 'app/check_license.html',context_dict,status=200 ) else: if (request.is_ajax()): ajaxdict=dict() ajaxdict["data"] = "There are no matching SPDX listed licenses" response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = "There are no matching SPDX listed licenses" jpype.detachThreadFromJVM() return render(request, 'app/check_license.html',context_dict,status=404 ) except jpype.JavaException,ex : """ Java exception raised without exiting the application """ if (request.is_ajax()): ajaxdict=dict() ajaxdict["data"] = jpype.JavaException.message(ex) response = dumps(ajaxdict) jpype.detachThreadFromJVM() return HttpResponse(response,status=404) context_dict["error"] = jpype.JavaException.message(ex) jpype.detachThreadFromJVM() return render(request, 'app/check_license.html',context_dict,status=404 ) except :
def convert(request): """ Handle Convert api request """ if request.method == 'GET': """ Return all convert api request """ query = ConvertFileUpload.objects.all() serializer = ConvertSerializer(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return convert tool result on the post file""" serializer = ConvertSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted() == 0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath = settings.JAR_ABSOLUTE_PATH jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") result = "" tagToRdfFormat = None message = "Success" query = ConvertFileUpload.objects.create( owner=request.user, file=request.data.get('file'), from_format=request.POST["from_format"], to_format=request.POST["to_format"], cfilename=request.POST["cfilename"], ) uploaded_file = str(query.file) uploaded_file_path = str(query.file.path) try: if request.FILES["file"]: folder = "/".join(uploaded_file_path.split('/')[:-1]) option1 = request.POST["from_format"] option2 = request.POST["to_format"] convertfile = request.POST["cfilename"] warningoccurred = False if (extensionGiven(convertfile) == False): extension = getFileFormat(option2) convertfile = convertfile + extension """ Call the java function with parameters as list""" if (option1 == "Tag"): print("Verifing for Tag/Value Document") if (option2 == "RDF"): try: tagToRdfFormat = request.POST["tagToRdfFormat"] except: tagToRdfFormat = 'RDF/XML-ABBREV' option3 = tagToRdfFormat if option3 not in [ 'RDF/XML-ABBREV', 'RDF/XML', 'N-TRIPLET', 'TURTLE' ]: message, returnstatus, httpstatus = convertError( '400') tagtordfclass = package.TagToRDF retval = tagtordfclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile, option3 ]) if (len(retval) > 0): warningoccurred = True elif (option2 == "Spreadsheet"): tagtosprdclass = package.TagToSpreadsheet retval = tagtosprdclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile ]) if (len(retval) > 0): warningoccurred = True else: message, returnstatus, httpstatus = convertError( '400') elif (option1 == "RDF"): print("Verifing for RDF Document") if (option2 == "Tag"): rdftotagclass = package.RdfToTag retval = rdftotagclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2 == "Spreadsheet"): rdftosprdclass = package.RdfToSpreadsheet retval = rdftosprdclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2 == "HTML"): rdftohtmlclass = package.RdfToHtml retval = rdftohtmlclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile ]) if (len(retval) > 0): warningoccurred = True else: message, returnstatus, httpstatus = convertError( '400') elif (option1 == "Spreadsheet"): print("Verifing for Spreadsheet Document") if (option2 == "Tag"): sprdtotagclass = package.SpreadsheetToTag retval = sprdtotagclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile ]) if (len(retval) > 0): warningoccurred = True elif (option2 == "RDF"): sprdtordfclass = package.SpreadsheetToRDF retval = sprdtordfclass.onlineFunction([ uploaded_file_path, folder + "/" + convertfile ]) if (len(retval) > 0): warningoccurred = True else: message, returnstatus, httpstatus = convertError( '400') if (warningoccurred == True): message = "The following error(s)/warning(s) were raised: " + str( retval) index = folder.split("/").index('media') result = "/" + "/".join( folder.split("/")[index:]) + '/' + convertfile returnstatus = status.HTTP_406_NOT_ACCEPTABLE httpstatus = 406 jpype.detachThreadFromJVM() else: """return only the path starting with MEDIA_URL""" index = folder.split("/").index('media') result = "/" + ("/".join( folder.split("/")[index:])) + '/' + convertfile returnstatus = status.HTTP_201_CREATED httpstatus = 201 jpype.detachThreadFromJVM() else: message, returnstatus, httpstatus = convertError('404') except jpype.JavaException as ex: message = jpype.JavaException.message(ex) returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except: message = format_exc() returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() query.tagToRdfFormat = tagToRdfFormat query.message = message query.status = httpstatus query.result = result ConvertFileUpload.objects.filter(file=uploaded_file).update( tagToRdfFormat=tagToRdfFormat, message=message, status=httpstatus, result=result) serial = ConvertSerializerReturn(instance=query) return Response(serial.data, status=returnstatus) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def compare(request): """ Handle Compare api request """ if request.method == 'GET': """ Return all compare api request """ query = CompareFileUpload.objects.all() serializer = CompareSerializerReturn(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return compare tool result on the post file""" serializer = CompareSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted()==0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath =settings.JAR_ABSOLUTE_PATH jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=%s"%classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") verifyclass = package.Verify compareclass = package.CompareMultpleSpdxDocs result="" message="" erroroccurred = False try : if (request.FILES["file1"] and request.FILES["file2"]): """ Saving file to the media directory """ rfilename = request.POST["rfilename"] if (extensionGiven(rfilename)==False): rfilename = rfilename+".xlsx" folder = "api/"+str(request.user) +"/"+ str(int(time())) fs = FileSystemStorage(location=settings.MEDIA_ROOT +"/"+ folder, base_url=urljoin(settings.MEDIA_URL, folder+'/') ) callfunc = [settings.MEDIA_ROOT+"/"+ folder+"/"+rfilename] file1 = request.FILES["file1"] file2 = request.FILES["file2"] filename1 = fs.save(file1.name, file1) uploaded_file_url1 = fs.url(filename1) filename2 = fs.save(file2.name, file2) uploaded_file_url2 = fs.url(filename2) callfunc.append(settings.APP_DIR+uploaded_file_url1) callfunc.append(settings.APP_DIR+uploaded_file_url2) """ Call the java function with parameters as list""" retval1 = verifyclass.verifyRDFFile(settings.APP_DIR+uploaded_file_url1) if (len(retval1) > 0): erroroccurred = True message = "The following error(s)/warning(s) were raised by " + str(file1.name) + ": " +str(retval1) retval2 = verifyclass.verifyRDFFile(settings.APP_DIR+uploaded_file_url2) if (len(retval2) > 0): erroroccurred = True message += "The following error(s)/warning(s) were raised by " + str(file1.name) + ": " +str(retval2) try : compareclass.onlineFunction(callfunc) result = "/media/" + folder+"/"+ rfilename returnstatus = status.HTTP_201_CREATED httpstatus = 201 except : message += "While running compare tool " + format_exc() returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 if (erroroccurred == False): returnstatus = status.HTTP_201_CREATED httpstatus = 201 else : returnstatus = status.HTTP_406_BAD_REQUEST httpstatus = 406 jpype.detachThreadFromJVM() else : message = "File Not Uploaded" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except jpype.JavaException,ex : """ Error raised by verifyclass.verify without exiting the application""" message = jpype.JavaException.message(ex) #+ "This SPDX Document is not a valid RDF/XML or tag/value format" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except :
def compare(request): """ Handle Compare api request """ if request.method == 'GET': """ Return all compare api request """ query = CompareFileUpload.objects.all() serializer = CompareSerializerReturn(query, many=True) return Response(serializer.data) elif request.method == 'POST': """ Return compare tool result on the post file""" serializer = CompareSerializer(data=request.data) if serializer.is_valid(): if (jpype.isJVMStarted() == 0): """ If JVM not already started, start it, attach a Thread and start processing the request """ classpath = settings.JAR_ABSOLUTE_PATH jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath) """ Attach a Thread and start processing the request """ jpype.attachThreadToJVM() package = jpype.JPackage("org.spdx.tools") verifyclass = package.Verify compareclass = package.CompareMultpleSpdxDocs result = "" message = "Success" erroroccurred = False rfilename = request.POST["rfilename"] query = CompareFileUpload.objects.create( owner=request.user, file1=request.data.get('file1'), file2=request.data.get('file2'), rfilename=rfilename, ) uploaded_file1 = str(query.file1) uploaded_file2 = str(query.file2) uploaded_file1_path = str(query.file1.path) uploaded_file2_path = str(query.file2.path) try: if (request.FILES["file1"] and request.FILES["file2"]): """ Saving file to the media directory """ if (extensionGiven(rfilename) == False): rfilename = rfilename + ".xlsx" file1 = request.FILES["file1"] file2 = request.FILES["file2"] folder = "/".join(uploaded_file1_path.split('/')[:-1]) callfunc = [folder + "/" + rfilename] callfunc.append(uploaded_file1_path) callfunc.append(uploaded_file2_path) """ Call the java function with parameters as list""" retval1 = verifyclass.verifyRDFFile(uploaded_file1_path) if (len(retval1) > 0): erroroccurred = True message = "The following error(s)/warning(s) were raised by " + str( uploaded_file1) + ": " + str(retval1) retval2 = verifyclass.verifyRDFFile(uploaded_file2_path) if (len(retval2) > 0): erroroccurred = True message += "The following error(s)/warning(s) were raised by " + str( uploaded_file2) + ": " + str(retval2) try: compareclass.onlineFunction(callfunc) """Return only the path starting with MEDIA_URL""" index = folder.split("/").index('media') result = "/" + ("/".join( folder.split("/")[index:])) + '/' + rfilename returnstatus = status.HTTP_201_CREATED httpstatus = 201 except: message += "While running compare tool " + format_exc() returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 if (erroroccurred == False): returnstatus = status.HTTP_201_CREATED httpstatus = 201 else: returnstatus = status.HTTP_406_BAD_REQUEST httpstatus = 406 jpype.detachThreadFromJVM() else: message = "File Not Uploaded" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except jpype.JavaException as ex: """ Error raised by verifyclass.verify without exiting the application""" message = jpype.JavaException.message( ex ) #+ "This SPDX Document is not a valid RDF/XML or tag/value format" returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() except: message = format_exc() returnstatus = status.HTTP_400_BAD_REQUEST httpstatus = 400 jpype.detachThreadFromJVM() query.message = message query.result = result query.status = httpstatus CompareFileUpload.objects.filter(file1=uploaded_file1).filter( file2=uploaded_file2).update(message=message, result=result, status=httpstatus) serial = CompareSerializerReturn(instance=query) return Response(serial.data, status=returnstatus) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def run(self): global mbeanHelper,mbeans jpype.attachThreadToJVM() while config.estado in config.estados[0] : time.sleep(1) os.chdir(ruta_tablas) eventoActual=1 numEventos=self.cursor.rowcount eventos = [w for w in self.resultado] dnsSg=05 dnsMs=12 rutaNoSenal='11_1322587936515' pesnum=1 iniPes=False pespres = [0,0,0] pestimes = [0,0,0] args = shlex.split('rm -f fifo_out.ts fifo_tdt.ts fifo_audio.ts fifo_video.ts 1.video.pes 2.video.pes 1.audio.pes 2.audio.pes 1.audio.pes.length 2.audio.pes.length') try: call(args,shell=False) except: pass if os.path.exists(ruta_iptv+rutaNoSenal+'.mp4') is True : tablas() if modo_transmision is 1 : tsout_bitrate=tsout_bitrate_t else: tsout_bitrate=tsout_bitrate_c if iptv : instance.vlm_add_broadcast('iptv', ruta_iptv+rutaNoSenal+'.mp4', '#gather:udp{mux=ts,dst='+dir_ip_destino+':'+puerto_destino+'}', 1, ("sout-keep",1), True, True) args = shlex.split('mkfifo fifo_out.ts fifo_tdt.ts fifo_audio.ts fifo_video.ts') self.p1 = Popen(args,shell=False) if modo_transmision is 1 : args = shlex.split('DtPlay fifo_tdt.ts -n '+str(numTarjeta)+' -t '+str(modulador)+' -mt DVBT -mC QAM16 -mG 1/4 -mc 2/3 -mf 578 -mS ON') else: args = shlex.split('DtPlay fifo_tdt.ts -n '+str(numTarjeta)+' -t '+str(modulador)+' -r '+tsout_bitrate_c+' -mt QAM64 -mf 578 -ma A -mS ON') self.p2 = Popen(args,shell=False) args = shlex.split('tstdt fifo_out.ts') fifo1 = open('fifo_tdt.ts', 'w') self.p3 = Popen(args,shell=False,stdout=fifo1) args = shlex.split('tscbrmuxer b:'+ts_video_bitrate+' fifo_video.ts b:'+ts_audio_bitrate+' fifo_audio.ts b:4000000 ocdir1.ts b:3008 pat.ts b:3008 pmt.ts b:2000 tdt.ts b:2000 ste.ts b:2000 ait.ts b:1500 sdt.ts b:1400 nit.ts o:'+tsout_bitrate+' null.ts') fifo2 = open('fifo_out.ts', 'w') self.p4 = Popen(args,shell=False,stdout=fifo2) print 'Lista de Eventos' for i in eventos: print 'Hora: '+str(i[1])+' Duracion: '+str(i[2])+' Ruta: '+str(i[3]) for ie in self.resultado: if datetime.today().strftime("%H:%M:%S.%f") < str(ie[1]): break; else: del eventos[0] numEventos-=1 print "Numero de Eventos Siguientes="+str(numEventos) eventCount=1 #delta=0 numeventopres=0 while config.estado in config.estados[1] : if eventCount % 2 == 1 : pesnum=1 else : pesnum=2 #Configurando evento inicial y siguiente if not iniPes : print '************************Configurando evento inicial y siguiente***********************************************************************' horaact=datetime.today() horaactst = horaact.strftime("%H:%M:%S.%f") print 'horaActual='+horaactst #Evento inicial if numEventos > 0 : evento=eventos[eventoActual-1] if horaactst < str(evento[1]): print 'Set noSenal 1' pespres[1]=0 self.setContent(rutaNoSenal,1) if iptv: instance.vlm_set_input('iptv', ruta_iptv+rutaNoSenal+'.mp4') horaact1=horaact+timedelta(seconds=dnsSg,milliseconds=dnsMs) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[1]=horaact1 print 'horasumada='+horaactst1 #Evento Siguiente if horaactst1 < str(evento[1]): print 'Set noSenal 2' pespres[2]=0 self.setContent(rutaNoSenal,2) horaact2=horaact1+timedelta(seconds=dnsSg,milliseconds=dnsMs) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2]=horaact2 print 'horasumada='+horaactst2 else : print 'Set evento 2' pespres[2]=1 self.setContent(evento[3],2) horaevt = datetime.strptime(str(evento[2]), "%H:%M:%S.%f") print horaactst1 print str(horaevt.minute) print str(horaevt.second) print str(horaevt.microsecond) horaact2=horaact1+timedelta(minutes=horaevt.minute,seconds=horaevt.second,milliseconds=(horaevt.microsecond/1000)) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2]=horaact2 print 'horasumada='+horaactst2 if numEventos+1 > eventoActual: eventoActual+=1 else : print 'Set evento 1' pespres[1]=1 self.setContent(evento[3],1) if iptv: instance.vlm_set_input('iptv', ruta_iptv+evento[3]+'.mp4') horaevt = datetime.strptime(str(evento[2]), "%H:%M:%S.%f") horaact1=horaact+timedelta(minutes=horaevt.minute,seconds=horaevt.second,milliseconds=(horaevt.microsecond/1000)) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[1]=horaact1 print 'horasumada='+horaactst1 if numEventos+1 > eventoActual: eventoActual+=1 #Evento Siguiente if horaactst1 < str(eventos[eventoActual-1][1]): print 'Set noSenal 2' pespres[2]=0 self.setContent(rutaNoSenal,2) horaact2=horaact1+timedelta(seconds=dnsSg,milliseconds=dnsMs) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2]=horaact2 print 'horasumada='+horaactst2 else : print 'Set evento 2' pespres[2]=1 evento=eventos[eventoActual-1] self.setContent(evento[3],2) horaevt = datetime.strptime(str(evento[2]), "%H:%M:%S.%f") horaact2=horaact1+timedelta(minutes=horaevt.minute,seconds=horaevt.second,milliseconds=(horaevt.microsecond/1000)) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2]=horaact2 print 'horasumada='+horaactst2 if numEventos+1 > eventoActual: eventoActual+=1 else: print 'Set noSenal 2' pespres[2]=0 self.setContent(rutaNoSenal,2) horaact2=horaact1+timedelta(seconds=dnsSg,milliseconds=dnsMs) horaactst2 = horaact2.strftime("%H:%M:%S.%f") pestimes[2]=horaact2 print 'horasumada='+horaactst2 else: self.setContent(rutaNoSenal,1) if iptv: instance.vlm_set_input('iptv', ruta_iptv+rutaNoSenal+'.mp4') self.setContent(rutaNoSenal,2) if iptv : instance.vlm_play_media('iptv') args = shlex.split('pesvideo2ts '+pid_video+' 25 112 '+ts_video_bitrate+' 1 1.video.pes 2.video.pes') fifo3 = open('fifo_video.ts', 'w') self.p5 = Popen(args,shell=False,stdout=fifo3,stderr=PIPE) args = shlex.split('pesaudio2ts '+pid_audio+' 1152 48000 384 1 1.audio.pes 2.audio.pes') fifo4 = open('fifo_audio.ts', 'w') self.p6 = Popen(args,shell=False,stdout=fifo4,stderr=PIPE) print '-----'+self.p5.stderr.readline() print '-----'+self.p5.stderr.readline() if numEventos > 0 : t0 = TimerInfo(1,'{\"id\" : \"1\" , \"tipo\" : \"1\", \"texto\" : \"kalash, kalash\" , \"duracion\" : \"1\"}\n') t0.start() iniPes=True else: break print '*************************Presentando evento**********************************************************************' if pespres[pesnum] is 1 : eventopres=eventos[numeventopres] duraevt = datetime.strptime(eventopres[2], "%H:%M:%S.%f") tiempo=float(float((duraevt.minute*60*1000000)+(duraevt.second*1000000)+duraevt.microsecond)/float(1000000)) self.iniInfoAsociada(eventopres[0]) self.iniVotacion(eventopres[0],tiempo) numeventopres+=1 while True: line=self.p6.stderr.readline() parts1=line.split(",") parts2=parts1[0].split(" ") if len(parts2) > 1: sync1=parts2[10] else: sync1=None line=self.p5.stderr.readline() parts1=line.split(",") parts2=parts1[0].split(" ") if len(parts2) > 1: sync2=parts2[9] else: sync2=None if sync1 is not None and sync2 is not None: if sync1 != sync2 : print '--- Out of Synchronization --- '+sync1+' different of '+sync2 mbeanHelper.sendNotification(mbeans[0],'gestv.error.audioVideoOutOfSynchronization', 'empty'); break horaact=datetime.today() horaactst = horaact.strftime("%H:%M:%S.%f") print 'horafintimer='+horaactst #Configurando evento posterior print '************************Configurando evento posterior***********************************************************************' if pesnum is 1 : pesevt=2 else : pesevt=1 horaactst1 = pestimes[pesevt].strftime("%H:%M:%S.%f") print 'hora siguiente='+horaactst1 if numEventos+1 > eventoActual: evento=eventos[eventoActual-1] if horaactst1 < str(evento[1]): print 'Set noSenal '+str(pesnum) pespres[pesnum]=0 self.setContent(rutaNoSenal,pesnum) horaact1=pestimes[pesevt]+timedelta(seconds=dnsSg,milliseconds=dnsMs) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[pesnum]=horaact1 print 'horasumada='+horaactst1 else: print 'Set evento id='+str(evento[0])+' '+str(pesnum) pespres[pesnum]=1 self.setContent(evento[3],pesnum) horaevt = datetime.strptime(str(evento[2]), "%H:%M:%S.%f") horaact1=pestimes[pesevt]+timedelta(minutes=horaevt.minute,seconds=horaevt.second,milliseconds=(horaevt.microsecond/1000)) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[pesnum]=horaact1 print 'horasumada='+horaactst1 if numEventos+1 > eventoActual : eventoActual+=1 else: if pespres[1] is 0 and pespres[2] is 0: break; else: print 'Set noSenal '+str(pesnum) pespres[pesnum]=0 self.setContent(rutaNoSenal,pesnum) horaact1=pestimes[pesevt]+timedelta(seconds=dnsSg,milliseconds=dnsMs) horaactst1 = horaact1.strftime("%H:%M:%S.%f") pestimes[pesnum]=horaact1 print 'horasumada='+horaactst1 eventCount+=1 if iptv : instance.vlm_set_input('iptv', ruta_iptv+rutaNoSenal+'.mp4') while config.estado in config.estados[1] : print 'colocando ciclo no senal' #tiempo=float(float((duraNoSenal.minute*60*1000000)+(duraNoSenal.second*1000000)+duraNoSenal.microsecond)/float(1000000)) #time.sleep(tiempo-1) #while True: line=self.p6.stderr.readline() print '-- '+line+' --' line=self.p5.stderr.readline() print '-- '+line+' --' else : mbeanHelper.sendNotification(mbeans[0],'gestv.error.contentRepositoryNotFound', 'empty'); print "Error: No pudo conectarse al repositorio de contenidos." jpype.detachThreadFromJVM() self.parar() jpype.detachThreadFromJVM()
def main(firmware='*****@*****.**', model='mk3060', testname='short2pps'): global DEBUG userid = '500001169232518525' linkkit_test_server = 'pre-iotx-qs.alibaba.com' server = '11.238.148.46' #server = '116.62.245.240' port = 34568 wifissid = 'aos_test_01' wifipass = '******' #parse input i = 1 while i < len(sys.argv): arg = sys.argv[i] if arg.startswith('--firmware='): args = arg.split('=') if len(args) != 2: print 'wrong argument {0} input, example: --firmware=firmware.bin'.format( arg) firmware = args[1] elif arg.startswith('--model='): args = arg.split('=') if len(args) != 2: print 'wrong argument {0} input, example: --model=mk3060'.format( arg) model = args[1] elif arg.startswith('--testname='): args = arg.split('=') if len(args) != 2: print 'wrong argument {0} input, example: --testname=5pps'.format( arg) testname = args[1] elif arg.startswith('--userid='): args = arg.split('=') if len(args) != 2 or args[1].isdigit() == False: print 'wrong argument {0} input, example: --userid=123456789012345678'.format( arg) userid = args[1] elif arg.startswith('--server='): args = arg.split('=') if len(args) != 2: print 'wrong argument {0} input, example: --server=192.168.10.16'.format( arg) server = args[1] elif arg.startswith('--port='): args = arg.split('=') if len(args) != 2 or args[1].isdigit() == False: print 'wrong argument {0} input, example: --port=34568'.format( arg) port = int(args[1]) elif arg.startswith('--wifissid='): args = arg.split('=') if len(args) != 2: print 'wrong argument {0} input, example: --wifissid=test_wifi'.format( arg) wifissid = args[1] elif arg.startswith('--wifipass='******'=') if len(args) != 2: print 'wrong argument {0} input, example: --wifipass=test_password'.format( arg) wifipass = args[1] elif arg.startswith('--debug='): args = arg.split('=') if len(args) != 2 or args[1].isdigit() == False: print 'wrong argument {0} input, example: --debug=1'.format( arg) DEBUG = (args[1] != '0') elif arg == '--help': print 'Usage: python {0} [--firmware=xxx.bin] [--model=xxx] [--testname=xxxx] [--userid=xxxxx] [--server=xx.x.x.x] [--port=xx] [--wifissid=wifi_ssid] [--wifipass=password] [--debug=0/1]'.format( sys.argv[0]) return [0, 'help'] i += 1 if DEBUG: print "firmware: {0}".format(firmware) print "model: {0}".format(model) print "testname: {0}".format(testname) print "userid: {0}".format(userid) print "server: {0}".format(server) print "port: {0}".format(port) print "wifissid: {0}".format(wifissid) print "wifipass: {0}".format(wifipass) if testname not in testnames: print "error: unsupported testname {0}".format(repr(testname)) return [1, 'testname {0} unsupported'.format(repr(testname))] if not model or model.lower() not in models: print "error: unsupported model {0}".format(repr(model)) return [1, 'model {0} unsupported'.format(repr(model))] model = model.lower() logname = time.strftime('-%Y-%m-%d@%H-%M') logname = testname + logname + '.log' at = Autotest() print "at.start === : {0}".format(server) if at.start(server, port, logname) == False: print 'error: start failed' return [1, 'connect testbed failed'] print "at.ok === : {0}".format(server) number = 1 timeout = 120 allocted = at.device_allocate(model, number, timeout, 'alink') if len(allocted) != number: print "error: request device allocation failed" return [1, 'allocate device failed'] print "allocted device", allocted[0] devices = {'A': allocted[0]} device = 'A' #subscribe device if at.device_subscribe(devices) == False: print 'error: subscribe to device failed, some devices may not exist in testbed' return [1, 'subscribe device failed'] #program device succeed = False retry = 5 addr = models[model] print 'programming device {0} ...'.format(devices[device]) for i in range(retry): print "firmware = {0}".format(firmware) if at.device_program(device, addr, firmware) == True: succeed = True break time.sleep(0.5) if succeed == False: print 'error: program device {0} failed'.format(devices[device]) return [1, 'program device failed'] print 'program device {0} succeed'.format(devices[device]) time.sleep(5) #connect to linkkit succeed = False retry = 5 key_name = None uuid = None startflag = 0 while retry > 0: #clear previous setting and reboot #at.device_run_cmd(device, 'kv del wifi') #at.device_run_cmd(device, 'netmgr clear') time.sleep(2) at.device_control(device, 'reset') time.sleep(5) netmgr = 2 while (netmgr > 0): print "after reset" #connect device to linkkit at.device_run_cmd(device, 'netmgr connect {0} {1}'.format( wifissid, wifipass), timeout=1.5) netmgr -= 1 time.sleep(2) print "after connect" #at.device_control(device, 'reboot') time.sleep(20) print "after reboot" loop = 5 while (loop > 0): filter = ['KEY_NAME:'] response = at.device_run_cmd(device, 'prtkey', 1, 5.5, filter) print "after prtkey {0}".format(response) lenresp = len(response) if response == False or len(response) != 1: loop -= 1 continue key_name = response[0].split()[-1] print " key_name is : {0}".format(key_name) productKey = key_name.split('.', 2)[0] deviceName = key_name.split('.', 2)[1] print " productKey is :{0}".format(productKey) print " deviceName is :{0}".format(deviceName) print "connect linkkit succeed, key_name:{0}".format(key_name) startflag = 1 break retry -= 1 if startflag == 0: continue time.sleep(2) thing_crt_flag = 0 thing_check = 10 while (thing_check > 0): filter = ['THING_ID_CREAT'] response = at.device_run_cmd(device, 'prtkey', 1, 2.5, filter) print "after prtkey {0}".format(response) if response == False or len(response) != 1: thing_check -= 1 time.sleep(2) continue thing_crt_flag = 1 break if (thing_crt_flag == 0): print "thing creat fail" continue else: break if (startflag == 0): print "device start fail" time.sleep(2) at.device_control(device, 'reset') time.sleep(2) return [1, 'device start fail'] if (thing_crt_flag == 0): print "device thing creat fail" time.sleep(2) at.device_control(device, 'reset') time.sleep(2) return [1, 'device thing creat fail'] sys_usr = getpass.getuser() print("user", sys_usr) if sys_usr == "iot": os.environ['JAVA_HOME'] = '/usr/local/jdk1.8.0_151' if sys_usr == "lc122798": os.environ['JAVA_HOME'] = '/home/lc122798/tools/jdk1.8.0_151' time.sleep(5) start_jvm() attach_jvm() print(jpype.getDefaultJVMPath()) MyDevice = jpype.JClass('MyDevice') jardevice = MyDevice(productKey, deviceName) time.sleep(10) loopcnt = 100 successcnt = loopcnt while (loopcnt > 0): print("start setProperty") if jardevice.setProperty('LightSwitch', 1): time.sleep(0.5) else: time.sleep(1) continue loopcnt -= 1 cycle_ms = 1 #time.sleep(cycle_ms) time.sleep(60) retry = 100 recordcnt = 0 while (retry > 0): filter = ['PROPERTY_SET_COUNT::'] response = at.device_run_cmd(device, 'prtkey', 1, 2.5, filter) print "after prtkey {0}".format(response) if response == False or len(response) != 1: retry -= 1 time.sleep(2) continue returnstr = response[0].split()[-1] print " returnstr is : {0}".format(returnstr) recordcnt = int(returnstr) print("out int", recordcnt) break jpype.detachThreadFromJVM() time.sleep(2) at.device_control(device, 'reset') time.sleep(2) print("out put", successcnt, recordcnt) if (successcnt == recordcnt): print "linkkit success" return [0, 'linkkit success'] else: print "linkkit fail" return [1, 'linkkit fail']
output_actions = [] if response_actions: for i, j_action in enumerate(response_actions): j_type = j_action.getType() p_action = ae_action.AdaptationAction(j_type.ordinal()) p_action.target = j_action.getTarget() p_action.destination = j_action.getDestination() p_action.scale_value = j_action.getScaleValue() p_action.score = j_action.getScore() output.OUTPUT.info("[Action {} type]".format(i), p_action) output.OUTPUT.info("[Action {} target]".format(i), (p_action.target or 'None')) output.OUTPUT.info("[Action {} destination]".format(i), (p_action.destination or 'None')) output.OUTPUT.info("[Action {} scale_value]".format(i), (p_action.scale_value or 'None')) output.OUTPUT.info("[Action {} score]".format(i), (p_action.score or 'None')) output_actions.append(p_action) else: raise Exception('No actions to translate') except Exception, err: output.OUTPUT.error("Problem with python translation: {}".format(err)) output.OUTPUT.error(err) self._results[self._uuid] = output_actions output.OUTPUT.info("Detaching thread from JVM...") jpype.detachThreadFromJVM() output.OUTPUT.info("Thread detached from JVM") output.OUTPUT.info("Releasing JVM lock...") self._lock.release() output.OUTPUT.info("JVM lock released")