class ConnReader:
def __init__(self, conn):
self.conn = conn
self.url = conn.getURL().toExternalForm()
fields = self.conn.getHeaderFields()
self.headers = Headers()
for key in fields:
if key != None:
self.headers[key.lower()] = conn.getHeaderField(key)
self.bs = BufferedInputStream(self.conn.getInputStream())
def read(self, *args):
if len(args) == 1:
size = args[0]
buf = zeros(size, 'b')
off = 0
while size > 0:
count = self.bs.read(buf, off, size)
if count == -1:
buf = buf[:off]
break
off += count
size -= count
return buf.tostring()
else:
return self.read(int(self.headers['content-length']))
def info(self):
return Headers(self.headers)
def close(self):
self.bs.close()
class ConnReader:
def __init__(self, conn):
self.conn = conn
self.url = conn.getURL().toExternalForm()
fields = self.conn.getHeaderFields()
self.headers = Headers()
for key in fields:
if key != None:
self.headers[key.lower()] = conn.getHeaderField(key)
self.bs = BufferedInputStream(self.conn.getInputStream())
def read(self, *args):
if len(args) == 1:
size = args[0]
buf = zeros(size, 'b')
off = 0
while size > 0:
count = self.bs.read(buf, off, size)
if count == -1:
buf = buf[:off]
break
off += count
size -= count
return buf.tostring()
else:
return self.read(int(self.headers['content-length']))
def info(self):
return Headers(self.headers)
def close(self):
self.bs.close()
def __init__(self, cmd, capturestderr=0, bufsize=-1):
"""The parameter 'cmd' is the shell command to execute in a
sub-process. Can be either a sequence of executable
and arguments, or a shell command.
The 'capturestderr' flag, if true, specifies that
the object should capture standard error output of the child process.
The default is false. If the 'bufsize' parameter is specified, it
specifies the size of the I/O buffers to/from the child process.
"""
self.process = shellexecute(cmd)
self._tochild = self.process.getOutputStream()
self._fromchild = self.process.getInputStream()
if capturestderr:
self._childerr = self.process.getErrorStream()
else:
self._childerr = None
import threading
self.childWaiterLock = threading.Lock()
if bufsize > 0:
self._tochild = BufferedOutputStream(self._tochild, bufsize)
self._fromchild = BufferedInputStream(self._fromchild, bufsize)
if self._childerr:
self._childerr = BufferedInputStream(self._childerr, bufsize)
self.tochild = PyFile(self._tochild)
self.fromchild = PyFile(self._fromchild)
if self._childerr:
self.childerr = PyFile(self._childerr)
def write(self, archive, path, dest):
archive.putArchiveEntry(ZipArchiveEntry(dest))
input = BufferedInputStream(FileInputStream(path))
IOUtils.copy(input, archive)
input.close()
archive.closeArchiveEntry()
def __init__(self, conn):
self.conn = conn
self.url = conn.getURL().toExternalForm()
fields = self.conn.getHeaderFields()
self.headers = Headers()
for key in fields:
if key != None:
self.headers[key.lower()] = conn.getHeaderField(key)
self.bs = BufferedInputStream(self.conn.getInputStream())
def reset(self):
self.close()
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % self._encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def load_common_properties():
"""Loads common test properties into grinder properties."""
current_dir = os.path.dirname(os.path.abspath(__file__))
file_name = os.path.join(current_dir, PROPERTIES)
source = BufferedInputStream(FileInputStream(file_name))
props = Properties()
props.load(source)
source.close()
for key in props.keySet().iterator():
grinder.properties[key] = props.get(key)
def __init__(self, encoding=ENCODING):
self._depth = 0
self._buffer = ''
self.handler = IncrementalHandler()
self._encoding = encoding
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def loadProperties(self, source):
""" Load a Java properties file into a Dictionary. """
result = {}
# name provided, use file
if type(source) == type(""):
source = FileInputStream(source)
bis = BufferedInputStream(source)
props = jProperties()
props.load(bis)
bis.close()
for key in props.keySet().iterator():
result[key] = props.get(key)
return result
def loadProperties(self, source):
""" Load a Java properties file into a Dictionary. """
result = {}
# name provided, use file
if type(source) == type(''):
source = FileInputStream(source)
bis = BufferedInputStream(source)
props = jProperties()
props.load(bis)
bis.close()
for key in props.keySet().iterator():
result[key] = props.get(key)
return result
def read_entry():
is_ = None
try:
is_ = BufferedInputStream(zip_file.getInputStream(entry))
size = entry.getSize()
data = jarray.zeros(size, 'b')
nread_tot = 0
while nread_tot < size:
nread = is_.read(data, nread_tot, size - nread_tot)
if nread <= 0:
raise java.io.IOException('Read ended prematurely')
nread_tot += nread
return data
finally:
if not is_ is None:
is_.close()
def read_entry():
is_ = None
try:
is_ = BufferedInputStream(zip_file.getInputStream(entry))
size = entry.getSize()
data = jarray.zeros(size, 'b')
nread_tot = 0
while nread_tot < size:
nread = is_.read(data, nread_tot, size-nread_tot)
if nread <= 0:
raise java.io.IOException('Read ended prematurely')
nread_tot += nread
return data
finally:
if not is_ is None:
is_.close()
class SSLSocket(object):
def __init__(self, java_socket, keyfile=None):
self.java_ssl_socket = self._nycs_socket(java_socket, keyfile)
self._in_buf = BufferedInputStream(
self.java_ssl_socket.getInputStream())
self._out_buf = BufferedOutputStream(
self.java_ssl_socket.getOutputStream())
# Not-Yet-Commons-SSL Socket
def _nycs_socket(self, java_socket, keyfile=None):
host = java_socket.getInetAddress().getHostAddress()
port = java_socket.getPort()
client = SSLClient()
client.setCheckHostname(False)
client.setCheckExpiry(False)
client.setCheckCRL(False)
client.setKeyMaterial(KeyMaterial(keyfile, ""))
client.setTrustMaterial(TrustMaterial.TRUST_ALL)
java_ssl_socket = client.createSocket(java_socket, host, port, 0)
java_ssl_socket.startHandshake()
return java_ssl_socket
def recv(self, n=4096):
data = jarray.zeros(n, 'b')
m = self._in_buf.read(data, 0, n)
if m <= 0:
return ""
if m < n:
data = data[:m]
return data.tostring()
def send(self, s):
self._out_buf.write(s)
self._out_buf.flush()
return len(s)
class SSLSocket(object):
def __init__(self, java_socket, keyfile=None):
self.java_ssl_socket = self._nycs_socket(java_socket, keyfile)
self._in_buf = BufferedInputStream(self.java_ssl_socket.getInputStream())
self._out_buf = BufferedOutputStream(self.java_ssl_socket.getOutputStream())
# Not-Yet-Commons-SSL Socket
def _nycs_socket(self, java_socket, keyfile=None):
host = java_socket.getInetAddress().getHostAddress()
port = java_socket.getPort()
client = SSLClient()
client.setCheckHostname(False)
client.setCheckExpiry(False)
client.setCheckCRL(False)
client.setKeyMaterial(KeyMaterial(keyfile, ""))
client.setTrustMaterial(TrustMaterial.TRUST_ALL)
java_ssl_socket = client.createSocket(java_socket, host, port, 0)
java_ssl_socket.startHandshake()
return java_ssl_socket
def recv(self, n=4096):
data = jarray.zeros(n, 'b')
m = self._in_buf.read(data, 0, n)
if m <= 0:
return ""
if m < n:
data = data[:m]
return data.tostring()
def send(self, s):
self._out_buf.write(s)
self._out_buf.flush()
return len(s)
def _load_certificates(self, f):
cf = CertificateFactory.getInstance("X.509")
try:
for cert in cf.generateCertificates(BufferedInputStream(f)):
self._trust_store.setCertificateEntry(str(uuid.uuid4()), cert)
except CertificateParsingException:
log.debug("Failed to parse certificate", exc_info=True)
raise
def __init__(self, conn):
self.conn = conn
self.url = conn.getURL().toExternalForm()
fields = self.conn.getHeaderFields()
self.headers = Headers()
for key in fields:
if key != None:
self.headers[key.lower()] = conn.getHeaderField(key)
self.bs = BufferedInputStream(self.conn.getInputStream())
def _get_ca_certs_trust_manager(ca_certs):
trust_store = KeyStore.getInstance(KeyStore.getDefaultType())
trust_store.load(None, None)
with open(ca_certs) as f:
cf = CertificateFactory.getInstance("X.509")
for cert in cf.generateCertificates(BufferedInputStream(f)):
trust_store.setCertificateEntry(str(uuid.uuid4()), cert)
tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
tmf.init(trust_store)
return tmf
def reset(self):
self.close()
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % self._encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def fetchData(self, place):
url = URL("https://www.yr.no/place/" + place + "/forecast.xml")
connection = CAST(url.openConnection(), HttpURLConnection)
connection.setInstanceFollowRedirects(True)
try:
stream = BufferedInputStream(connection.getInputStream())
except:
return None
return stream
def copy_zip_file(path, output_jar):
try:
with open(path) as f:
with closing(BufferedInputStream(f)) as bis:
if not skip_zip_header(bis):
return False
with closing(ZipInputStream(bis)) as input_zip:
try:
output_jar.copy_zip_input_stream(input_zip, "Lib")
return True
except ZipException:
return False
except IOError:
return False
def _get_ca_certs_trust_manager(ca_certs=None):
trust_store = KeyStore.getInstance(KeyStore.getDefaultType())
trust_store.load(None, None)
num_certs_installed = 0
if ca_certs is not None:
with open(ca_certs) as f:
cf = CertificateFactory.getInstance("X.509")
for cert in cf.generateCertificates(BufferedInputStream(f)):
trust_store.setCertificateEntry(str(uuid.uuid4()), cert)
num_certs_installed += 1
tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
tmf.init(trust_store)
log.debug("Installed %s certificates", num_certs_installed, extra={"sock": "*"})
return tmf
def __init__(self, encoding=ENCODING):
self._depth = 0
self._buffer = ''
self.handler = IncrementalHandler()
self._encoding = encoding
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def copy_file(self, relpath, path):
path_parts = tuple(os.path.split(relpath)[0].split(os.sep))
self.create_ancestry(path_parts)
chunk = jarray.zeros(8192, "b")
with open(path) as f:
with closing(BufferedInputStream(f)) as bis:
output_entry = JarEntry(relpath)
output_entry.time = os.path.getmtime(path) * 1000
self.jar.putNextEntry(output_entry)
while True:
read = bis.read(chunk, 0, 8192)
if read == -1:
break
self.jar.write(chunk, 0, read)
self.jar.closeEntry()
def processResponse(self, response):
#threadContext = HTTPPluginControl.getThreadHTTPClientContext()
#threadContext.resumeClock()
# We just want to read data flow - so we can scale
bodyLength = 0
bin = BufferedInputStream(response.getInputStream())
buf = jarray.zeros(8192, 'b')
lenBuf = 0
while lenBuf != -1:
lenBuf = bin.read(buf)
bodyLength += lenBuf
bin.close()
grinder.getLogger().output("INFO: Download of %d bytes finished" %
(bodyLength))
#threadContext.pauseClock();
# Update statistics with body size
testStatistics = grinder.getStatistics()
if (testStatistics.isTestInProgress()):
testStatistics.getForCurrentTest().addLong(
"httpplugin.responseLength", bodyLength)
def _extract_certs_from_keystore_file(f, password):
keystore = KeyStore.getInstance(KeyStore.getDefaultType())
if password is None: # default java keystore password is changeit
password = '******'
elif not isinstance(password, str):
password = []
keystore.load(BufferedInputStream(f), password)
certs = []
alias_iter = keystore.aliases()
while alias_iter.hasMoreElements():
alias = alias_iter.nextElement()
certs.append(keystore.getCertificate(alias))
return certs
def trustSpecificCertificate(self, pemCertificateFile,
pemCertificateAlias):
from java.io import BufferedInputStream, FileInputStream
from java.security import KeyStore
from java.security.cert import CertificateFactory, X509Certificate
from javax.net.ssl import SSLContext, TrustManagerFactory
fis = FileInputStream(pemCertificateFile)
bis = BufferedInputStream(fis)
ca = CertificateFactory.getInstance("X.509").generateCertificate(bis)
ks = KeyStore.getInstance(KeyStore.getDefaultType())
ks.load(None, None)
ks.setCertificateEntry(pemCertificateAlias, ca)
tmf = TrustManagerFactory.getInstance(
TrustManagerFactory.getDefaultAlgorithm())
tmf.init(ks)
context = SSLContext.getInstance("SSL")
context.init(None, tmf.getTrustManagers(), None)
SSLContext.setDefault(context)
def copy_file(self, relpath, path):
path_parts = tuple(os.path.split(relpath)[0].split(os.sep))
self.create_ancestry(path_parts)
chunk = jarray.zeros(8192, "b")
with open(path) as f:
with closing(BufferedInputStream(f)) as bis:
output_entry = JarEntry(relpath)
output_entry.time = os.path.getmtime(path) * 1000
try:
self.jar.putNextEntry(output_entry)
while True:
read = bis.read(chunk, 0, 8192)
if read == -1:
break
self.jar.write(chunk, 0, read)
self.jar.closeEntry()
except ZipException, e:
if not "duplicate entry" in str(e):
log.error("Problem in creating entry %r", entry, exc_info=True)
raise
class SafeUNIXSocket(object):
def __init__(self, socketpath):
self.sock = AFUNIXSocket.newInstance()
self.sock.connect(AFUNIXSocketAddress(File(socketpath)))
self._in_buf = BufferedInputStream(self.sock.getInputStream())
self._out_buf = BufferedOutputStream(self.sock.getOutputStream())
def recv(self, n=4096):
data = jarray.zeros(n, 'b')
m = self._in_buf.read(data, 0, n)
if m <= 0:
return ""
if m < n:
data = data[:m]
return data.tostring()
def send(self, s):
self._out_buf.write(s)
self._out_buf.flush()
return len(s)
class SafeUNIXSocket(object):
def __init__(self, socketpath):
self.sock = AFUNIXSocket.newInstance()
self.sock.connect(AFUNIXSocketAddress(File(socketpath)))
self._in_buf = BufferedInputStream(self.sock.getInputStream())
self._out_buf = BufferedOutputStream(self.sock.getOutputStream())
def recv(self, n=4096):
data = jarray.zeros(n, 'b')
m = self._in_buf.read(data, 0, n)
if m <= 0:
return ""
if m < n:
data = data[:m]
return data.tostring()
def send(self, s):
self._out_buf.write(s)
self._out_buf.flush()
return len(s)
class IncrementalParser(object):
def __init__(self, encoding=ENCODING):
self._depth = 0
self._buffer = ''
self.handler = IncrementalHandler()
self._encoding = encoding
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def close(self):
self._initialized = False
self.handler.reset()
self._depth = 0
self._buffer = ''
self._fed.close()
self._feeder.close()
self._er.close()
self._sr.close()
def reset(self):
self.close()
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % self._encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def _parse(self, chunk, fragment=False):
if chunk.startswith('<?xml '):
chunk = chunk[chunk.find('?>') + 2:]
if not chunk:
return
self._fed.write(chunk)
er = self._er
consumed = False
while er.hasNext():
if not fragment and self._feeder.available() == 0 and consumed:
break
event = er.next()
etype = event.getEventType()
if etype == XMLEvent.START_ELEMENT:
consumed = False
if not chunk.endswith('/>'):
consumed = True
self._depth += 1
element = event.asStartElement()
self.handler.startElementNS(None, element.getName(),
element.getAttributes())
elif etype == XMLEvent.END_ELEMENT:
consumed = True
self._depth -= 1
element = event.asEndElement()
self.handler.endElementNS(None, element.getName())
if self._depth == 0:
break
elif etype == XMLEvent.CHARACTERS:
consumed = False
self.handler.characters(event.asCharacters().getData())
elif etype == XMLEvent.COMMENT:
consumed = True
self.handler.comment(event.getText())
elif etype == XMLEvent.PROCESSING_INSTRUCTION:
consumed = True
self.handler.processingInstruction(event.getTarget(),
event.getData())
elif etype == XMLEvent.START_DOCUMENT:
self.handler.startDocument()
elif etype == XMLEvent.END_DOCUMENT:
break
def feed(self, chunk):
if not chunk:
return
self._buffer = self._buffer + chunk
pos = posa = 0
posb = -1
last_posb = 0
new_buffer = ''
buf_len = len(self._buffer)
while 1:
found = False
posa = self._buffer.find('<', pos)
if posa > -1:
posb = self._buffer.find('>', posa)
if posb > -1:
found = True
pos = posb
self._parse(self._buffer[last_posb:posb + 1])
last_posb = posb + 1
if not found and posb != buf_len:
break
self._buffer = self._buffer[last_posb:]
class IncrementalParser(object):
def __init__(self, encoding=ENCODING):
self._depth = 0
self._buffer = ''
self.handler = IncrementalHandler()
self._encoding = encoding
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def close(self):
self._initialized = False
self.handler.reset()
self._depth = 0
self._buffer = ''
self._fed.close()
self._feeder.close()
self._er.close()
self._sr.close()
def reset(self):
self.close()
self._fed = PipedOutputStream()
self._feeder = BufferedInputStream(PipedInputStream(self._fed))
self._fed.write('<?xml version="1.0" encoding="%s"?>' % self._encoding)
ipf = XMLInputFactory.newInstance()
ipf.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, True)
self._sr = ipf.createXMLStreamReader(self._feeder)
self._er = ipf.createXMLEventReader(self._sr)
def _parse(self, chunk, fragment=False):
if chunk.startswith('<?xml '):
chunk = chunk[chunk.find('?>')+2:]
if not chunk:
return
self._fed.write(chunk)
er = self._er
consumed = False
while er.hasNext():
if not fragment and self._feeder.available() == 0 and consumed:
break
event = er.next()
etype = event.getEventType()
if etype == XMLEvent.START_ELEMENT:
consumed = False
if not chunk.endswith('/>'):
consumed = True
self._depth += 1
element = event.asStartElement()
self.handler.startElementNS(None, element.getName(), element.getAttributes())
elif etype == XMLEvent.END_ELEMENT:
consumed = True
self._depth -= 1
element = event.asEndElement()
self.handler.endElementNS(None, element.getName())
if self._depth == 0:
break
elif etype == XMLEvent.CHARACTERS:
consumed = False
self.handler.characters(event.asCharacters().getData())
elif etype == XMLEvent.COMMENT:
consumed = True
self.handler.comment(event.getText())
elif etype == XMLEvent.PROCESSING_INSTRUCTION:
consumed = True
self.handler.processingInstruction(event.getTarget(), event.getData())
elif etype == XMLEvent.START_DOCUMENT:
self.handler.startDocument()
elif etype == XMLEvent.END_DOCUMENT:
break
def feed(self, chunk):
if not chunk:
return
self._buffer = self._buffer + chunk
pos = posa = 0
posb = -1
last_posb = 0
new_buffer = ''
buf_len = len(self._buffer)
while 1:
found = False
posa = self._buffer.find('<', pos)
if posa > -1:
posb = self._buffer.find('>', posa)
if posb > -1:
found = True
pos = posb
self._parse(self._buffer[last_posb:posb+1])
last_posb = posb+1
if not found and posb != buf_len:
break
self._buffer = self._buffer[last_posb:]
def __init__(self, socketpath):
self.sock = AFUNIXSocket.newInstance()
self.sock.connect(AFUNIXSocketAddress(File(socketpath)))
self._in_buf = BufferedInputStream(self.sock.getInputStream())
self._out_buf = BufferedOutputStream(self.sock.getOutputStream())
def __init__(self, java_socket, keyfile=None):
self.java_ssl_socket = self._nycs_socket(java_socket, keyfile)
self._in_buf = BufferedInputStream(
self.java_ssl_socket.getInputStream())
self._out_buf = BufferedOutputStream(
self.java_ssl_socket.getOutputStream())
from java.io import File as F
from java.io import FileInputStream as FI
from java.io import FileOutputStream as FO
from java.io import BufferedInputStream as BI
from java.io import BufferedOutputStream as BO
from java.util.zip import InflaterInputStream as II
file_read = F("file5.txt")
file_write = F("file6.txt")
bi = BI(II(FI(file_read)))
bo = BO(FO(file_write))
while True:
val = bi.read()
if val != -1:
bo.write(val)
else:
break
bi.close()
bo.close()
def __init__(self, socketpath):
self.sock = AFUNIXSocket.newInstance()
self.sock.connect(AFUNIXSocketAddress(File(socketpath)))
self._in_buf = BufferedInputStream(self.sock.getInputStream())
self._out_buf = BufferedOutputStream(self.sock.getOutputStream())
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from java.io import BufferedOutputStream as BO
from java.io import BufferedInputStream as BI
from java.io import FileInputStream as FI
from java.io import FileOutputStream as FO
f_read = FI("file1.txt")
b_read = BI(f_read)
f_write = FO("file2.txt")
b_write = BO(f_write)
while True:
ch = b_read.read()
if ch != -1:
b_write.write(ch)
else:
break
b_read.close()
f_read.close()
b_write.close()
f_write.close()
def __init__(self, java_socket, keyfile=None):
self.java_ssl_socket = self._nycs_socket(java_socket, keyfile)
self._in_buf = BufferedInputStream(self.java_ssl_socket.getInputStream())
self._out_buf = BufferedOutputStream(self.java_ssl_socket.getOutputStream())
