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 _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 _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 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 __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 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 _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 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 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
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 __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())
