def dictCheck(dictionary, value, subvalue, configName):
map = LinkedHashMap()
if type(dictionary) == dict:
for k in dictionary.keys():
if type(k) != str:
raise TypeError, configName + " key [" + ` k ` + "] not a str"
l = dictionary[k]
if type(l) != value:
raise TypeError, configName + " value [" + `l` + "] not a " \
+ `value`
if value == list or value == tuple:
n = ArrayList()
for m in l:
if type(m) != subvalue:
raise TypeError, configName + " value [" + `l` \
+ "] isn't a " + `subvalue` + ": " + `m`
elif subvalue == int:
n.add(Integer(m))
elif subvalue == float:
n.add(Float(m))
else:
n.add(m)
map.put(k, n)
else:
if value == int:
map.put(k, Integer(l))
elif value == float:
map.put(k, Float(l))
else:
map.put(k, l)
else:
raise TypeError, configName + " not a dict:" + ` dictionary `
return map
def __init__(self, imageWidth=None, imageHeight=None, expandLeft=25.0, expandRight=25.0, expandTop=25.0, expandBottom=25.0, mask=None, wholeDomain=0, bgColor=None):
# Create empty display and data manager for display
display = GFEMapRenderableDisplay()
self.dataMgr = DataManagerOffscreenFactory.getInstance(display)
self.refId = None
envelope = None
gloc = self.dataMgr.getParmManager().compositeGridLocation()
if mask is not None:
from com.raytheon.uf.common.dataplugin.gfe.reference import ReferenceData
CoordinateType = ReferenceData.CoordinateType
self.refId = ReferenceID(mask)
if wholeDomain == 0:
envelope = self.dataMgr.getRefManager().loadRefSet(self.refId).overallDomain(CoordinateType.GRID)
if imageWidth is not None:
imageWidth = Integer(int(imageWidth))
if imageHeight is not None:
imageHeight = Integer(int(imageHeight))
geom = GfeImageUtil.getLocationGeometry(gloc, envelope, imageWidth, imageHeight, expandLeft / 100.0, expandRight / 100.0, expandTop / 100.0, expandBottom / 100.0)
# Create descriptor for display
desc = MapDescriptor(geom)
display.setDescriptor(desc)
VizPainter.VizPainter.__init__(self, display, backgroundColor=bgColor)
gfeSystem = GFESystemResource(self.dataMgr)
self.addVizResource(gfeSystem)
desc.getResourceList().getProperties(gfeSystem).setSystemResource(True)
self.primaryRsc = None
def load_zones(app):
"""Read favourite zones
"""
app.zones = []
favZonesDir = File(
File.separator.join(
[app.SCRIPTDIR, "configuration", "favourite_zones"]))
for zoneFile in sorted(favZonesDir.listFiles()):
name = zoneFile.getName()[:-4]
fileName = zoneFile.getPath()
zoneFile = open(fileName)
fileContent = zoneFile.read()
if len(fileContent.split("|")) == 2:
geomString, country = fileContent.split("|")
country = country.upper().decode("utf-8")
else:
geomString = fileContent
country = ""
zoneFile.close()
zType = "rectangle"
try:
Integer.parseInt(geomString[0])
except NumberFormatException:
zType = "polygon"
zone = Zone(app, name, zType, geomString, country)
app.zones.append(zone)
if name == app.favZoneName:
app.favZone = zone
#Fav zone is active but its data is missing
if app.favouriteZoneStatus and app.favZone is None:
app.favouriteZoneStatus = False
def test_int_compare(self):
x = Integer(5)
y = Integer(7)
self.assertTrue(x < y)
self.assertFalse(x > y)
self.assertTrue(x <= y)
self.assertFalse(x >= y)
self.assertTrue(x != y)
self.assertFalse(x == y)
self.assertTrue(y > x)
self.assertFalse(y < x)
self.assertTrue(y >= x)
self.assertFalse(y <= x)
self.assertTrue(y != x)
self.assertFalse(y == x)
z = Integer(7)
self.assertFalse(y < z)
self.assertFalse(y > z)
self.assertTrue(y >= z)
self.assertTrue(y <= z)
self.assertFalse(y != z)
self.assertTrue(y == z)
self.assertFalse(z < y)
self.assertFalse(z > y)
self.assertTrue(z >= y)
self.assertTrue(z <= y)
self.assertFalse(z != y)
self.assertTrue(z == y)
def load_zones(app):
"""Read favourite zones
"""
app.zones = []
favZonesDir = File(File.separator.join([app.SCRIPTDIR,
"configuration",
"favourite_zones"]))
for zoneFile in sorted(favZonesDir.listFiles()):
name = zoneFile.getName()[:-4]
fileName = zoneFile.getPath()
zoneFile = open(fileName)
fileContent = zoneFile.read()
if len(fileContent.split("|")) == 2:
geomString, country = fileContent.split("|")
country = country.upper()
else:
geomString = fileContent
country = ""
zoneFile.close()
zType = "rectangle"
try:
Integer.parseInt(geomString[0])
except NumberFormatException:
zType = "polygon"
zone = Zone(app, name, zType, geomString, country)
app.zones.append(zone)
if name == app.favZoneName:
app.favZone = zone
#Fav zone is active but its data is missing
if app.favouriteZoneStatus and app.favZone is None:
app.favouriteZoneStatus = False
def retrieve_an_archive(cust_id, archive_name, user_id, chunk_hint, file_name, output_ids):
print "\nretrieve_a_chunk routine:: output file_name is :", file_name
try:
outfile_stream = FileOutputStream(file_name)
except:
print "retrieve_a_chunk routine:: Failed to open output stream on file : ", file_name, "..returning"
return None
# retrieve data
mc = ManagementContainer.getInstance()
rm = mc.getRecoveryManager()
l_cust_id = Integer.parseInt(cust_id);
l_user_id = Integer.parseInt(user_id);
sosw = IRecoveryManager.SimpleOutputStreamWrapper(outfile_stream)
try:
rm.createPerUserActiveRecoveryArchiveFile(l_cust_id, archive_name, l_user_id, sosw, chunk_hint)
except:
print "retrieve_a_chunk routine:: `Exception while creating active recovery archive..returning"
sys.exc_info()[1].printStackTrace()
print("*** print_exc:")
traceback.print_exc(file=sys.stdout)
outfile_stream.close()
raise
outfile_stream.close()
return get_chunk_hint(file_name, output_ids)
def retrieve_an_archive(cust_id, archive_name, user_id, chunk_hint, file_name, output_ids):
print "\nretrieve_a_chunk routine:: output file_name is :", file_name
try:
outfile_stream = FileOutputStream(file_name)
except:
print "retrieve_a_chunk routine:: Failed to open output stream on file : ", file_name, "..returning"
return None
# retrieve data
mc = ManagementContainer.getInstance()
rm = mc.getRecoveryManager()
l_cust_id = Integer.parseInt(cust_id);
l_user_id = Integer.parseInt(user_id);
sosw = IRecoveryManager.SimpleOutputStreamWrapper(outfile_stream)
try:
rm.createPerUserActiveRecoveryArchiveFile(l_cust_id, archive_name, l_user_id, sosw, chunk_hint)
except:
print "retrieve_a_chunk routine:: `Exception while creating active recovery archive..returning"
sys.exc_info()[1].printStackTrace()
print("*** print_exc:")
traceback.print_exc(file=sys.stdout)
outfile_stream.close()
raise
outfile_stream.close()
return get_chunk_hint(file_name, output_ids)
def test_byte_value(self):
from java.lang import Integer
try:
# call instance from class, should throw but not crash
Integer.byteValue()
except:
pass
def test_byte_value(self):
from java.lang import Integer
try:
# call instance from class, should throw but not crash
Integer.byteValue()
except:
pass
def test_hash(self):
# verify a PyJNumber can be hashed by Python, this will call the Python hash() not the Java hashCode()
a = Integer(50)
self.assertEqual(50, hash(a))
b = Integer(-1)
# -1 in Python means error code so they weirdly have the hash of -1 be -2
self.assertEqual(-2, hash(b))
def get_values(self):
i = Integer(-5)
pi = i.intValue()
j = Long(5001)
pj = j.longValue()
d = Double(10.001)
pd = d.doubleValue()
return i, pi, j, pj, d, pd
def test_number_format(self):
try:
Integer.parseInt('asdf')
except Exception as ex:
if jep.USE_MAPPED_EXCEPTIONS:
self.assertTrue(isinstance(ex, jep.NumberFormatException))
else:
self.assertEquals(ex.java_name, 'java.lang.NumberFormatException')
def get_values(self):
i = Integer(-5)
pi = i.intValue()
j = Long(5001)
pj = j.longValue()
d = Double(10.001)
pd = d.doubleValue()
return i, pi, j, pj, d, pd
def test_setitem(self):
jlist = makeJavaList()
pylist = makePythonList()
jlist[5] = Integer(55)
pylist[5] = Integer(55)
jlist[-3] = Integer(99)
pylist[-3] = Integer(99)
self.assertSequenceEqual(jlist, pylist)
def deploy():
if connected == 'false':
connect(userName, passWord, adminServerURL)
if connected == 'false':
writeResultToFile(RESULT_FAILED + "\n Could not connecte the Server!" + adminServerURL)
edit()
startEdit()
#_targets
_targets =""
if (targetServers is not None) and (len(targetServers) > 0):
_targets = targetServers
if (targetClusters is not None) and (len(targetClusters) > 0):
if len(_targets) > 0:
_targets = _targets + "," + targetClusters
else:
_targets = targetClusters
#timeout
_timeout = 1200000
if (timeOut is not None) and (len(timeOut) > 0):
try:
_timeout = Integer(timeOut).intValue()
except:
print "timeOut not set."
print "appName:" + appName
print "earPath:" + earPath
print "targets:" + _targets
print "_timeout: " + Integer(_timeout).toString()
progressMonitor = None
##cluster must use stage model
if (targetClusters is not None) and (len(targetClusters) > 0):
if (_stageModel is not None) and (len(_stageModel) > 0):
progressMonitor = deploy(appName,earPath,_targets,stageMode=_stageModel,timeout=_timeout)
else:
progressMonitor = deploy(appName,earPath,_targets,stageMode="nostage",timeout=_timeout)
else:
progressMonitor = deploy(appName,earPath,_targets,timeout=_timeout)
## while(progressMonitor.isRunning()):
## print time.sleep(10)
#running, completed, failed, or released
result_state = progressMonitor.getState()
print "deploy's state:" + result_state
if result_state == 'failed':
try:
undo(defaultAnswer='y')
cancelEdit(defaultAnswer='y')
finally:
writeResultToFile(RESULT_FAILED)
else :
try:
save()
activate()
writeResultToFile(RESULT_SUCCEED)
except:
writeResultToFile(RESULT_EXCEPTION)
def __call__(self):
params = Vector()
params.addElement(Integer(6))
params.addElement(Integer(3))
result = client.execute("sample.sumAndDifference", params)
sum = result.get("sum")
grinder.logger.info("SUM %d" % sum)
def test_number_format(self):
try:
Integer.parseInt('asdf')
except Exception as ex:
if jep.USE_MAPPED_EXCEPTIONS:
self.assertTrue(isinstance(ex, jep.NumberFormatException))
else:
self.assertEquals(ex.java_name,
'java.lang.NumberFormatException')
def test_java_exceptions():
if __graalpython__.jython_emulation_enabled:
from java.lang import Integer, NumberFormatException
try:
Integer.parseInt("99", 8)
except NumberFormatException as e:
assert True
else:
assert False
def test_addequals(self):
jlist = makeJavaList()
pylist = makePythonList()
jlist += [Integer(COUNT + 1)]
pylist += [Integer(COUNT + 1)]
self.assertSequenceEqual(jlist, pylist)
toAdd = [Integer(1), Integer(2), Integer(3)]
jlist += toAdd
pylist += toAdd
self.assertSequenceEqual(jlist, pylist)
def warn(self, e):
errorNumber = self.textfield.getText()
if errorNumber == "":
self.textfield.setBorder(self.defaultborder)
return
try:
Integer.parseInt(errorNumber)
except NumberFormatException:
self.textfield.setBorder(BorderFactory.createLineBorder(Color.RED, 1))
return
self.textfield.setBorder(BorderFactory.createLineBorder(Color.GREEN, 1))
def test_nonzero(self):
i, pi, j, pj, d, pd = self.get_values()
self.assertEqual(bool(i), bool(pi))
self.assertEqual(bool(j), bool(pj))
self.assertEqual(bool(d), bool(pd))
self.assertFalse(bool(Integer(0)))
self.assertFalse(bool(Long(0)))
self.assertFalse(bool(Double(0.0)))
self.assertTrue(bool(Integer(1)))
self.assertTrue(bool(Long(1)))
self.assertTrue(bool(Double(1.0)))
def test_bigtest05(self):
'''Get recids_hm_intint'''
message = self.bridge.createMessage('bigtest') \
.setParam('action', 'recids_hm_intint') \
.setParam('size', self.size)
self.bridge.sendMessage(message)
res = HashMap.cast_(message.getResults())
assert res.size() == self.size
assert Integer.cast_(res.get(0)).equals(0)
assert Integer.cast_(res.get(5)).equals(5)
def test_setslice(self):
jlist = makeJavaList()
pylist = makePythonList()
jlist[2:4] = [Integer(7), Integer(1)]
pylist[2:4] = [Integer(7), Integer(1)]
self.assertEqual(len(jlist), len(pylist))
self.assertSequenceEqual(jlist, pylist)
jlist[9:-5] = [Integer(4), Integer(88), Integer(19)]
pylist[9:-5] = [Integer(4), Integer(88), Integer(19)]
self.assertEqual(len(jlist), len(pylist))
self.assertSequenceEqual(jlist, pylist)
def test_pow(self):
i, pi, j, pj, d, pd = self.get_values()
self.assertEqual(pow(i, i), pow(pi, pi))
self.assertEqual(pow(i, 3), pow(pi, 3))
self.assertEqual(pow(j, j), pow(pj, pj))
self.assertEqual(pow(j, 301), pow(pj, 301))
self.assertEqual(pow(d, d), pow(pd, pd))
self.assertEqual(pow(d, 4.53), pow(pd, 4.53))
k = Integer(2)
pk = k.intValue()
self.assertEqual(pow(i, 3, k), pow(pi, 3, pk))
self.assertEqual(pow(j, 301, k), pow(pj, 301, pk))
def warn(self, e):
errorNumber = self.textfield.getText()
if errorNumber == "":
self.textfield.setBorder(self.defaultborder)
return
try:
Integer.parseInt(errorNumber)
except NumberFormatException:
self.textfield.setBorder(
BorderFactory.createLineBorder(Color.RED, 1))
return
self.textfield.setBorder(BorderFactory.createLineBorder(
Color.GREEN, 1))
def test_pow(self):
i, pi, j, pj, d, pd = self.get_values()
self.assertEqual(pow(i, i), pow(pi, pi))
self.assertEqual(pow(i, 3), pow(pi, 3))
self.assertEqual(pow(j, j), pow(pj, pj))
self.assertEqual(pow(j, 301), pow(pj, 301))
self.assertEqual(pow(d, d), pow(pd, pd))
self.assertEqual(pow(d, 4.53), pow(pd, 4.53))
k = Integer(2)
pk = k.intValue()
self.assertEqual(pow(i, 3, k), pow(pi, 3, pk))
self.assertEqual(pow(j, 301, k), pow(pj, 301, pk))
def __queryForecastTimes(self):
from com.raytheon.uf.common.dataquery.requests import DbQueryRequest
from com.raytheon.uf.viz.core.requests import ThriftClient
from java.lang import Integer
request = DbQueryRequest()
request.setConstraints(self._buildConstraints(self.refTime))
request.addRequestField('dataTime.fcstTime')
request.setOrderByField('dataTime.fcstTime')
request.setDistinct(True)
iForecastTimesLimit = Integer(self.forecastTimesLimit)
if (self.forecastTimesLimit > 0):
request.setLimit(iForecastTimesLimit)
return ThriftClient.sendRequest(request).getFieldObjects(
'dataTime.fcstTime', iForecastTimesLimit.getClass())
def initializeServices(self):
self.updateUtilizationInfo = 1
self.discoverDependLinks = Boolean.parseBoolean(self.getParameterValue('discoverDependLinks'))
self.onlyHostDependLinks = 0
self.ignoreUnackedTcpConn = 0
self.shouldCountClients = 1
self.discoverIP = self.Framework.getDestinationAttribute('ip_address')
self.hostId = self.Framework.getDestinationAttribute('hostId')
self.minimalClients = Integer.parseInt(self.Framework.getParameter('minClients'))
self.minimalOctets = Integer.parseInt(self.Framework.getParameter('minOctets'))
self.minimalPackets = Integer.parseInt(self.Framework.getParameter('minPackets'))
self.protocols = self.Framework.getParameter('protocols')
self.disregardListenPorts = Boolean.parseBoolean(self.getParameterValue('disregardListenPorts'))
def servicesPorts(self, onlyKnownPorts = 1):
services = self.Framework.getParameter('services')
if logger.isDebugEnabled():
logger.debug('Requested services:', services)
if (services == None) or (len(services) == 0) or (services == '*'):
if onlyKnownPorts:
portsInfo = self.knownPortsConfigFile.getTcpPorts()
services = ''
delimiter = ''
for info in portsInfo:
services = services + delimiter + str(info.getPortNumber())
delimiter = ','
if len(services) == 0:
return services
else:
return ''
names = services.split(',')
ports = ''
delimiter = ''
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if (portNums == None) or (len(portNums) == 0):
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:', name)
continue
for portNum in portNums:
ports = ports + delimiter + str(portNum)
delimiter = ','
if logger.isDebugEnabled():
logger.debug('Requested services ports:', ports)
return ports
def getGlobals(mod):
mp = HashMap()
for attrName in mod.__dict__:
if not attrName.startswith('__'):
attr = mod.__getattribute__(attrName)
t = type(attr)
if t is not list:
if t is str:
mp.put(attrName, attr)
elif t is int:
mp.put(attrName, Integer(attr))
elif t is float:
mp.put(attrName, Float(attr))
elif t is bool:
mp.put(attrName, Boolean(attr))
else:
arr = None
if len(attr) > 0:
t = type(attr[0])
if t is int:
arr = __fillArray(attr, Integer)
elif t is float:
arr = __fillArray(attr, Float)
elif t is str:
arr = __fillArray(attr, String)
mp.put(attrName, arr)
return mp
def test_compare(self):
pfive = 5
jfive = Integer(5)
ptwosix = 2.6
jtwosix = Double(2.6)
# Need to check with same values on opposite sides of the operator due
# to Python's richcompare behavior.
# check the trues first
self.assertTrue(pfive > jtwosix)
self.assertTrue(jtwosix < pfive)
self.assertTrue(ptwosix < jfive)
self.assertTrue(jfive > ptwosix)
self.assertTrue(ptwosix == jtwosix)
self.assertTrue(jtwosix == ptwosix)
self.assertTrue(pfive == jfive)
self.assertTrue(jfive == pfive)
# check the falses next
self.assertFalse(pfive < jtwosix)
self.assertFalse(jtwosix > pfive)
self.assertFalse(ptwosix > jfive)
self.assertFalse(jfive < ptwosix)
self.assertFalse(pfive != jfive)
self.assertFalse(jfive != pfive)
self.assertFalse(ptwosix != jtwosix)
self.assertFalse(jtwosix != ptwosix)
def get_recids_changes(message):
"""Retrieves the recids of the last changed documents"""
last_recid = None
table = 'bibrec'
if message.getParam("table"):
table = str(message.getParam("table"))
if message.getParam("last_recid"):
#last_recid = int(Integer.cast_(message.getParam("last_recid")).intValue())
last_recid = int(str(message.getParam("last_recid")))
mod_date = None
if message.getParam("mod_date"):
mod_date = str(message.getParam("mod_date"))
max_records = 10000
if message.getParam('max_records'):
max_records = int(Integer.cast_(message.getParam("max_records")).intValue())
if last_recid and last_recid == -1:
mod_date = None
(wid, results) = api_calls.dispatch("get_recids_changes", last_recid, max_recs=max_records,
mod_date=mod_date, table=table)
if results:
data, last_recid, mod_date = results
out = HashMap() #.of_(String, JArray_int)
for k,v in data.items():
out.put(k, JArray_int(v))
message.setResults(out)
message.setParam('mod_date', mod_date)
message.setParam('last_recid', last_recid)
def executeRequest(self, request):
client = None
response = None
try:
if self.params.proxyUsername and self.params.proxyPassword:
credentials = UsernamePasswordCredentials(self.params.proxyUsername, self.params.proxyPassword)
auth_scope = AuthScope(self.params.proxyHost, Integer.valueOf(self.params.proxyPort))
creds_provider = BasicCredentialsProvider()
creds_provider.setCredentials(auth_scope, credentials)
client = HttpClientBuilder.create().setDefaultCredentialsProvider(creds_provider).build()
else:
client = HttpClients.createDefault()
response = client.execute(request)
status = response.getStatusLine().getStatusCode()
entity = response.getEntity()
result = EntityUtils.toString(entity, "UTF-8") if entity else None
headers = response.getAllHeaders()
EntityUtils.consume(entity)
return HttpResponse(status, result, headers)
finally:
if response:
response.close()
if client:
client.close()
def servicesPorts(self, onlyKnownPorts=1):
services = self.Framework.getParameter('services')
if logger.isDebugEnabled():
logger.debug('Requested services:', services)
if (services == None) or (len(services) == 0) or (services == '*'):
if onlyKnownPorts:
portsInfo = self.knownPortsConfigFile.getTcpPorts()
services = ''
delimiter = ''
for info in portsInfo:
services = services + delimiter + str(info.getPortNumber())
delimiter = ','
if len(services) == 0:
return services
else:
return ''
names = services.split(',')
ports = ''
delimiter = ''
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if (portNums == None) or (len(portNums) == 0):
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:',
name)
continue
for portNum in portNums:
ports = ports + delimiter + str(portNum)
delimiter = ','
if logger.isDebugEnabled():
logger.debug('Requested services ports:', ports)
return ports
def equals(self, other):
try:
selfIntValue = self.getIntValue()
otherIntValue = other.getIntValue()
return _Integer.equals(selfIntValue, otherIntValue)
#
except:
return False
def diagnostic_test(message):
out = []
message.setParam("query", "boson")
perform_request_search_ints(message)
res = JArray_int.cast_(message.getResults())
out.append('Search for "boson" retrieved: %s hits' % len(res) )
out.append('Total hits: %s' % Integer.cast_(message.getParam("total")))
message.setResults('\n'.join(out))
def buildBarChart(self, context):
barChartData = None
self.systemConfig = context["systemConfig"]
self.imgW = 550
self.imgH = 400
if (self.request.getParameter("w") is not None):
self.imgW = Integer.valueOf(self.request.getParameter("w"))
if (self.request.getParameter("h") is not None):
self.imgH = Integer.valueOf(self.request.getParameter("h"))
self.fromDtTxt = self.request.getParameter("from")
self.toDtTxt = self.request.getParameter("to")
if (self.fromDtTxt is None or self.toDtTxt is None):
self.errorMsg = "Invalid date range."
return
self.fromDt = self.dateFormatter.parse(self.fromDtTxt)
self.toDt = self.dateFormatter.parse(self.toDtTxt)
if (self.fromDt.after(self.toDt)):
self.errorMsg = "Invalid date range."
return
self.out = self.response.getOutputStream("image/png")
chartHandlerConfig =self.systemConfig.getObject("charts").get(self.chartName)
className = chartHandlerConfig.get("className")
chartHandlerClass = Class.forName(className)
chartHandlerObject = chartHandlerClass.newInstance()
setSystemConfigMethod = chartHandlerClass.getMethod("setSystemConfig", self.get_class("com.googlecode.fascinator.common.JsonSimple"))
setSystemConfigMethod.invoke(chartHandlerObject, self.systemConfig)
setScriptingServiceMethod = chartHandlerClass.getMethod("setScriptingServices", self.get_class("com.googlecode.fascinator.portal.services.ScriptingServices"))
setScriptingServiceMethod.invoke(chartHandlerObject, context['Services'])
setFromDateMethod = chartHandlerClass.getMethod("setFromDate", self.get_class("java.util.Date"))
setFromDateMethod.invoke(chartHandlerObject, self.fromDt)
setFromDateMethod = chartHandlerClass.getMethod("setToDate", self.get_class("java.util.Date"))
setFromDateMethod.invoke(chartHandlerObject, self.toDt)
renderChartMethod = chartHandlerClass.getMethod("renderChart",
self.get_class("java.io.OutputStream"))
renderChartMethod.invoke(chartHandlerObject, self.out);
self.out.close()
def __activate__(self, context):
response = context["response"]
self.indexer = context["Services"].getIndexer()
self.systemConfig = context["systemConfig"]
self.log = context["log"]
self.sessionState = context["sessionState"]
self.sessionState.set("username", "admin")
writer = response.getPrintWriter("text/plain; charset=UTF-8")
try:
writer.println("Transition workflow script has been started")
count = 0
transitions = self.systemConfig.getArray("transitionWorkflow",
"transitions").toArray()
for transition in transitions:
fromWorkflowId = transition.get("from-workflow-id")
fromWorkflowStage = transition.get("from-workflow-stage")
packages = self.findPackagesToTransition(
fromWorkflowId, fromWorkflowStage)
for package in packages:
writer.println("processing: " + package.get("storage_id"))
self.log.debug("processing: " + package.get("storage_id"))
transitionWorkflow = TransitionWorkflow()
transitionWorkflow.run(
context, package.get("storage_id"), fromWorkflowId,
fromWorkflowStage, transition.get("to-workflow-id"),
transition.get("to-workflow-stage"),
transition.get("to-workflow-page-title"),
transition.get("to-workflow-label"))
self.log.debug("Transition workflow script processed " +
Integer(packages.size()).toString() +
" records for transition " +
transition.toString())
count = count + packages.size()
self.log.info("Transition workflow script processed " +
Integer(count).toString())
writer.println("Transition workflow script processed " +
Integer(count).toString())
self.log.info("Transition workflow script has completed")
writer.println("Transition workflow script has completed")
except Exception, e:
writer.println(
"The transition workflow script had a problem - check logs")
self.log.error("Exception in alerts code: %s" % (e.message))
raise
def pyValToJavaObj(val):
retObj = val
valtype = type(val)
if valtype is int:
retObj = Integer(val)
elif valtype is float:
retObj = Float(val)
elif valtype is long:
retObj = Long(val)
elif valtype is bool:
retObj = Boolean(val)
elif valtype is list:
retObj = ArrayList()
for i in val:
retObj.add(pyValToJavaObj(i))
elif valtype is tuple:
tempList = ArrayList()
for i in val:
tempList.add(pyValToJavaObj(i))
retObj = Collections.unmodifiableList(tempList)
elif issubclass(valtype, dict):
retObj = pyDictToJavaMap(val)
elif issubclass(valtype, JavaWrapperClass):
retObj = val.toJavaObj()
return retObj
def test_type_error(self):
try:
from java.util import Collections, ArrayList
x = ArrayList()
c = Collections.checkedList(x, Integer)
c.add(Integer(5))
c.add(String("5"))
except TypeError as ex:
pass
def makePythonList():
pylist = []
for i in range(COUNT):
# At present have to make it a java.lang.Integer for
# assertSequenceEqual to work. If in the future a
# java.lang.Integer can compare equality to a python int,
# then this should be updated to use python ints.
pylist.append(Integer(i))
return pylist
def test_number_compare(self):
x = 5
from java.lang import Integer
y = Integer(9)
refcount1 = sys.gettotalrefcount()
result = x < y
del result
refcount2 = sys.gettotalrefcount()
self.assertEquals(refcount1, refcount2 - 1)
def test_class(self):
Parent = jclass("com.chaquo.python.TestOverload$Parent")
Child = jclass("com.chaquo.python.TestOverload$Child")
Object = jclass("java.lang.Object")
Float = jclass("java.lang.Float")
String = jclass("java.lang.String")
Integer = jclass("java.lang.Integer")
s = String()
i = Integer(42)
f = Float(1.23)
child = Child()
parent = Parent()
self.assertEqual(parent.resolve(s), 'Parent Object')
self.assertEqual(parent.resolve(i), 'Parent Integer')
self.assertEqual(parent.resolve(f), 'Parent Object')
self.assertEqual(parent.resolve(f, s), 'Parent Object, String')
self.assertEqual(child.resolve(s), 'Child String')
self.assertEqual(child.resolve(i), 'Child Integer')
self.assertEqual(child.resolve(f), 'Child Object')
self.assertEqual(child.resolve(cast(Object, s)), 'Child Object')
self.assertEqual(child.resolve(cast(String, cast(Object, s))),
'Child String')
# Casting of None
with self.ambiguous:
child.resolve(None)
self.assertEqual(child.resolve(cast(String, None)), 'Child String')
self.assertEqual(child.resolve(cast(Object, None)), 'Child Object')
self.assertEqual(child.resolve(cast(String, cast(Object, None))),
'Child String')
self.assertEqual(child.resolve(s, i), 'Child String, Object')
self.assertEqual(child.resolve(i, s), 'Parent Object, String')
with self.inapplicable:
child.resolve(i, i)
# Casting of method parameters
with self.ambiguous:
child.resolve(s, s)
self.assertEqual(child.resolve(cast(Object, s), s),
'Parent Object, String')
self.assertEqual(child.resolve(s, cast(Object, s)),
'Child String, Object')
# Casting of object on which method is called should limit visibility of overloads, but
# subclass overrides of visible overloads should still be called.
child_Parent = cast(Parent, child)
self.assertEqual(child_Parent.resolve(s), 'Child Object')
self.assertEqual(child_Parent.resolve(s, s), 'Parent Object, String')
with self.inapplicable:
child_Parent.resolve(s, i)
with self.assertRaisesRegexp(
TypeError, "int object does not specify a Java type"):
cast(42, child)
def test_mixed_static_and_instance(self):
MSI = TO.MixedStaticInstance
m = MSI()
self.assertEqual(m.resolve11("test"), "String")
self.assertEqual(m.resolve11(42), "Object")
self.assertEqual(MSI.resolve11("test"), "Object")
self.assertEqual(MSI.resolve11(42), "Object")
self.assertEqual(MSI.resolve11(m, "test"), "String")
with self.inapplicable:
MSI.resolve11(m, 42)
# ---
self.assertEqual(m.resolve10(), "")
self.assertEqual(m.resolve10("test"), "String")
with self.inapplicable:
MSI.resolve10()
self.assertEqual(MSI.resolve10("test"), "String")
self.assertEqual(MSI.resolve10(m), "")
with self.inapplicable:
MSI.resolve10(m, "test")
# ---
self.assertEqual(m.resolve01(), "")
self.assertEqual(m.resolve01("test"), "String")
self.assertEqual(MSI.resolve01(), "")
with self.inapplicable:
MSI.resolve01("test")
with self.inapplicable:
MSI.resolve01(m)
self.assertEqual(MSI.resolve01(m, "test"), "String")
# ---
from java.lang import Integer
i = Integer(42)
ts = r"^com.chaquo.python.TestOverload\$MixedStaticInstance@"
self.assertRegexpMatches(m.toString(), ts)
self.assertEqual(m.toString(i), "Integer")
with self.inapplicable:
MSI.toString()
self.assertEqual(MSI.toString(i), "Integer")
self.assertRegexpMatches(MSI.toString(m), ts)
with self.inapplicable:
MSI.toString(m, i)
def convertToIp(self, encodedIp):
#TODO: Make it Python
ipParts = []
for i in range(4):
ipParts.append(encodedIp[:2])
encodedIp = encodedIp[2:]
ip = ''
for ipPart in ipParts:
ip += str(Integer.parseInt(ipPart, 16)) + '.'
ip = ip[:len(ip)-1]
return ip
def updateWithPrePostScriptCmd(Framework, commandLine):
isPrePostScriptAllowed = Boolean.parseBoolean(Framework.getParameter('IsPrePostScriptAllowed'))
prePostScriptExecTimeout = Integer.parseInt(Framework.getParameter('PrePostScriptExecTimeout'))
logger.debug("isPrePostScriptAllowed:", isPrePostScriptAllowed)
if isPrePostScriptAllowed:
deltaParams = ' -scripts:. '
scriptTimeoutParam = ''
if prePostScriptExecTimeout > 0:
scriptTimeoutParam = ' -scriptstimeout:' + str(prePostScriptExecTimeout) + ' '
index = String(commandLine).indexOf(ENTERPRISE_MODE) + String(ENTERPRISE_MODE).length()
commandLine = commandLine[0:index] + deltaParams + scriptTimeoutParam + commandLine[index + 1:]
logger.debug('After apply pre/post scripts, scanner execution command updated to ', commandLine)
return commandLine
def xtest_bigtest05(self):
'''Get recids_hm_intint -- TODO: move to demotest,
it will not work, because it needs solr instance'''
#req = QueryRequest()
size = self.size
hm = HashMap().of_(String, String)
hm.put('action', 'recids_hm_intint')
hm.put('size', str(size))
params = MapSolrParams(hm)
req = LocalSolrQueryRequest(self.core, params)
rsp = SolrQueryResponse()
message = self.bridge.createMessage('bigtest_www') \
.setParam('response', rsp) \
.setParam('request', req)
self.bridge.sendMessage(message)
res = HashMap.cast_(message.getResults())
assert res.size() == self.size
assert Integer.cast_(res.get(0)).equals(0)
assert Integer.cast_(res.get(5)).equals(5)
def compareTo(self, other):
if other is None:
raise _NullPointerException()
#
selfIntValue = self.getIntValue()
otherIntValue = None
try:
otherIntValue = other.getIntValue()
#
except:
raise _ClassCastException()
#
return _Integer.compare(selfIntValue, otherIntValue)
def __init__(self, w, b):
JDialog.__init__(self, w)
self.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE)
self.panel = Panel()
self.getContentPane().add(self.panel)
t = Text()
t.addFocusListener(FocusLostListener(self.lostfocus))
self.panel + t
view = ""
for byte in b:
view += Integer.toString((0xFF & byte), 2).zfill(8)
view += ' '
t.settext(view[:-1])
self.pack()
self.setVisible(1)
def parseMappingString(mappingString):
bitPositions = TreeSet()
bytesNumber = len(mappingString) / SYMBOLS_PER_BYTE
for i in range(bytesNumber):
currentPosition = i * SYMBOLS_PER_BYTE
currentByteString = mappingString[currentPosition : currentPosition + SYMBOLS_PER_BYTE]
currentByte = Integer.parseInt(currentByteString, 16)
for j in range(BITS_IN_SYMBOL):
if (currentByte & 1) == 1:
bitPositions.add(i * BITS_IN_SYMBOL + BITS_IN_SYMBOL - j)
currentByte = currentByte >> 1
return list(ArrayList(bitPositions))
def delete_record(message):
"""deletes record"""
diff = message.getParam('diff')
if diff:
diff = int(str(diff))
else:
diff = 5 # 5 secs older
recid = int(Integer.cast_(message.getParam('recid')).intValue())
record = search_engine.get_record(recid)
bibrecord.record_add_field(record, "980", subfields=[("c", "DELETED")])
ret = bibupload.bibupload(record, opt_mode='replace')
recid = ret[1]
message.setResults(Integer(recid))
# extra query needed because invenio sets modification date=NOW()
# and so the deleted recs have modification_date<creation_date
#dbquery.run_sql("UPDATE bibrec SET modification_date=NOW() + %s WHERE id=%s" % (diff, recid))
change_date(recid, diff=diff)
def read_gui(self):
"""Read preferences from gui
"""
username = self.userTextField.getText()
level = self.levelsCombo.getSelectedItem()
limit = self.limitTextField.getText()
try:
limit = Integer.parseInt(limit)
if limit > 500:
limit = 500
limit = str(limit)
except NumberFormatException:
limit = ""
preferences = {"username": username.strip(),
"level": level,
"limit": limit}
return preferences
def getRequestedPortsSet(self):
services = self.Framework.getParameter('P2PServerPorts')
if logger.isDebugEnabled():
logger.debug('Requested services:', services)
if (services == None) or (len(services) == 0) or (services == '*'):
return None
names = services.split(',')
portsSet = HashSet()
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if portNums == None:
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:', name)
continue
for portNum in portNums:
portsSet.add(portNum)
return portsSet
def test_get_recids_deleted(self):
#time.sleep(1) # otherwise the new record has the same creation time as the old recs
#message = self.bridge.createMessage('create_delete')
#self.bridge.sendMessage(message)
message = self.bridge.createMessage('create_record')
self.bridge.sendMessage(message)
created_recid = int(Integer.cast_(message.getResults()).intValue())
message = self.bridge.createMessage('delete_record').setParam('recid', created_recid)
self.bridge.sendMessage(message)
deleted_recid = int(str(message.getResults()))
req = QueryRequest()
rsp = SolrQueryResponse()
message = self.bridge.createMessage('get_recids_changes') \
.setSender('InvenioKeepRecidUpdated') \
.setParam('response', rsp) \
.setParam('last_recid', 30)
self.bridge.sendMessage(message)
results = message.getResults()
out = HashMap.cast_(results)
added = JArray_int.cast_(out.get('ADDED'))
updated = JArray_int.cast_(out.get('UPDATED'))
deleted = JArray_int.cast_(out.get('DELETED'))
message = self.bridge.createMessage('wipeout_record') \
.setParam('recid', deleted_recid)
self.bridge.sendMessage(message)
assert created_recid == deleted_recid
assert len(added) == 0
assert len(updated) == 0
assert len(deleted) == 1
assert int(str(deleted[0])) == deleted_recid
def getKnownListeningPortsSet(self):
ports = self.Framework.getParameter('knownListeningPorts')
portsSet = HashSet()
if logger.isDebugEnabled():
logger.debug('Known Listening Ports:', ports)
if (ports == None) or (len(ports) == 0):
return None
if (ports == '*'):
portsSet.add('*')
return portsSet
names = ports.split(',')
for name in names:
portNums = self.knownPortsConfigFile.getPortByName(name)
if portNums == None:
try:
portNums = [Integer.parseInt(name)]
except:
logger.debug('Failed to resolve service port number:', name)
continue
for portNum in portNums:
portsSet.add(portNum)
return portsSet
def initParameters(Framework):
try:
parameter = Framework.getParameter(PARAM_INACTIVE_TIMEOUT)
logger.debug("Parameter for InactiveTimeout:", parameter)
global inactiveTimeout
inactiveTimeout = Integer.parseInt(parameter) * DAY
except:
pass
logger.debug("InactiveTimeout value(ms):", inactiveTimeout)
try:
parameter = Framework.getParameter(PARAM_DELETE_TIMEOUT)
logger.debug("Parameter for deleteTimeout:", parameter)
global deleteTimeout
deleteTimeout = Integer.parseInt(parameter) * DAY
except:
pass
logger.debug("DeleteTimeout value(ms):", deleteTimeout)
try:
parameter = Framework.getParameter(PARAM_CLEANUP_TIMEOUT)
logger.debug("Parameter for CleanupTimeout:", parameter)
global cleanupTimeout
cleanupTimeout = Integer.parseInt(parameter) * DAY
except:
pass
logger.debug("CleanupTimeout value:(ms):", cleanupTimeout)
#make sure the clean up timeout is not shorter than the sum of inactive timeout and delete timeout
minCleanupTimeout = inactiveTimeout + deleteTimeout
if cleanupTimeout < minCleanupTimeout:
cleanupTimeout = minCleanupTimeout
try:
parameter = Framework.getParameter(PARAM_MOONWALK_SLEEP)
logger.debug("Parameter for moonwalkSleep:", parameter)
global moonwalkSleep
moonwalkSleep = Integer.parseInt(parameter)
except:
pass
try:
parameter = Framework.getParameter(PARAM_IS_COLLECT_DATA_CENTER_IP)
logger.debug("Parameter for isCollectDataCenterIP:", parameter)
global isCollectDataCenterIP
isCollectDataCenterIP = Boolean.parseBoolean(parameter)
except:
pass
try:
parameter = Framework.getParameter(PARAM_IS_REPORT_DELETE_IP)
logger.debug("Parameter for isReportDeleteIP:", parameter)
global isReportDeleteIP
isReportDeleteIP = Boolean.parseBoolean(parameter)
except:
pass
logger.debug("Final value for parameters:")
logger.debug("inactiveTimeout:", inactiveTimeout)
logger.debug("deleteTimeout:", deleteTimeout)
logger.debug("cleanupTimeout:", cleanupTimeout)
logger.debug("moonwalkSleep:", moonwalkSleep)
logger.debug("isCollectDataCenterIP:", isCollectDataCenterIP)
logger.debug("isReportDeleteIP:", isReportDeleteIP)
def wipeout_record(message):
recid = int(Integer.cast_(message.getParam('recid')).intValue())
bibupload_regression_tests.wipe_out_record_from_all_tables(recid)
print 'type conversions'
print 'numbers'
from java.lang.Math import abs
assert abs(-2.) == 2., 'Python float to Java double'
assert abs(-2) == 2l, 'Python int to Java long'
assert abs(-2l) == 2l, 'Python long to Java long'
try: abs(-123456789123456789123l)
except TypeError: pass
print 'strings'
from java.lang import Integer, String
assert Integer.valueOf('42') == 42, 'Python string to Java string'
print 'arrays'
chars = ['a', 'b', 'c']
assert String.valueOf(chars) == 'abc', 'char array'
print 'Enumerations'
from java.util import Vector
vec = Vector()
items = range(10)
for i in items:
vec.addElement(i)
expected = 0
for i in vec:
def discover_private(self):
maxPorts = Integer.parseInt(self.getParameterValue('maxPorts'))
tcpOnly = Boolean.parseBoolean(self.getParameterValue('tcpOnly'))
#WE ALWAYS CHECK ONLY ONE DIRECTION SINCE WE ALWAYS REPORT FLOWS IN BOTH DIRECTION SO
#WE CAN COUNT CLIENTS ONLY ON ONE SIDE
#WE ASSUME THAT NETFLOW ALWAYS REPORTS CONNECTIONS IN BOTH DIRECTIONS SO WE WILL GET
#OCTETS AND PACKETS COUNT ALWAYS
query = ' select SrcAddr ,DstAddr ,DstPort ,count(*) cnt, sum(dPkts) dPkts, sum(dOctets) dOctets, Prot,'
query = query + ' case when Port is NULL then 0 else 1 end ListenPort '
query = query + ' from Agg_V5 left join Port_Process on DstAddr=ipaddress and DstPort=port and Prot = Protocol and listen '
if tcpOnly:
query = query + ' where Prot=6 '
query = query + ' group by SrcAddr, DstAddr, DstPort '
#for each ip -> ip traffic we first wnat get ports that are listen, than which have more clients
#after all ports which have more traffic
query = query + ' order by SrcAddr, DstAddr, ListenPort desc, cnt desc, dOctets desc, dPkts desc'
#here Prot is asc since TCP ports have higher priority on UDP ports
query = query + ', Prot asc '
conn = self.Framework.getProbeDatabaseConnection('TCPDISCOVERY')
st = None
result = None
try:
st = conn.createStatement()
result = st.executeQuery(query)
currSrcAddr = None
portsSet = StringVector()
currDstAddr = None
currLinkID = None
octets = 0
packets = 0
dataFound = 0
while result.next():
dataFound = 1
srcAddr = str(result.getString('SrcAddr'))
dstAddr = str(result.getString('DstAddr'))
dstPort = result.getString('DstPort')
cnt = result.getString('cnt')
listenPort = result.getInt('ListenPort')
if not self.isServerPort(cnt, listenPort, dstPort):
continue
if not self.shouldInclude(srcAddr, 0):
continue
if not self.shouldInclude(dstAddr, 1):
continue
linkID = self.createLinkID(srcAddr, dstAddr)
if currLinkID == linkID:
octets = octets + result.getInt('dOctets')
packets = packets + result.getInt('dPkts')
if portsSet.size() < maxPorts:
portsSet.add(dstPort)
continue
elif currLinkID != None:
self.addTraffic(currSrcAddr, currDstAddr, portsSet, octets, packets)
currLinkID = linkID
currSrcAddr = srcAddr
currDstAddr = dstAddr
portsSet = StringVector()
portsSet.add(dstPort)
octets = result.getInt('dOctets')
packets = result.getInt('dPkts')
if not dataFound:
self.Framework.reportWarning("No data to process, please check if Host Resources jobs had already run")
if currLinkID != None:
self.addTraffic(currSrcAddr, currDstAddr, portsSet, octets, packets)
finally:
if result != None:
try:
result.close
except:
pass
conn.close(st)
conn.close()
