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 _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 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 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 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()
# -*- 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())