def test_make_synchronized(self):
doneSignal = CountDownLatch(10)
class SynchedRunnable(Runnable):
i = 0
def run(self):
self.i += 1
doneSignal.countDown()
run = synchronize.make_synchronized(run)
runner = SynchedRunnable()
for _ in xrange(10):
Thread(runner).start()
doneSignal. await ()
self.assertEquals(10, runner.i)
class ChildSocket(_socketobject):
def __init__(self):
super(ChildSocket, self).__init__()
self.activity_latch = CountDownLatch(1)
def _unlatch(self):
print "Unlatched"
self.activity_latch.countDown()
def _wait_on_latch(self):
print "Waiting for activity on this child socket"
self.activity_latch.await()
#self.__class__ = _socketobject
print "Latch released"
# FIXME raise exception for accept, listen, bind, connect, connect_ex
# All ops that allow us to characterize the mode of operation of
# this socket as being either Start TLS or SSL when connected
def send(self, data):
print "Child send", data
if self.activity_latch.getCount():
self._post_connect()
self._unlatch()
return super(ChildSocket, self).send(data)
def recv(self, bufsize, flags=0):
print "Child recv", bufsize
if self.activity_latch.getCount():
self._post_connect()
self._unlatch()
return super(ChildSocket, self).recv(bufsize, flags)
# Presumably we would only close/shutdown immediately under exceptional situations;
# regardless release the latch
def close(self):
if self.activity_latch.getCount():
self._post_connect()
self._unlatch()
super(ChildSocket, self).close()
def shutdown(self, how):
if self.activity_latch.getCount():
self._post_connect()
self._unlatch()
super(ChildSocket, self).shutdown(how)
def fetch(self):
""" generated source for method fetch """
totalFetchDataSize = self.calcDataSize(len(self.variables))
if totalFetchDataSize == 0:
raise RuntimeException("no data to fetch")
if totalFetchDataSize > dataSizeLimitForFetch:
raise RuntimeException("exceed the max data limit for fetch")
dataSet = GridDataSet(self.meta)
latch = CountDownLatch(len(self.variables) * self.tRange.getSize() * self.zRange.getSize())
exceptions = ConcurrentLinkedQueue()
counter = AtomicInteger()
taskCount = 0
for variable in variables:
dataSet.addVariable(variable, Grid4D(buffer_, self.meta.getDataType(), self.getOrigin(), self.getShape()))
#
# * not thread-safe
#
while t < tRange.getEnd():
#
# * not thread-safe
#
#
# * not thread-safe
#
while z < zRange.getEnd():
#
# * not thread-safe
#
self.addTask(counter, data, curPos, variable, t, z, latch, exceptions)
curPos += xRange.getSize() * yRange.getSize() * meta.getDataType().getSize()
taskCount += 1
z += 1
t += 1
latch.await()
if not exceptions.isEmpty():
raise exceptions.peek()
if counter.get() != taskCount:
raise RuntimeException("not all task success")
return dataSet
def call(self):
#CountdownLatch
latch = CountDownLatch(1)
#Read History.txt into TextArea
br = BufferedReader(FileReader(self.hist_file))
#Runnable Inner Class
class HistoryTaskRunnable (Runnable):
def __init__(self, textArea, br):
self.textArea = textArea
self.br = br
self.sbf = StringBuffer()
#@Override
def run(self):
while True:
line = self.br.readLine()
if line != None:
self.sbf.append(line + "\n")
# self.textArea.appendText(line + "\n") - Very slow
else:
break
#Add Text to TextArea
self.textArea.setText(self.sbf.toString())
self.textArea.appendText("") #Used to trigger event handler
#Close Buffered Reader
br.close()
#Run Later
Platform.runLater(HistoryTaskRunnable(self.textArea, br))
#Set Starting positions
textArea.setScrollLeft(Double.MAX_VALUE)
textArea.setScrollTop(Double.MAX_VALUE)
#Make the Application Thread wait
latch.await()
def __init__(self):
super(ChildSocket, self).__init__()
self.activity_latch = CountDownLatch(1)
def __init__(self, sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE,
ssl_version=PROTOCOL_SSLv23, ca_certs=None,
do_handshake_on_connect=True, suppress_ragged_eofs=True, npn_protocols=None, ciphers=None,
server_hostname=None, _context=None):
# TODO ^^ handle suppress_ragged_eofs
self.sock = sock
self.do_handshake_on_connect = do_handshake_on_connect
self._sock = sock._sock # the real underlying socket
# FIXME in CPython, a check like so is performed - but this is
# not quite correct, based on tests. We should revisit to see
# if we can make this work as desired.
# if do_handshake_on_connect and self._sock.timeout == 0:
# raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets")
self._connected = False
if _context:
self._context = _context
else:
if server_side and not certfile:
raise ValueError("certfile must be specified for server-side "
"operations")
if keyfile and not certfile:
raise ValueError("certfile must be specified")
if certfile and not keyfile:
keyfile = certfile
self._context = SSLContext(ssl_version)
self._context.verify_mode = cert_reqs
if ca_certs:
self._context.load_verify_locations(ca_certs)
if certfile:
self._context.load_cert_chain(certfile, keyfile)
if npn_protocols:
self._context.set_npn_protocols(npn_protocols)
if ciphers:
self._context.set_ciphers(ciphers)
self.keyfile = keyfile
self.certfile = certfile
self.cert_reqs = cert_reqs
self.ssl_version = ssl_version
self.ca_certs = ca_certs
self.ciphers = ciphers
if sock.getsockopt(SOL_SOCKET, SO_TYPE) != SOCK_STREAM:
raise NotImplementedError("only stream sockets are supported")
if server_side and server_hostname:
raise ValueError("server_hostname can only be specified "
"in client mode")
if self._context.check_hostname and not server_hostname:
raise ValueError("check_hostname requires server_hostname")
self.server_side = server_side
self.server_hostname = server_hostname
self.suppress_ragged_eofs = suppress_ragged_eofs
self.ssl_handler = None
# We use _sslobj here to support the CPython convention that
# an object means we have handshaked. It is used by existing code
# in the wild that looks at this ostensibly internal attribute.
# FIXME CPython uses _sslobj to track the OpenSSL wrapper
# object that's implemented in C, with the following
# properties:
#
# 'cipher', 'compression', 'context', 'do_handshake',
# 'peer_certificate', 'pending', 'read', 'shutdown',
# 'tls_unique_cb', 'version', 'write'
self._sslobj = self # setting to self is not quite right
self.engine = None
if self.do_handshake_on_connect and self._sock.connected:
log.debug("Handshaking socket on connect", extra={"sock": self._sock})
if isinstance(self._sock, ChildSocket):
# Need to handle child sockets differently depending
# on whether the parent socket is wrapped or not.
#
# In either case, we cannot handshake here in this
# thread - it must be done in the child pool and
# before the child is activated.
#
# 1. If wrapped, this is going through SSLSocket.accept
if isinstance(self._sock.parent_socket, SSLSocket):
# already wrapped, via `wrap_child` function a few lines below
log.debug(
"Child socket - will handshake in child loop type=%s parent=%s",
type(self._sock), self._sock.parent_socket,
extra={"sock": self._sock})
self._sock._make_active()
# 2. If not, using code will be calling SSLContext.wrap_socket
# *after* accept from an unwrapped socket
else:
log.debug("Child socket will wrap self with handshake", extra={"sock": self._sock})
setup_handshake_latch = CountDownLatch(1)
def setup_handshake():
handshake_future = self.do_handshake()
setup_handshake_latch.countDown()
return handshake_future
self._sock.ssl_wrap_self = setup_handshake
self._sock._make_active()
setup_handshake_latch.await()
log.debug("Child socket waiting on handshake=%s", self._handshake_future, extra={"sock": self._sock})
self._sock._handle_channel_future(self._handshake_future, "SSL handshake")
else:
self.do_handshake()
if hasattr(self._sock, "accepted_children"):
def wrap_child(child):
log.debug(
"Wrapping child socket - about to handshake! parent=%s",
self._sock, extra={"sock": child})
child._wrapper_socket = self.context.wrap_socket(
_socketobject(_sock=child),
do_handshake_on_connect=self.do_handshake_on_connect,
suppress_ragged_eofs=self.suppress_ragged_eofs,
server_side=True)
if self.do_handshake_on_connect:
# this handshake will be done in the child pool - initChannel will block on it
child._wrapper_socket.do_handshake()
self._sock.ssl_wrap_child_socket = wrap_child
