def open(self):
if self._active:
nowTime = TimeUtils.getNowSeconds()
if nowTime - self._activatedTime > NimbleEnvironment.CONNECTION_LIFETIME:
self.close()
else:
return False
self._activatedTime = TimeUtils.getNowSeconds()
try:
target = (NimbleEnvironment.getConnectionHost(),
NimbleEnvironment.getConnectionPort())
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Sets socket option to prevent connection being refused by TCP reconnecting
# to the same socket after a recent closure.
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._socket.setblocking(1)
self._socket.connect(target)
except Exception as err:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Failed to open Nimble connection',
err)
return False
if self not in NimbleConnection._CONNECTION_POOL:
NimbleConnection._CONNECTION_POOL.append(self)
self._active = True
return True
def open(self):
if self._active:
nowTime = TimeUtils.getNowSeconds()
if nowTime - self._activatedTime > NimbleEnvironment.CONNECTION_LIFETIME:
self.close()
else:
return False
self._activatedTime = TimeUtils.getNowSeconds()
try:
target = (
NimbleEnvironment.getConnectionHost(),
NimbleEnvironment.getConnectionPort()
)
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Sets socket option to prevent connection being refused by TCP reconnecting
# to the same socket after a recent closure.
self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._socket.setblocking(1)
self._socket.connect(target)
except Exception as err:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Failed to open Nimble connection', err)
return False
if self not in NimbleConnection._CONNECTION_POOL:
NimbleConnection._CONNECTION_POOL.append(self)
self._active = True
return True
def __call__(self, *args, **kwargs):
"""Doc..."""
if self.response is None:
self.response = RemoteScriptResponse()
if self.kwargs is None:
self.kwargs = kwargs
try:
self.run()
except Exception as err:
message = "Nimble remote script run failure"
NimbleEnvironment.logError(message, err)
logMessage = Logger.createErrorMessage(message, err)
self.putErrorResult(Logger.logMessageToString(logMessage=logMessage, includePrefix=False))
result = self.response.result
return result if result else dict()
def __call__(self, *args, **kwargs):
"""Doc..."""
if self.response is None:
self.response = RemoteScriptResponse()
if self.kwargs is None:
self.kwargs = kwargs
try:
self.run()
except Exception as err:
message = u'Nimble remote script run failure'
NimbleEnvironment.logError(message, err)
logMessage = Logger.createErrorMessage(message, err)
self.putErrorResult(
Logger.logMessageToString(logMessage=logMessage,
includePrefix=False))
result = self.response.result
return result if result else dict()
def __init__(self, router =None):
asyncore.dispatcher.__init__(self)
try:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(('localhost', NimbleEnvironment.getServerPort()))
self.listen(5)
except Exception as err:
NimbleEnvironment.logError(
'[ERROR | NIMBLE SERVER] Failed to establish server connection', err)
raise
if router is None:
if NimbleEnvironment.inMaya():
from nimble.connection.router.MayaRouter import MayaRouter
self._router = MayaRouter
else:
self._router = NimbleRouter
else:
self._router = router
def __init__(self, router=None):
asyncore.dispatcher.__init__(self)
try:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((NimbleEnvironment.getServerHost(),
NimbleEnvironment.getServerPort()))
self.listen(5)
except Exception as err:
NimbleEnvironment.logError(
'[ERROR | NIMBLE SERVER] Failed to establish server connection',
err)
raise
if router is None:
if NimbleEnvironment.inMaya():
from nimble.connection.router.MayaRouter import MayaRouter
self._router = MayaRouter
else:
self._router = NimbleRouter
else:
self._router = router
def run(self):
"""Doc..."""
self.saveSelection()
count = self.fetch('count', 1000)
self._size = self.fetch('size', 0.1)
self._padding = self.fetch('padding', 0.0)
transforms = cmds.ls(selection=True, type='transform')
if not transforms:
self._cleanup()
self.putErrorResult(u'ERROR: No transforms selected')
return
shapes = []
totalVolume = 0.0
shapeCount = 0
for transform in transforms:
shapeNames = cmds.listRelatives(transforms, shapes=True)
if not shapeNames:
continue
for shape in shapeNames:
try:
box = TransformUtils.getBoundingBox(shape)
cmds.select(shape, replace=True)
shapeVolume = nimble.executeMelCommand('computePolysetVolume')
totalVolume += shapeVolume
shapes.append(dict(
transform=transform,
name=shape,
box=box,
weight=float(shapeVolume)) )
shapeCount += 1
except Exception as err:
self._cleanup()
NimbleEnvironment.logError(u'ERROR: Shape processing', err)
self.putErrorResult(
u'ERROR: Unable to process selection item %s -> %s' % (transform, shape) )
return
if shapeCount == 0:
self._cleanup()
self.putErrorResult(u'ERROR: No polygon transforms found in selection')
return
try:
for shape in shapes:
if not self._createMeshPointNode(shape):
self._cleanup()
print(u'ERROR: Creation failure')
self.putErrorResult(u'ERROR: Unable to create point test node')
shape['weight'] /= totalVolume
shapeCount = int(round(float(count)*shape['weight']))
for i in range(shapeCount):
self._create(shape)
self._removeMeshPointNode()
except Exception as err:
self._cleanup()
print(Logger.createErrorMessage(u'ERROR: Creation failure', err))
self.putErrorResult(u'ERROR: Unable to create random box')
return
self._cleanup()
def runPythonImport(cls, payload):
try:
kwargs = payload.get('kwargs', {})
targetModule = StringUtils.toStr2(payload.get('module'))
targetMethod = StringUtils.toStr2(payload.get('method'))
targetClass = StringUtils.toStr2(payload.get('class'))
target = targetClass if targetClass is not None else targetMethod
if target is None:
parts = targetModule.rsplit('.', 1)
targetModule = parts[0]
target = parts[1]
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError('\n'.join([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)]), err),
response=NimbleResponseData.FAILED_RESPONSE)
# Dynamically import the specified module and reload it to make sure any changes have
# been updated
try:
module = __import__(
StringUtils.toStr2(targetModule),
globals(), locals(),
[StringUtils.toStr2(target)] if target else [])
reload(module)
target = getattr(module, target)
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to import python target',
'MODULE: %s' % targetModule,
'TARGET: %s' % target,
'PAYLOAD: ' + DictUtils.prettyPrint(payload)], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(
'Failed to import python module', err),
response=NimbleResponseData.FAILED_RESPONSE)
try:
result = dict()
if targetClass is not None:
tc = target()
result = getattr(tc, targetMethod)(**kwargs) \
if targetMethod else \
tc(**kwargs)
elif targetMethod is not None:
result = target(**kwargs)
else:
# Find a NimbleScriptBase derived class definition and if it exists, run it to
# populate the results
for name,value in DictUtils.iter(Reflection.getReflectionDict(target)):
if not inspect.isclass(value):
continue
if NimbleScriptBase in value.__bases__:
result = getattr(target, name)()(**kwargs)
found = True
# If a result dictionary contains an error key format the response as a failure
errorMessage = None
try:
errorMessage = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_ERROR_KEY, None, result)
except Exception as err:
pass
return cls.createReply(DataKindEnum.PYTHON_IMPORT, result, errorMessage=errorMessage)
except Exception as err:
msg = 'ERROR: Failed to execute remote script'
NimbleEnvironment.logError([
msg,
'PAYLOAD: ' + DictUtils.prettyPrint(payload),
'TARGET: ' + str(target)], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(msg, err),
response=NimbleResponseData.FAILED_RESPONSE)
def runPythonImport(cls, payload):
try:
kwargs = payload.get('kwargs', {})
targetModule = StringUtils.toStr2(payload.get('module'))
targetMethod = StringUtils.toStr2(payload.get('method'))
targetClass = StringUtils.toStr2(payload.get('class'))
target = targetClass if targetClass is not None else targetMethod
if target is None:
parts = targetModule.rsplit('.', 1)
targetModule = parts[0]
target = parts[1]
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)
], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(
'\n'.join([
'ERROR: Failed to parse python import payload',
'PAYLOAD: ' + DictUtils.prettyPrint(payload)
]), err),
response=NimbleResponseData.FAILED_RESPONSE)
# Dynamically import the specified module and reload it to make sure any changes have
# been updated
try:
module = __import__(StringUtils.toStr2(targetModule), globals(),
locals(),
[StringUtils.toStr2(target)] if target else [])
reload(module)
target = getattr(module, target)
except Exception as err:
NimbleEnvironment.logError([
'ERROR: Failed to import python target',
'MODULE: %s' % targetModule,
'TARGET: %s' % target,
'PAYLOAD: ' + DictUtils.prettyPrint(payload)
], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError('Failed to import python module',
err),
response=NimbleResponseData.FAILED_RESPONSE)
try:
result = dict()
if targetClass is not None:
tc = target()
result = getattr(tc, targetMethod)(**kwargs) \
if targetMethod else \
tc(**kwargs)
elif targetMethod is not None:
result = target(**kwargs)
else:
# Find a NimbleScriptBase derived class definition and if it exists, run it to
# populate the results
for name, value in DictUtils.iter(
Reflection.getReflectionDict(target)):
if not inspect.isclass(value):
continue
if NimbleScriptBase in value.__bases__:
result = getattr(target, name)()(**kwargs)
found = True
# If a result dictionary contains an error key format the response as a failure
errorMessage = None
try:
errorMessage = ArgsUtils.extract(
NimbleEnvironment.REMOTE_RESULT_ERROR_KEY, None, result)
except Exception as err:
pass
return cls.createReply(DataKindEnum.PYTHON_IMPORT,
result,
errorMessage=errorMessage)
except Exception as err:
msg = 'ERROR: Failed to execute remote script'
NimbleEnvironment.logError([
msg, 'PAYLOAD: ' + DictUtils.prettyPrint(payload),
'TARGET: ' + str(target)
], err)
return NimbleResponseData(
kind=DataKindEnum.PYTHON_IMPORT,
error=cls._getDetailedError(msg, err),
response=NimbleResponseData.FAILED_RESPONSE)
def _sendRemote(self, nimbleData):
responseFlags = 0
message = u''
retry = NimbleEnvironment.REMOTE_RETRY_COUNT
while retry > 0:
try:
self.open()
except Exception as err:
failure = [
'[ERROR | NIMBLE COMMUNICATION] Unable to open connection',
err
]
retry -= 1
if retry == 0:
if not nimble.quietFailure:
NimbleEnvironment.logError(failure[0], failure[1])
return None
continue
try:
serialData = nimbleData.serialize()
except Exception as err:
failure = [
'[ERROR | NIMBLE COMMUNICATION] Unable to serialize data for transmission',
err
]
if not nimble.quietFailure:
NimbleEnvironment.logError(failure[0], failure[1])
return None
try:
self._chunk.clear()
self._chunk.writeUint32(NimbleEnvironment.CONNECTION_FLAGS)
self._chunk.writeString(
serialData + NimbleEnvironment.TERMINATION_IDENTIFIER)
self._socket.sendall(self._chunk.byteArray)
except Exception as err:
failure = [
'[ERROR | NIMBLE COMMUNICATION] Unable to send data', err
]
self.close()
retry -= 1
if retry == 0:
if not nimble.quietFailure:
NimbleEnvironment.logError(failure[0], failure[1])
return None
continue
try:
self._chunk.clear()
b = SocketUtils.receiveInChunks(
self._socket,
chunkSize=NimbleEnvironment.SOCKET_RESPONSE_CHUNK_SIZE)
self._chunk.writeString(b)
self._chunk.position = 0
responseFlags = self._chunk.readUint32()
message = StringUtils.strToUnicode(self._chunk.read(-1))
# Break while loop on successful reading of the result
if message is not None:
break
except Exception as err:
if not nimble.quietFailure:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Unable to read response',
err)
self.close()
return None
try:
if not (responseFlags & ConnectionFlags.KEEP_ALIVE):
self.close()
except Exception as err:
if not nimble.quietFailure:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Unable to close connection',
err)
try:
return NimbleData.fromMessage(message)
except Exception as err:
if not nimble.quietFailure:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Response data parsing failure',
err)
return None
def _sendRemote(self, nimbleData):
responseFlags = 0
message = u''
retry = NimbleEnvironment.REMOTE_RETRY_COUNT
while retry > 0:
try:
self.open()
except Exception as err:
failure = [
'[ERROR | NIMBLE COMMUNICATION] Unable to open connection',
err ]
retry -= 1
if retry == 0:
if not nimble.quietFailure:
NimbleEnvironment.logError(failure[0], failure[1])
return None
continue
try:
serialData = nimbleData.serialize()
except Exception as err:
failure = [
'[ERROR | NIMBLE COMMUNICATION] Unable to serialize data for transmission',
err ]
if not nimble.quietFailure:
NimbleEnvironment.logError(failure[0], failure[1])
return None
try:
self._chunk.clear()
self._chunk.writeUint32(NimbleEnvironment.CONNECTION_FLAGS)
self._chunk.writeString(serialData + NimbleEnvironment.TERMINATION_IDENTIFIER)
self._socket.sendall(self._chunk.byteArray)
except Exception as err:
failure = [
'[ERROR | NIMBLE COMMUNICATION] Unable to send data',
err ]
self.close()
retry -= 1
if retry == 0:
if not nimble.quietFailure:
NimbleEnvironment.logError(failure[0], failure[1])
return None
continue
try:
self._chunk.clear()
b = SocketUtils.receiveInChunks(
self._socket,
chunkSize=NimbleEnvironment.SOCKET_RESPONSE_CHUNK_SIZE)
self._chunk.writeString(b)
self._chunk.position = 0
responseFlags = self._chunk.readUint32()
message = StringUtils.strToUnicode(self._chunk.read(-1))
# Break while loop on successful reading of the result
if message is not None:
break
except Exception as err:
if not nimble.quietFailure:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Unable to read response', err)
self.close()
return None
try:
if not (responseFlags & ConnectionFlags.KEEP_ALIVE):
self.close()
except Exception as err:
if not nimble.quietFailure:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Unable to close connection', err)
try:
return NimbleData.fromMessage(message)
except Exception as err:
if not nimble.quietFailure:
NimbleEnvironment.logError(
'[ERROR | NIMBLE COMMUNICATION] Response data parsing failure', err)
return None
def run(self):
"""Doc..."""
self.saveSelection()
count = self.fetch('count', 1000)
self._size = self.fetch('size', 0.1)
self._padding = self.fetch('padding', 0.0)
transforms = cmds.ls(selection=True, type='transform')
if not transforms:
self._cleanup()
self.putErrorResult(u'ERROR: No transforms selected')
return
shapes = []
totalVolume = 0.0
shapeCount = 0
for transform in transforms:
shapeNames = cmds.listRelatives(transforms, shapes=True)
if not shapeNames:
continue
for shape in shapeNames:
try:
box = TransformUtils.getBoundingBox(shape)
cmds.select(shape, replace=True)
shapeVolume = nimble.executeMelCommand('computePolysetVolume')
totalVolume += shapeVolume
shapes.append(dict(
transform=transform,
name=shape,
box=box,
weight=float(shapeVolume)) )
shapeCount += 1
except Exception as err:
self._cleanup()
NimbleEnvironment.logError(u'ERROR: Shape processing', err)
self.putErrorResult(
u'ERROR: Unable to process selection item %s -> %s' % (transform, shape) )
return
if shapeCount == 0:
self._cleanup()
self.putErrorResult(u'ERROR: No polygon transforms found in selection')
return
try:
for shape in shapes:
if not self._createMeshPointNode(shape):
self._cleanup()
print(u'ERROR: Creation failure')
self.putErrorResult(u'ERROR: Unable to create point test node')
shape['weight'] /= totalVolume
shapeCount = int(round(float(count)*shape['weight']))
for i in range(shapeCount):
self._create(shape)
self._removeMeshPointNode()
except Exception as err:
self._cleanup()
print(Logger.createErrorMessage(u'ERROR: Creation failure', err))
self.putErrorResult(u'ERROR: Unable to create random box')
return
self._cleanup()
