def _register(self, manager):
Module._register(self, manager)
self.port = pydra_settings.PORT
self.node_key = None
#load crypto keys for authentication
self.pub_key, self.priv_key = load_crypto('%s/node.key' % \
pydra_settings.RUNTIME_FILES_DIR)
self.master_pub_key = load_crypto('%s/node.master.key' % \
pydra_settings.RUNTIME_FILES_DIR, create=False, both=False)
self.master = None
def __init__(self):
#locks
self._lock = Lock() #general lock, use when multiple shared resources are touched
self._listeners = {
'MANAGER_INIT':self.connect,
'NODE_CREATED':self.connect_node,
'NODE_UPDATED':self.connect_node,
}
self._interfaces = [
self.connect
]
#load rsa crypto
self.pub_key, self.priv_key = load_crypto('%s/master.key' \
% pydra_settings.RUNTIME_FILES_DIR)
self.rsa_client = RSAClient(self.priv_key, self.pub_key, \
callback=self.init_node)
#connection management
self.connecting = True
self.reconnect_count = 0
self.attempts = None
self.reconnect_call_ID = None
self.host = 'localhost'
def __init__(self, key_size=4096, key=None):
self._registered_interfaces = {}
self.sessions = {}
self.key_size = key_size
key = key if key else '%s/master.key' % pydra_settings.RUNTIME_FILES_DIR
self.pub_key, self.priv_key = load_crypto(key)
self.priv_key_encrypt = self.priv_key.encrypt
def __init__(self):
self._services = [self.get_worker_service]
#locks
self._lock = Lock() #general lock, use when multiple shared resources are touched
#load rsa crypto
self.pub_key, self.priv_key = load_crypto('%s/master.key' % pydra_settings.RUNTIME_FILES_DIR)
def test_load_crypto_key_pair_no_key(self):
"""
verifies that a key will not be created or loaded when there is no
Key file and create flag = False
"""
self.destroy_key_files()
try:
priv = load_crypto(KEY_FILE, False, both=False)
self.assertFalse(priv, 'Private key should not have been created')
finally:
self.destroy_key_files()
def __init__(self):
self._listeners = {"MANAGER_INIT": self.connect, "WORKER_FINISHED": self.disconnect}
self._remotes = [("MASTER", os.getpid)]
self.reconnect_count = 0
self.factory = MasterClientFactory(self.reconnect)
# load crypto for authentication
# workers use the same keys as their parent Node
self.pub_key, self.priv_key = load_crypto("%s/node.key" % pydra_settings.RUNTIME_FILES_DIR)
# self.master_pub_key = load_crypto('./node.key', False, both=False)
self.rsa_client = RSAClient(self.priv_key)
def __init__(self):
self._services = [self.get_worker_service]
self._listeners = {"NODE_INITIALIZED": self.enable_workers, "WORKER_FINISHED": self.remove_worker}
# locks
self._lock = Lock() # general lock, use when multiple shared resources are touched
# load rsa crypto
self.pub_key, self.priv_key = load_crypto("%s/node.key" % pydra_settings.RUNTIME_FILES_DIR)
# setup worker security - using this checker just because we need
# _something_ that returns an avatarID. Its extremely vulnerable
# but thats ok because the real authentication takes place after
# the worker has connected
self.worker_checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
def __init__(self, host='localhost', port=18801, key='./master.key'):
"""
Initialize WebController
:parameters:
host: host of interface
port: port of interface
key: path to key file for authentication [./master.key]
"""
self.host = host
self.port = port
# load rsa crypto
self.pub_key, self.priv_key = load_crypto(key, False)
cj = cookielib.CookieJar()
self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
def test_load_crypto_public_key(self):
"""
verifies that a public key can be loaded
"""
self.destroy_key_files()
try:
# create keys and save the public key
pub, priv = generate_keys(KEY_SIZE)
self.create_key_file(pub)
#get the public key data back
pub_key = load_crypto(KEY_FILE, False, both=False)
priv_key = RSA.construct(priv)
self.verify_keys(pub_key, priv_key)
finally:
self.destroy_key_files()
def _register(self, manager):
InterfaceModule._register(self, manager)
self._services = [self.get_controller_service]
#load rsa crypto
self.pub_key, self.priv_key = load_crypto('%s/master.key' % \
pydra_settings.RUNTIME_FILES_DIR)
self.priv_key_encrypt = self.priv_key.encrypt
# setup security. This just uses a default user/pw
# the real authentication happens after the AMF client connects
self.checker = checkers.InMemoryUsernamePasswordDatabaseDontUse()
self.checker.addUser("controller", "1234")
# Load crypto - The interface runs on the same server as the Master so
# it can use the same key. Theres no way with the AMF interface to
# restrict access to localhost connections only.
self.key_size=4096
def test_load_crypto_key_pair_no_key_create_key(self):
"""
Verifies keypair will be generated and returned when there is
no key and create flag = True
"""
self.destroy_key_files()
try:
pub, priv_key = load_crypto(KEY_FILE, key_size=KEY_SIZE)
self.assert_(pub, 'No public key was returned from load_crypto')
self.assert_(priv_key, 'No private key was returned from load_crypto')
self.assertEqual(len(pub), 2, 'Public key should have 2 integers')
pub_key = RSA.construct(pub)
self.verify_keys(pub_key, priv_key)
finally:
self.destroy_key_files()
def setUp(self):
load_crypto('./keys')
self.api = WebController(key='./keys')
self.api.opener = OpenerProxy()
self.func = WebControllerFunction(self.api, 'method_name')
def setUp(self):
load_crypto('./keys')
