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 detach():
if jp.isThreadAttachedToJVM():
jp.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")
