def setup():
pm.registerService('apiexceptionsv1', apiexceptionsv1)
pm.registerService('apiexceptionsv2', apiexceptionsv2)
api_tools = APITools()
pm.registerService('apitools', api_tools)
resource_manager_tools = ResourceManagerTools()
pm.registerService('resourcemanagertools', resource_manager_tools)
config = pm.getService("config")
config.install("delegatetools.config_path", "deploy/config.json", "JSON file with configuration data for CH, SA, MA")
config.install("delegatetools.supplemetary_fileds_path", "deploy/supplementary_fields.json", "JSON file with Supplementary Fields for CH, SA, MA",True)
config.install("delegatetools.service_registry_path","deploy/registry.json", "JSON file with Services supported by the registry",True)
config.install("delegatetools.defaults_path", "src/plugins/fedtools/defaults.json", "JSON file with default data for CH, SA, MA", True)
#<UT>
config.install("delegatetools.authz_path", "src/plugins/fedtools/authz.json", "JSON file with mapping between privileges and methods", True)
config.install("delegatetools.roles_path", "src/plugins/fedtools/roles.json", "JSON file with default privileges for CH roles", True)
config.install("delegatetools.trusted_cert_path", "deploy/trusted/certs/", "Path to trusted certificates", True)
config.install("delegatetools.trusted_cert_keys_path", "deploy/trusted/cert_keys", "Path to trusted certificate keys", True)
config.install("delegatetools.trusted_crl_path", "deploy/trusted/crl", "Path to CRLs", True)
delegate_tools = DelegateTools()
pm.registerService('delegatetools', delegate_tools)
def setup():
pm.registerService("geniutil", geniutil)
# view certificates with: openssl x509 -in ca_cert -text -noout
# or use mac osx's Keychain Access (go into "Keychain Access"-Menu and use the Cerificate Assistant)
# infer public key from private key for testing: openssl rsa -in mykey.pem -pubout
# creates a self-signed CA cert including a new key pair
ca_c, ca_pu, ca_pr = geniutil.create_certificate(
"urn:publicid:IDN+eict.de+authority+sa",
is_ca=True,
email="*****@*****.**")
# creates a user cert with a new key pair
u_c, u_pu, u_pr = geniutil.create_certificate(
"urn:publicid:IDN+eict:de+user+tom",
issuer_key=ca_pr,
issuer_cert=ca_c,
email="*****@*****.**")
# creates a user cert with a given public key
u2_c, u2_pu, u2_pr = geniutil.create_certificate(
"urn:publicid:IDN+eict:de+user+manfred",
issuer_key=ca_pr,
issuer_cert=ca_c,
public_key=u_pu,
email="*****@*****.**")
logger.info(">>> CERT <<<\n %s>>> PUB <<<\n %s>>> PRIV <<<\n %s" %
(u2_c, u2_pu, u2_pr))
def setup():
# set up config keys
config = pm.getService('config')
# register xmlrpc endpoint
xmlrpc = pm.getService('xmlrpc')
pgch_handler = PGCHv1Handler()
pgch_delegate = PGCHv1Delegate()
pgch_handler.setDelegate(pgch_delegate)
pgch_handler2 = PGCHv1Handler()
pgch_delegate2 = PGCHv1Delegate()
pgch_handler2.setDelegate(pgch_delegate2)
pgch_handler3 = PGCHv1Handler()
pgch_delegate3 = PGCHv1Delegate()
pgch_handler3.setDelegate(pgch_delegate3)
pm.registerService('pgchv1handler', pgch_handler)
# name, handler, endpoint
xmlrpc.registerXMLRPC('pgch2v1', pgch_handler2, '/PGCH')
xmlrpc.registerXMLRPC('pgch3v1', pgch_handler3, '/PGCH/ch')
xmlrpc.registerXMLRPC('pgchv1', pgch_handler, '/')
def setup():
rest = pm.getService("rest")
opsmon_handler = OpsMonHandler()
pm.registerService("opsmon_handler", opsmon_handler)
rest.registerREST(
"opsmon", OpsMonHandler.handle_opsmon_request, "/info/<variety>/<id>", methods=["GET"], defaults={}
)
def setup():
pm.registerService('apiexceptionsv1', apiexceptionsv1)
pm.registerService('apiexceptionsv2', apiexceptionsv2)
api_tools = APITools()
pm.registerService('apitools', api_tools)
resource_manager_tools = ResourceManagerTools()
pm.registerService('resourcemanagertools', resource_manager_tools)
config = pm.getService("config")
config.install("delegatetools.config_path", "deploy/config.json",
"JSON file with configuration data for CH, SA, MA")
config.install("delegatetools.supplemetary_fileds_path",
"deploy/supplementary_fields.json",
"JSON file with Supplementary Fields for CH, SA, MA", True)
config.install("delegatetools.service_registry_path",
"deploy/registry.json",
"JSON file with Services supported by the registry", True)
config.install("delegatetools.defaults_path",
"src/plugins/fedtools/defaults.json",
"JSON file with default data for CH, SA, MA", True)
delegate_tools = DelegateTools()
pm.registerService('delegatetools', delegate_tools)
def setup():
# setup config keys
config = pm.getService("config")
config.install("opennaas.db_dir", "/opt/amsoil", "(Sqlite) database directory")
config.install("opennaas.db_dump_stat", False, "(Sqlite) database dump statements")
config.install("opennaas.reservation_timeout", 600, "Reservation timeout (minutes)")
config.install("opennaas.server_address", "localhost", "OpenNaas server address")
config.install("opennaas.server_port", 8888, "OpenNaas server port")
config.install("opennaas.user", "admin", "OpenNaas user")
config.install("opennaas.password", "123456", "OpenNaas password")
config.install("opennaas.update_timeout", 5, "Update resources timeout (secs)")
config.install("opennaas.update_step", 100, "Update resources step")
config.install("opennaas.check_expire_timeout", 60, "Check resources expiration timeout (secs)")
config.install("opennaas.check_credentials", False, "Check credentials for incoming requests")
# resource manager
import resourceexceptions as ons_exceptions_package
pm.registerService('opennaas_exceptions', ons_exceptions_package)
import models as ons_models_package
pm.registerService('opennaas_models', ons_models_package)
import commandsmanager as ons_commands_mngr_package
pm.registerService('opennaas_commands', ons_commands_mngr_package)
import fsmmanager as ons_fsm_mngr_package
pm.registerService('opennaas_fsm', ons_fsm_mngr_package)
from resourcemanager import RMRoadmManager
pm.registerService('opennaas_resourcemanager', RMRoadmManager())
# delegate
from geni3delegate import OpenNaasGENI3Delegate
handler = pm.getService('geniv3handler')
handler.setDelegate(OpenNaasGENI3Delegate())
def setup():
# setup config items
config = pm.getService("config")
config.install("worker.dbpath", "deploy/worker.db", "Path to the worker's database (if relative, AMsoil's root will be assumed).")
import workers as worker_package
pm.registerService('worker', worker_package)
def setup():
config = pm.getService("config")
config.install("schedule.dbpath", "deploy/schedule.db", "Path to the schedule database (if relative, AMsoil's root will be assumed as base).")
from schedulep import Schedule
pm.registerService('schedule', Schedule)
import scheduleexceptions as exceptions_package
pm.registerService('scheduleexceptions', exceptions_package)
def setup():
rest = pm.getService("rest")
opsmon_handler = OpsMonHandler()
pm.registerService('opsmon_handler', opsmon_handler)
rest.registerREST('opsmon',
OpsMonHandler.handle_opsmon_request,
'/info/<variety>/<id>',
methods=["GET"],
defaults={})
def setup():
cs_handler = CSv1Handler()
pm.registerService('csv1handler', cs_handler)
cs_delegate = CSv1Delegate()
cs_handler.setDelegate(cs_delegate)
cs_guard = CSv1Guard() # For speaks-for
cs_handler.setGuard(cs_guard)
xmlrpc = pm.getService('xmlrpc')
xmlrpc.registerXMLRPC('cs1', cs_handler, '/CS')
def setup():
log_handler = Loggingv1Handler()
pm.registerService('loggingv1handler', log_handler)
log_delegate = Loggingv1Delegate()
log_handler.setDelegate(log_delegate)
log_guard = Loggingv1Guard()
log_handler.setGuard(log_guard)
xmlrpc = pm.getService('xmlrpc')
xmlrpc.registerXMLRPC('log1', log_handler, '/LOG')
def setup():
log_handler = Loggingv1Handler()
pm.registerService('loggingv1handler', log_handler)
log_delegate = Loggingv1Delegate()
log_handler.setDelegate(log_delegate)
log_guard = Loggingv1Guard()
log_handler.setGuard(log_guard)
xmlrpc = pm.getService('xmlrpc')
xmlrpc.registerXMLRPC('log1', log_handler, '/LOG')
def setup():
# setup config keys
config = pm.getService("config")
config.install("dhcprm.max_reservation_duration", 10*60, "Maximum duration a DHCP resource can be held allocated (not provisioned).")
config.install("dhcprm.max_lease_duration", 24*60*60, "Maximum duration DHCP lease can be provisioned.")
config.install("dhcprm.dbpath", "deploy/dhcp.db", "Path to the dhcp database (if relative, AMsoil's root will be assumed).")
from dhcpresourcemanager import DHCPResourceManager
import dhcpexceptions as exceptions_package
rm = DHCPResourceManager()
pm.registerService('dhcpresourcemanager', rm)
pm.registerService('dhcpexceptions', exceptions_package)
def setup():
cs_handler = CSv1Handler()
pm.registerService('csv1handler', cs_handler)
cs_delegate = CSv1Delegate()
cs_handler.setDelegate(cs_delegate)
cs_guard = CSv1Guard() # For speaks-for
cs_handler.setGuard(cs_guard)
xmlrpc = pm.getService('xmlrpc')
xmlrpc.registerXMLRPC('cs1', cs_handler, '/CS')
def setup():
config = pm.getService("config")
# create default configurations (if they are not already in the database)
config.install("flask.bind", "0.0.0.0", "IP to bind the Flask RPC to.")
config.install("flask.fcgi_port", 9001, "Port to bind the Flask RPC to (FCGI server).")
config.install("flask.app_port", 8001, "Port to bind the Flask RPC to (standalone server).")
config.install("flask.debug", True, "Write logging messages for the Flask RPC server.")
config.install("flask.fcgi", False, "Use FCGI server instead of the development server.")
# create and register the RPC server
flaskserver = FlaskServer()
pm.registerService('rpcserver', flaskserver)
# create and register the XML-RPC server
xmlrpc = FlaskXMLRPC(flaskserver)
pm.registerService('xmlrpc', xmlrpc)
def setup():
# setup config keys
config = pm.getService("config")
# TODO: Vanno decise i tempi di allocazione di un allocate.
config.install("dhcprm.max_reservation_duration", 10 * 60, "Maximum duration a DHCP resource can be held allocated (not provisioned).")
config.install("dhcprm.max_lease_duration", 24 * 60 * 60, "Maximum duration DHCP lease can be provisioned.")
config.install("aggregate.dbpath", "deploy/aggregate.db", "Path to the database")
# config.install("dhcprm.dbpath", "deploy/dhcp.db", "Path to the dhcp database (if relative, AMsoil's root will be assumed).")
from islandresourcemanager import islandResourceManager
rm = islandResourceManager()
pm.registerService('islandresourcemanager', rm)
import islandrmexceptions as exceptions_package
pm.registerService('islandrmexceptions', exceptions_package)
def setup():
pm.registerService("geniutil", geniutil)
# view certificates with: openssl x509 -in ca_cert -text -noout
# or use mac osx's Keychain Access (go into "Keychain Access"-Menu and use the Cerificate Assistant)
# infer public key from private key for testing: openssl rsa -in mykey.pem -pubout
# creates a self-signed CA cert including a new key pair
ca_c,ca_pu,ca_pr = geniutil.create_certificate("urn:publicid:IDN+eict.de+authority+sa", is_ca=True, email="*****@*****.**")
# creates a user cert with a new key pair
u_c,u_pu,u_pr = geniutil.create_certificate("urn:publicid:IDN+eict:de+user+tom", issuer_key=ca_pr, issuer_cert=ca_c, email="*****@*****.**")
# creates a user cert with a given public key
u2_c,u2_pu,u2_pr = geniutil.create_certificate("urn:publicid:IDN+eict:de+user+manfred", issuer_key=ca_pr, issuer_cert=ca_c, public_key=u_pu, email="*****@*****.**")
logger.info(">>> CERT <<<\n %s>>> PUB <<<\n %s>>> PRIV <<<\n %s" % (u2_c,u2_pu,u2_pr))
def setup():
config = pm.getService("config")
# create default configurations (if they are not already in the database)
config.install("flask.bind", "0.0.0.0", "IP to bind the Flask RPC to.")
config.install("flask.hostname", _get_hostname(config.get('flask.bind')), "Hostname of Flask RPC server.")
config.install("flask.fcgi_port", 9001, "Port to bind the Flask RPC to (FCGI server).")
config.install("flask.app_port", 8001, "Port to bind the Flask RPC to (standalone server).")
config.install("flask.debug", True, "Write logging messages for the Flask RPC server.")
config.install("flask.fcgi", False, "Use FCGI server instead of the development server.")
config.install("flask.force_client_cert", True, "Only applies if flask.debug is set: Determines if the client _must_ present a certificate. No validation is performed.")
# create and register the RPC server
flaskserver = FlaskServer()
pm.registerService('rpcserver', flaskserver)
# create and register the XML-RPC server
xmlrpc = FlaskXMLRPC(flaskserver)
pm.registerService('xmlrpc', xmlrpc)
def setup():
config = pm.getService("config")
# create default configurations (if they are not already in the database)
config.install("flask.bind", "0.0.0.0", "IP to bind the Flask RPC to.")
config.install("flask.fcgi_port", 9001, "Port to bind the Flask RPC to (FCGI server).")
config.install("flask.app_port", 8001, "Port to bind the Flask RPC to (standalone server).")
config.install("flask.debug", True, "Write logging messages for the Flask RPC server.")
config.install("flask.fcgi", False, "Use FCGI server instead of the development server.")
config.install("flask.force_client_cert", True, "Only applies if flask.debug is set: Determines if the client _must_ present a certificate. No validation is performed.")
# create and register the RPC server
flaskserver = FlaskServer()
pm.registerService('rpcserver', flaskserver)
# create and register the XML-RPC server
xmlrpc = FlaskXMLRPC(flaskserver)
pm.registerService('xmlrpc', xmlrpc)
def setup():
# setup config keys
config = pm.getService("config")
config.install(
"dhcprm.max_reservation_duration", 10 * 60,
"Maximum duration a DHCP resource can be held allocated (not provisioned)."
)
config.install("dhcprm.max_lease_duration", 24 * 60 * 60,
"Maximum duration DHCP lease can be provisioned.")
config.install(
"dhcprm.dbpath", "deploy/dhcp.db",
"Path to the dhcp database (if relative, AMsoil's root will be assumed)."
)
from dhcpresourcemanager import DHCPResourceManager
import dhcpexceptions as exceptions_package
rm = DHCPResourceManager()
pm.registerService('dhcpresourcemanager', rm)
pm.registerService('dhcpexceptions', exceptions_package)
def setup():
db_engine = CHDatabaseEngine()
pm.registerService("chdbengine", db_engine)
# delegate = CHv1Implementation()
delegate = CHv1PersistentImplementation()
guard = CHv1Guard()
handler = pm.getService("chv1handler")
handler.setDelegate(delegate)
sr_handler = SRv1Handler()
pm.registerService("srv1handler", sr_handler)
sr_delegate = SRv1Delegate()
sr_handler.setDelegate(sr_delegate)
xmlrpc = pm.getService("xmlrpc")
xmlrpc.registerXMLRPC("sr1", sr_handler, "/SR")
def setup():
db_engine = CHDatabaseEngine()
pm.registerService('chdbengine', db_engine)
# delegate = CHv1Implementation()
delegate = CHv1PersistentImplementation()
guard = CHv1Guard()
handler = pm.getService('chv1handler')
handler.setDelegate(delegate)
sr_handler = SRv1Handler()
pm.registerService('srv1handler', sr_handler)
sr_delegate = SRv1Delegate()
sr_handler.setDelegate(sr_delegate)
xmlrpc = pm.getService('xmlrpc')
xmlrpc.registerXMLRPC('sr1', sr_handler, '/SR')
def setup():
db_engine = CHDatabaseEngine()
pm.registerService('chdbengine', db_engine)
# delegate = CHv1Implementation()
delegate = CHv1PersistentImplementation()
guard = CHv1Guard()
handler = pm.getService('chv1handler')
handler.setDelegate(delegate)
sr_handler = SRv1Handler()
pm.registerService('srv1handler', sr_handler)
sr_delegate = SRv1Delegate()
sr_handler.setDelegate(sr_delegate)
xmlrpc = pm.getService('xmlrpc')
xmlrpc.registerXMLRPC('sr1', sr_handler, '/SR')
def setup():
pm.registerService('apiexceptionsv1', apiexceptionsv1)
pm.registerService('apiexceptionsv2', apiexceptionsv2)
api_tools = APITools()
pm.registerService('apitools', api_tools)
resource_manager_tools = ResourceManagerTools()
pm.registerService('resourcemanagertools', resource_manager_tools)
config = pm.getService("config")
config.install("delegatetools.config_path", "deploy/config.json",
"JSON file with configuration data for CH, SA, MA")
config.install("delegatetools.supplemetary_fileds_path",
"deploy/supplementary_fields.json",
"JSON file with Supplementary Fields for CH, SA, MA", True)
config.install("delegatetools.service_registry_path",
"deploy/registry.json",
"JSON file with Services supported by the registry", True)
config.install("delegatetools.defaults_path",
"src/plugins/fedtools/defaults.json",
"JSON file with default data for CH, SA, MA", True)
#<UT>
config.install("delegatetools.authz_path",
"src/plugins/fedtools/authz.json",
"JSON file with mapping between privileges and methods",
True)
config.install("delegatetools.roles_path",
"src/plugins/fedtools/roles.json",
"JSON file with default privileges for CH roles", True)
config.install("delegatetools.trusted_cert_path", "deploy/trusted/certs/",
"Path to trusted certificates", True)
config.install("delegatetools.trusted_cert_keys_path",
"deploy/trusted/cert_keys",
"Path to trusted certificate keys", True)
config.install("delegatetools.trusted_crl_path", "deploy/trusted/crl",
"Path to CRLs", True)
delegate_tools = DelegateTools()
pm.registerService('delegatetools', delegate_tools)
def setup():
# setup config keys
config = pm.getService("config")
# TODO: Vanno decise i tempi di allocazione di un allocate.
config.install(
"dhcprm.max_reservation_duration", 10 * 60,
"Maximum duration a DHCP resource can be held allocated (not provisioned)."
)
config.install("dhcprm.max_lease_duration", 24 * 60 * 60,
"Maximum duration DHCP lease can be provisioned.")
config.install("aggregate.dbpath", "deploy/aggregate.db",
"Path to the database")
# config.install("dhcprm.dbpath", "deploy/dhcp.db", "Path to the dhcp database (if relative, AMsoil's root will be assumed).")
from islandresourcemanager import islandResourceManager
rm = islandResourceManager()
pm.registerService('islandresourcemanager', rm)
import islandrmexceptions as exceptions_package
pm.registerService('islandrmexceptions', exceptions_package)
def setup():
config = pm.getService("config")
# create default configurations (if they are not already in the database)
config.install("flask.bind", "0.0.0.0", "IP to bind the Flask RPC to.")
config.install("flask.fcgi_port", 9001,
"Port to bind the Flask RPC to (FCGI server).")
config.install("flask.app_port", 8001,
"Port to bind the Flask RPC to (standalone server).")
config.install("flask.debug", True,
"Write logging messages for the Flask RPC server.")
config.install("flask.fcgi", False,
"Use FCGI server instead of the development server.")
config.install(
"flask.debug.client_cert_file", '~/.gcf/alice-cert.pem',
"Only if FCGI off and debug on: The debug-server can not receive client certificates, this file is then taken for each incoming request."
)
# create and register the RPC server
flaskserver = FlaskServer()
pm.registerService('rpcserver', flaskserver)
# create and register the XML-RPC server
xmlrpc = FlaskXMLRPC(flaskserver)
pm.registerService('xmlrpc', xmlrpc)
def setup():
# setup config keys
config = pm.getService("config")
config.install("geniv3rpc.cert_root", "deploy/trusted", "Folder which includes trusted clearinghouse certificates for GENI API v3 (in .pem format). If relative path, the root is assumed to be git repo root.")
config.install("geniv3rpc.rspec_validation", True, "Determines if RSpec shall be validated by the given xs:schemaLocations in the document (may cause downloads of the given schema from the given URL per request).")
# register xmlrpc endpoint
xmlrpc = pm.getService('xmlrpc')
geni_handler = GENIv3Handler()
pm.registerService('geniv3handler', geni_handler)
pm.registerService('geniv3delegatebase', GENIv3DelegateBase)
pm.registerService('geniv3exceptions', geni_exceptions)
xmlrpc.registerXMLRPC('geni3', geni_handler, '/RPC2') # name, handlerObj, endpoint
def setup():
# setup config keys
config = pm.getService("config")
config.install(
"geniv3rpc.cert_root", "deploy/trusted",
"Folder which includes trusted clearinghouse certificates for GENI API v3 (in .pem format). If relative path, the root is assumed to be git repo root."
)
config.install(
"geniv3rpc.rspec_validation", True,
"Determines if RSpec shall be validated by the given xs:schemaLocations in the document (may cause downloads of the given schema from the given URL per request)."
)
# register xmlrpc endpoint
xmlrpc = pm.getService('xmlrpc')
geni_handler = GENIv3Handler()
pm.registerService('geniv3handler', geni_handler)
pm.registerService('geniv3delegatebase', GENIv3DelegateBase)
pm.registerService('geniv3exceptions', geni_exceptions)
xmlrpc.registerXMLRPC('geni3', geni_handler,
'/RPC2') # name, handlerObj, endpoint
def setup():
# setup config keys
config = pm.getService('config')
config.install('opennaas.server_address', 'localhost', 'OpenNaas server address.')
config.install('opennaas.server_port', 8888, 'OpenNaas server port.')
config.install('opennaas.user', 'admin', 'OpenNaas user.')
config.install('opennaas.password', '123456', 'OpenNaas password.')
config.install('opennaas.provisionMaxTimeout', 300 * 60, 'Provision timeout (5 hours).')
config.install('opennaas.allocationMaxTimeout', 120 * 60, 'Allocation timeout (2 hours).')
config.install('opennaas.dbpath', 'deploy/opennaas.db', 'Path to the opennaas database (if relative, root will be assumed).')
from opennaasresourcemanager import OPENNAASResourceManager
import opennaasexceptions as exceptions_package
import commandsmanager as commands
rm = OPENNAASResourceManager()
pm.registerService('opennaasresourcemanager', rm)
pm.registerService('opennaasexceptions', exceptions_package)
pm.registerService('opennaas_commands', commands)
def setup():
# load all the parameter values into the config database
set_parameters()
# Configure logging
configure_logging()
# register xmlrpc endpoint
xmlrpc = pm.getService('xmlrpc')
# Invoke the CH, SA and MA and set them with default/dummy
# guards and delegates
# Subsequent plugins should replace these with proper guard and delegate
# implementations
ch_handler = CHv1Handler()
ch_delegate = CHv1DelegateBase()
ch_guard = GuardBase()
ch_handler.setDelegate(ch_delegate)
ch_handler.setGuard(ch_guard)
pm.registerService('chv1handler', ch_handler)
xmlrpc.registerXMLRPC('ch1', ch_handler,
'/CH') # name, handlerObj, endpoint
sa_handler = SAv1Handler()
sa_delegate = SAv1DelegateBase()
sa_guard = GuardBase()
sa_handler.setDelegate(sa_delegate)
sa_handler.setGuard(sa_guard)
pm.registerService('sav1handler', sa_handler)
xmlrpc.registerXMLRPC('sa1', sa_handler,
'/SA') # name, handlerObj, endpoint
ma_handler = MAv1Handler()
ma_delegate = MAv1DelegateBase()
ma_guard = GuardBase()
ma_handler.setDelegate(ma_delegate)
ma_handler.setGuard(ma_guard)
pm.registerService('mav1handler', ma_handler)
xmlrpc.registerXMLRPC('ma1', ma_handler,
'/MA') # name, handlerObj, endpoint
def setup():
# load all the parameter values into the config database
set_parameters()
# Configure logging
configure_logging()
# register xmlrpc endpoint
xmlrpc = pm.getService('xmlrpc')
# Invoke the CH, SA and MA and set them with default/dummy
# guards and delegates
# Subsequent plugins should replace these with proper guard and delegate
# implementations
ch_handler = CHv1Handler()
ch_delegate = CHv1DelegateBase()
ch_guard = GuardBase()
ch_handler.setDelegate(ch_delegate)
ch_handler.setGuard(ch_guard)
pm.registerService('chv1handler', ch_handler)
xmlrpc.registerXMLRPC('ch1', ch_handler, '/CH') # name, handlerObj, endpoint
sa_handler = SAv1Handler()
sa_delegate = SAv1DelegateBase()
sa_guard = GuardBase()
sa_handler.setDelegate(sa_delegate)
sa_handler.setGuard(sa_guard)
pm.registerService('sav1handler', sa_handler)
xmlrpc.registerXMLRPC('sa1', sa_handler, '/SA') # name, handlerObj, endpoint
ma_handler = MAv1Handler()
ma_delegate = MAv1DelegateBase()
ma_guard = GuardBase()
ma_handler.setDelegate(ma_delegate)
ma_handler.setGuard(ma_guard)
pm.registerService('mav1handler', ma_handler)
xmlrpc.registerXMLRPC('ma1', ma_handler, '/MA') # name, handlerObj, endpoint
def setup():
handler = NETCONF_Handler()
print pm.registerService('netconfrpc', handler)
def setup():
handler = jsonrpcserver
pm.registerService('jsonrpc', handler)
def setup():
flask_server = pm.getService('rpcserver')
flask_rest = FlaskREST(flask_server)
pm.registerService('rest', flask_rest)
def setup():
pm.registerService("geniutil", geniutil)
def setup():
pm.registerService('gfedv1exceptions', gfed_exceptions)
xmlrpc = pm.getService('xmlrpc')
_api_tools = pm.getService('apitools')
greg_handler = GRegistryv1Handler()
pm.registerService('gregistryv1handler', greg_handler)
pm.registerService('gregistryv1delegatebase', GRegistryv1DelegateBase)
xmlrpc.registerXMLRPC('greg', greg_handler,
'/reg/1') # name, handlerObj, endpoint
_api_tools.register_endpoint(name='gregv1',
type='reg',
version='1',
url='/reg/1')
gma_handler = GMAv1Handler()
pm.registerService('gmav1handler', gma_handler)
pm.registerService('gmav1delegatebase', GMAv1DelegateBase)
xmlrpc.registerXMLRPC('gma', gma_handler,
'/ma/1') # name, handlerObj, endpoint
_api_tools.register_endpoint(name='gmav1',
type='ma',
version='1',
url='/ma/1')
gsa_handler = GSAv1Handler()
pm.registerService('gsav1handler', gsa_handler)
pm.registerService('gsav1delegatebase', GSAv1DelegateBase)
xmlrpc.registerXMLRPC('gsav1', gsa_handler,
'/sa/1') # name, handlerObj, endpoint
_api_tools.register_endpoint(name='gsav1',
type='sa',
version='1',
url='/sa/1')
def setup():
pm.registerService('gfedv1exceptions', gfed_exceptions)
xmlrpc = pm.getService('xmlrpc')
_api_tools = pm.getService('apitools')
greg_handler = GRegistryv1Handler()
pm.registerService('gregistryv1handler', greg_handler)
pm.registerService('gregistryv1delegatebase', GRegistryv1DelegateBase)
xmlrpc.registerXMLRPC('greg', greg_handler, '/reg/1') # name, handlerObj, endpoint
_api_tools.register_endpoint(name='gregv1', type='reg', version='1', url='/reg/1')
gma_handler = GMAv1Handler()
pm.registerService('gmav1handler', gma_handler)
pm.registerService('gmav1delegatebase', GMAv1DelegateBase)
xmlrpc.registerXMLRPC('gma', gma_handler, '/ma/1') # name, handlerObj, endpoint
_api_tools.register_endpoint(name='gmav1', type='ma', version='1', url='/ma/1')
gsa_handler = GSAv1Handler()
pm.registerService('gsav1handler', gsa_handler)
pm.registerService('gsav1delegatebase', GSAv1DelegateBase)
xmlrpc.registerXMLRPC('gsav1', gsa_handler, '/sa/1') # name, handlerObj, endpoint
_api_tools.register_endpoint(name='gsav1', type='sa', version='1', url='/sa/1')
def setup():
reg_rm = ORegistryResourceManager()
pm.registerService('oregistryrm', reg_rm)
pm.registerService('oregistryexceptions', oregistryexceptions)
def setup():
import amconfigdb
import amconfigdbexceptions
pm.registerService("config", amconfigdb.ConfigDB())
pm.registerService("configexceptions", amconfigdbexceptions)
def setup():
mongo_database = MongoDB(db_ip, db_port, db_name)
pm.registerService('mongodb', mongo_database)
def setup():
from emailer import Mailer
pm.registerService('mailer', Mailer)
def setup():
reg_rm = ORegistryResourceManager()
pm.registerService('oregistryrm', reg_rm)
pm.registerService('oregistryexceptions', oregistryexceptions)
def setup():
sa_rm = OSliceAuthorityResourceManager()
pm.registerService('osliceauthorityrm', sa_rm)
pm.registerService('osliceauthorityexceptions', osliceauthorityexceptions)
def setup():
resource_manger = NETCONFResourceManager()
pm.registerService('netconfrm', resource_manger)
def setup():
pm.registerService("geniutil", geniutil)
# view certificates with: openssl x509 -in ca_cert -text -noout
# or use mac osx's Keychain Access (go into "Keychain Access"-Menu and use the Cerificate Assistant)
# infer public key from private key for testing: openssl rsa -in mykey.pem -pubout
# # creates a self-signed CA cert including a new key pair
# ca_c,ca_pu,ca_pr = geniutil.create_certificate("urn:publicid:IDN+eict.de+authority+sa", is_ca=True, email="*****@*****.**")
#
# # creates a user cert with a new key pair
# u_c,u_pu,u_pr = geniutil.create_certificate("urn:publicid:IDN+eict:de+user+tom", issuer_key=ca_pr, issuer_cert=ca_c, email="*****@*****.**")
#
# # creates a user cert with a given public key
# u2_c,u2_pu,u2_pr = geniutil.create_certificate("urn:publicid:IDN+eict:de+user+manfred", issuer_key=ca_pr, issuer_cert=ca_c, public_key=u_pu, email="*****@*****.**")
#
# logger.info(">>> CERT <<<\n %s>>> PUB <<<\n %s>>> PRIV <<<\n %s" % (u2_c,u2_pu,u2_pr))
# import ext.geni
# from ext.geni.util import cert_util as gcf_cert_util
#
# # setup config items
# # config = pm.getService("config")
# # config.install("worker.dbpath", "deploy/worker.db", "Path to the worker's database (if relative, AMsoil's root will be assumed).")
#
# TMP_PATH = '/Users/motine/Documents/Ofelia/devel/test/cert' # I dont want to use tempfile, so I can look at the files (need persistant files)
# import os.path
#
# # TEST: create key-pair
# from ext.sfa.trust.certificate import Keypair
# kp = Keypair()
# kp.create()
# kp.load_from_file() # from pem
# kp.save_to_file() # as pem
# kp.load_from_string() # from pem
# logger.info("private key PEM: %s" % (kp.as_pem(),))
# logger.info("public key DER: %s" % (kp.get_pubkey_string(),))
#
# # TEST: load key-pair
#
# # --------------------------------------------------
# # create a self signed CA cert
# ca_gid, ca_keys = gcf_cert_util.create_cert("urn:publicid:IDN+eict.de+authority+sa", ca=True, email="*****@*****.**");
# logger.info("CA private key PEM: %s" % (ca_keys.as_pem(),))
# logger.info("CA CRT: %s" % (ca_gid.save_to_string(),))
# ca_keys.save_to_file(os.path.join(TMP_PATH, 'ca_key.pem'))
# ca_gid.save_to_file(os.path.join(TMP_PATH, 'ca_cert.crt'))
#
#
# # --------------------------------------------------
# # TEST: create user cert signed by a CA cert (incl. a new keypair)
#
# user_gid, user_keys = gcf_cert_util.create_cert("urn:publicid:IDN+eict.de+user+motine", issuer_key=ca_keys, issuer_cert=ca_gid, email="*****@*****.**");
# user_keys.save_to_file(os.path.join(TMP_PATH, 'user_key.pem'))
# user_gid.save_to_file(os.path.join(TMP_PATH, 'user_cert.crt')) # this includes the parents
#
# # write the public key out (needed for the next use case)
# user_pub_key = user_keys.get_m2_pkey().get_rsa().pem() # or user_gid.get_pubkey()
# with open(os.path.join(TMP_PATH, 'user_pub_key.pem'), 'w') as f:
# f.write(user_pub_key)
#
# # TEST: create user cert signed by a CA cert (with existing keypair)
#
# user2_gid, user2_keys = gcf_cert_util.create_cert("urn:publicid:IDN+eict.de+user+motine", issuer_key=ca_keys, issuer_cert=ca_gid, public_key=os.path.join(TMP_PATH, 'user_key.pub'), email="*****@*****.**");
# user2_keys.save_to_file(os.path.join(TMP_PATH, 'user2_key.pem'))
# user2_gid.save_to_file(os.path.join(TMP_PATH, 'user2_cert.crt')) # this includes the parents
# --------------------------------------------------
# Notes
# slice_gid = cert_util.create_cert(urn, self.keyfile, self.certfile, uuidarg = slice_uuid)[0]
# def create_cert(urn, issuer_key=None, issuer_cert=None, ca=False,
# public_key=None, lifeDays=1825, email=None, uuidarg=None):
# issuer_key can either be a string (filename) or a Keypair
# issuer_certfile can either be a string (filename) or a GID
# public_key contains the entity to sign. If None a new key is created, otherwise it must be a string)
# --------------------------------------------------
# create two users from different CAs
# then verify these (one should fail, one should succeed)
# TEST: get root certs
# self.trusted_root_files = cred_util.CredentialVerifier(ca_certs).root_cert_files
# TEST: load cert from file
# TEST: create user cred (see ch.py)
# TEST: create slice cred (see ch.py)
# please see ca.py
# TEST: extract info from cert
# see GID
# TEST: verify cert against a trusted root
# see GID verify chain
# # get the cert_root
# config = pm.getService("config")
# cert_root = expand_amsoil_path(config.get("geniv3rpc.cert_root"))
# TEST: create cred
# TEST: extract individual entries in cred
# TEST: verify cred against a trusted root
# client_cert = cred.Credential(string=geni_credentials[0]).gidCaller.save_to_string(save_parents=True)
# try:
# cred_verifier = ext.geni.CredentialVerifier(cert_root)
# cred_verifier.verify_from_strings(client_cert, geni_credentials, slice_urn, privileges)
# except Exception as e:
# raise RuntimeError("%s" % (e,))
#
# user_gid = gid.GID(string=client_cert)
# user_urn = user_gid.get_urn()
# user_uuid = user_gid.get_uuid()
# user_email = user_gid.get_email()
# return user_urn, user_uuid, user_email # TODO document return
def setup():
from policymanager import PolicyManager
pm.registerService('policy', PolicyManager)
def setup():
resource_manger = NETCONFResourceManager()
pm.registerService('netconfrm', resource_manger)
def setup():
from notificationcenter import NotificationCenter
pm.registerService('notification', NotificationCenter)
def setup():
xmlrpc = pm.getService('xmlrpc')
api_tools = pm.getService('apitools')
greg_handler = GRegistryv2Handler()
pm.registerService('gregistryv2handler', greg_handler)
pm.registerService('gregistryv2delegatebase', GRegistryv2DelegateBase)
xmlrpc.registerXMLRPC('gregv2', greg_handler,
'/reg/2') # name, handlerObj, endpoint
api_tools.register_endpoint(name='gregv2',
type='reg',
version='2',
url='/reg/2')
gma_handler = GMAv2Handler()
pm.registerService('gmav2handler', gma_handler)
pm.registerService('gmav2delegatebase', GMAv2DelegateBase)
xmlrpc.registerXMLRPC('gmav2', gma_handler,
'/ma/2') # name, handlerObj, endpoint
api_tools.register_endpoint(name='gmav2',
type='ma',
version='2',
url='/ma/2')
gsa_handler = GSAv2Handler()
pm.registerService('gsav2handler', gsa_handler)
pm.registerService('gsav2delegatebase', GSAv2DelegateBase)
xmlrpc.registerXMLRPC('gsav2', gsa_handler,
'/sa/2') # name, handlerObj, endpoint
api_tools.register_endpoint(name='gsav2',
type='sa',
version='2',
url='/sa/2')
def setup():
ma_rm = OMemberAuthorityResourceManager()
pm.registerService('omemberauthorityrm', ma_rm)
pm.registerService('omemberauthorityexceptions', omemberauthorityexceptions)
def setup():
import registration_server
pm.registerService('registration', registration_server)
def setup():
import registration_server
pm.registerService('registration', registration_server)
def setup():
xmlrpc = pm.getService('xmlrpc')
api_tools = pm.getService('apitools')
greg_handler = GRegistryv2Handler()
pm.registerService('gregistryv2handler', greg_handler)
pm.registerService('gregistryv2delegatebase', GRegistryv2DelegateBase)
xmlrpc.registerXMLRPC('gregv2', greg_handler, '/reg/2') # name, handlerObj, endpoint
api_tools.register_endpoint(name='gregv2', type='reg', version='2', url='/reg/2')
gma_handler = GMAv2Handler()
pm.registerService('gmav2handler', gma_handler)
pm.registerService('gmav2delegatebase', GMAv2DelegateBase)
xmlrpc.registerXMLRPC('gmav2', gma_handler, '/ma/2') # name, handlerObj, endpoint
api_tools.register_endpoint(name='gmav2', type='ma', version='2', url='/ma/2')
gsa_handler = GSAv2Handler()
pm.registerService('gsav2handler', gsa_handler)
pm.registerService('gsav2delegatebase', GSAv2DelegateBase)
xmlrpc.registerXMLRPC('gsav2', gsa_handler, '/sa/2') # name, handlerObj, endpoint
api_tools.register_endpoint(name='gsav2', type='sa', version='2', url='/sa/2')
