from portal.actions import (
manifold_update_user, manifold_update_account, manifold_add_account,
- manifold_delete_account, sfa_update_user, sfa_get_user, clear_user_creds )
+ manifold_delete_account, sfa_update_user, sfa_get_user, clear_user_creds, get_myslice_account, get_myslice_platform, get_registry_url, get_jfed_identity )
from portal.account import Account, get_expiration
from myslice.settings import logger
return context
@login_required
-def get_myslice_platform(request):
- platform_query = Query().get('local:platform')\
- .select('platform_id','platform','gateway_type','disabled','config')\
- .filter_by('platform','==','myslice')
- platform_details = execute_query(request, platform_query)
- for platform_detail in platform_details:
- return platform_detail
-
-@login_required
-def get_myslice_account(request):
- platform_myslice = get_myslice_platform(request)
- account_query = Query().get('local:account')\
- .select('user_id','platform_id','auth_type','config')\
- .filter_by('platform_id','==',platform_myslice['platform_id'])
- account_details = execute_query(request, account_query)
- for account_detail in account_details:
- return account_detail
-
-@login_required
-#my_acc form value processing
def account_process(request):
from sfa.trust.credential import Credential
from sfa.trust.certificate import Keypair
response['Content-Disposition'] = 'attachment; filename="auth_credential.txt"'
return response
-
+ account_detail = get_myslice_account(request)
if 'submit_name' in request.POST:
edited_first_name = request.POST['fname']
# XXX TODO: Factorize with portal/joinview.py
elif 'generate' in request.POST:
- for account_detail in account_details:
- for platform_detail in platform_details:
- if platform_detail['platform_id'] == account_detail['platform_id']:
- if 'myslice' in platform_detail['platform']:
- private = RSA.generate(1024)
- private_key = json.dumps(private.exportKey())
- public = private.publickey()
- public_key = json.dumps(public.exportKey(format='OpenSSH'))
- # updating manifold local:account table
- account_config = json.loads(account_detail['config'])
- # preserving user_hrn
- user_hrn = account_config.get('user_hrn','N/A')
- keypair = '{{"user_public_key":{}, "user_private_key":{}, "user_hrn":"{}"}}'\
- .format(public_key, private_key, user_hrn)
- #updated_config = json.dumps(account_config)
- # updating manifold
- #user_params = { 'config': keypair, 'auth_type':'managed'}
- #manifold_update_account(request, user_id, user_params)
- # updating sfa
- public_key = public_key.replace('"', '');
- user_pub_key = {'keys': public_key}
-
- sfa_update_user(request, user_hrn, user_pub_key)
- result_sfa_user = sfa_get_user(request, user_hrn, public_key)
- try:
- if 'keys' in result_sfa_user and result_sfa_user['keys'][0] == public_key:
- # updating manifold
- updated_config = json.dumps(account_config)
- user_params = {'config' : keypair, 'auth_type' : 'managed'}
- manifold_update_account(request, user_id, user_params)
- messages.success(request,
- 'Success: New Keypair Generated! '
- 'Delegation of your credentials will be automatic.')
- else:
- raise Exception,"Keys are not matching"
- except Exception as e:
- messages.error(request,
- 'Error: An error occured during the update '
- 'of your public key at the Registry, or your '
- 'public key is not matching the one stored.')
- logger.error("Exception in accountview {}".format(e))
- return HttpResponseRedirect("/portal/account/")
- else:
- messages.error(request,
- 'Account error: You need an account in '
- 'myslice platform to perform this action')
+ try:
+ private = RSA.generate(1024)
+ private_key = json.dumps(private.exportKey())
+ public = private.publickey()
+ public_key = json.dumps(public.exportKey(format='OpenSSH'))
+ # updating manifold local:account table
+ account_config = json.loads(account_detail['config'])
+ # preserving user_hrn
+ user_hrn = account_config.get('user_hrn','N/A')
+ keypair = '{"user_public_key":'+ public_key + ', "user_private_key":'+ private_key + ', "user_hrn":"'+ user_hrn + '"}'
+ #updated_config = json.dumps(account_config)
+ # updating manifold
+ #user_params = { 'config': keypair, 'auth_type':'managed'}
+ #manifold_update_account(request, user_id, user_params)
+ # updating sfa
+ public_key = public_key.replace('"', '');
+ user_pub_key = {'keys': public_key}
+
+ sfa_update_user(request, user_hrn, user_pub_key)
+ result_sfa_user = sfa_get_user(request, user_hrn, public_key)
+ try:
+ if 'keys' in result_sfa_user and result_sfa_user['keys'][0] == public_key:
+ # updating manifold
+ updated_config = json.dumps(account_config)
+ user_params = { 'config': keypair, 'auth_type':'managed'}
+ manifold_update_account(request, user_id, user_params)
+ messages.success(request, 'Sucess: New Keypair Generated! Delegation of your credentials will be automatic.')
+ else:
+ raise Exception,"Keys are not matching"
+ except Exception as e:
+ messages.error(request, 'Error: An error occured during the update of your public key at the Registry, or your public key is not matching the one stored.')
+ logger.error("Exception in accountview {}".format(e))
+ return HttpResponseRedirect("/portal/account/")
+ except Exception as e:
+ messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
return HttpResponseRedirect("/portal/account/")
elif 'upload_key' in request.POST:
- for account_detail in account_details:
- for platform_detail in platform_details:
- if platform_detail['platform_id'] == account_detail['platform_id']:
- if 'myslice' in platform_detail['platform']:
- up_file = request.FILES['pubkey']
- file_content = up_file.read()
- file_name = up_file.name
- file_extension = os.path.splitext(file_name)[1]
- allowed_extension = ['.pub','.txt']
- if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content):
- account_config = json.loads(account_detail['config'])
- # preserving user_hrn
- user_hrn = account_config.get('user_hrn','N/A')
- file_content = '{"user_public_key":"{}", "user_hrn":"{}"}'\
- .format(file_content, user_hrn)
- #file_content = re.sub("\r", "", file_content)
- #file_content = re.sub("\n", "\\n",file_content)
- file_content = ''.join(file_content.split())
- #update manifold local:account table
- user_params = {'config' : file_content, 'auth_type':'user'}
- manifold_update_account(request, user_id, user_params)
- # updating sfa
- user_pub_key = {'keys': file_content}
- sfa_update_user(request, user_hrn, user_pub_key)
- messages.success(request,
- 'Publickey uploaded! Please delegate your '
- 'credentials using SFA: '
- 'http://trac.myslice.info/wiki/DelegatingCredentials')
- return HttpResponseRedirect("/portal/account/")
- else:
- messages.error(request,
- 'RSA key error: Please upload '
- 'a valid RSA public key [.txt or .pub].')
- return HttpResponseRedirect("/portal/account/")
- else:
- messages.error(request,
- 'Account error: You need an account '
- 'in myslice platform to perform this action')
+ try:
+ up_file = request.FILES['pubkey']
+ file_content = up_file.read()
+ file_name = up_file.name
+ file_extension = os.path.splitext(file_name)[1]
+ allowed_extension = ['.pub','.txt']
+ if file_extension in allowed_extension and re.search(r'ssh-rsa',file_content):
+ account_config = json.loads(account_detail['config'])
+ # preserving user_hrn
+ user_hrn = account_config.get('user_hrn','N/A')
+ file_content = '{"user_public_key":"'+ file_content + '", "user_hrn":"'+ user_hrn +'"}'
+ #file_content = re.sub("\r", "", file_content)
+ #file_content = re.sub("\n", "\\n",file_content)
+ file_content = ''.join(file_content.split())
+ #update manifold local:account table
+ user_params = { 'config': file_content, 'auth_type':'user'}
+ manifold_update_account(request, user_id, user_params)
+ # updating sfa
+ user_pub_key = {'keys': file_content}
+ sfa_update_user(request, user_hrn, user_pub_key)
+ messages.success(request, 'Publickey uploaded! Please delegate your credentials using SFA: http://trac.myslice.info/wiki/DelegatingCredentials')
+ return HttpResponseRedirect("/portal/account/")
+ else:
+ messages.error(request, 'RSA key error: Please upload a valid RSA public key [.txt or .pub].')
+ return HttpResponseRedirect("/portal/account/")
+
+ except Exception as e:
+ messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
return HttpResponseRedirect("/portal/account/")
elif 'dl_pubkey' in request.POST or request.POST['button_value'] == 'dl_pubkey':
- for account_detail in account_details:
- for platform_detail in platform_details:
- if platform_detail['platform_id'] == account_detail['platform_id']:
- if 'myslice' in platform_detail['platform']:
- account_config = json.loads(account_detail['config'])
- public_key = account_config['user_public_key']
- response = HttpResponse(public_key, content_type='text/plain')
- response['Content-Disposition'] = 'attachment; filename="pubkey.txt"'
- return response
- break
- else:
- messages.error(request,
- 'Account error: You need an account '
- 'in myslice platform to perform this action')
+ try:
+ account_config = json.loads(account_detail['config'])
+ public_key = account_config['user_public_key']
+ response = HttpResponse(public_key, content_type='text/plain')
+ response['Content-Disposition'] = 'attachment; filename="pubkey.txt"'
+ return response
+ except Exception as e:
+ messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
return HttpResponseRedirect("/portal/account/")
elif 'dl_pkey' in request.POST or request.POST['button_value'] == 'dl_pkey':
- for account_detail in account_details:
- for platform_detail in platform_details:
- if platform_detail['platform_id'] == account_detail['platform_id']:
- if 'myslice' in platform_detail['platform']:
- account_config = json.loads(account_detail['config'])
- if 'user_private_key' in account_config:
- private_key = account_config['user_private_key']
- response = HttpResponse(private_key, content_type='text/plain')
- response['Content-Disposition'] = 'attachment; filename="privkey.txt"'
- return response
- else:
- messages.error(request,
- 'Download error: '
- 'Private key is not stored in the server')
- return HttpResponseRedirect("/portal/account/")
+ try:
+ account_config = json.loads(account_detail['config'])
+ if 'user_private_key' in account_config:
+ private_key = account_config['user_private_key']
+ response = HttpResponse(private_key, content_type='text/plain')
+ response['Content-Disposition'] = 'attachment; filename="privkey.txt"'
+ return response
+ else:
+ messages.error(request, 'Download error: Private key is not stored in the server')
+ return HttpResponseRedirect("/portal/account/")
- else:
- messages.error(request,
- 'Account error: You need an account '
- 'in myslice platform to perform this action')
+ except Exception as e:
+ messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
return HttpResponseRedirect("/portal/account/")
elif 'delete' in request.POST or request.POST['button_value'] == 'delete':
- for account_detail in account_details:
- for platform_detail in platform_details:
- if platform_detail['platform_id'] == account_detail['platform_id']:
- if 'myslice' in platform_detail['platform']:
- account_config = json.loads(account_detail['config'])
- if 'user_private_key' in account_config:
- for key in account_config.keys():
- if key == 'user_private_key':
- del account_config[key]
-
- updated_config = json.dumps(account_config)
- user_params = { 'config': updated_config, 'auth_type':'user'}
- manifold_update_account(request, user_id, user_params)
- messages.success(request,
- 'Private Key deleted. You need to delegate '
- 'credentials manually once it expires.')
- messages.success(request,
- 'Once your credentials expire, Please delegate '
- 'manually using SFA: '
- 'http://trac.myslice.info/wiki/DelegatingCredentials')
- return HttpResponseRedirect("/portal/account/")
- else:
- messages.error(request, 'Delete error: Private key is not stored in the server')
- return HttpResponseRedirect("/portal/account/")
-
- else:
+ try:
+ account_config = json.loads(account_detail['config'])
+ if 'user_private_key' in account_config:
+ for key in account_config.keys():
+ if key == 'user_private_key':
+ del account_config[key]
+
+ updated_config = json.dumps(account_config)
+ user_params = { 'config': updated_config, 'auth_type':'user'}
+ manifold_update_account(request, user_id, user_params)
+ messages.success(request, 'Private Key deleted. You need to delegate credentials manually once it expires.')
+ messages.success(request, 'Once your credentials expire, Please delegate manually using SFA: http://trac.myslice.info/wiki/DelegatingCredentials')
+ return HttpResponseRedirect("/portal/account/")
+ else:
+ messages.error(request, 'Delete error: Private key is not stored in the server')
+ return HttpResponseRedirect("/portal/account/")
+
+ except Exception as e:
messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
return HttpResponseRedirect("/portal/account/")
# download identity for jfed
elif 'dl_identity' in request.POST or request.POST['button_value'] == 'dl_identity':
- for account_detail in account_details:
- for platform_detail in platform_details:
- if platform_detail['platform_id'] == account_detail['platform_id']:
- if 'myslice' in platform_detail['platform']:
- account_config = json.loads(account_detail['config'])
- if 'user_private_key' in account_config:
- private_key = account_config['user_private_key']
- user_hrn = account_config.get('user_hrn','N/A')
- registry = 'http://sfa-fed4fire.pl.sophia.inria.fr:12345/'
- jfed_identity = user_hrn + '\n' + registry + '\n' + private_key
- response = HttpResponse(jfed_identity, content_type='text/plain')
- response['Content-Disposition'] = 'attachment; filename="jfed_identity.txt"'
- return response
- else:
- messages.error(request, 'Download error: Private key is not stored in the server')
- return HttpResponseRedirect("/portal/account/")
+ try:
+ jfed_identity = get_jfed_identity(request)
+ if jfed_identity is not None:
+ response = HttpResponse(jfed_identity, content_type='text/plain')
+ response['Content-Disposition'] = 'attachment; filename="jfed_identity.txt"'
+ return response
+ else:
+ messages.error(request, 'Download error: Private key is not stored in the server')
+ return HttpResponseRedirect("/portal/account/")
- else:
+ except Exception as e:
messages.error(request, 'Account error: You need an account in myslice platform to perform this action')
return HttpResponseRedirect("/portal/account/")
user_hrn = account_config.get('user_hrn','N/A')
t_user_hrn = user_hrn.split('.')
authority_hrn = t_user_hrn[0] + '.' + t_user_hrn[1]
+ registry = get_registry_url(request)
import socket
hostname = socket.gethostbyaddr(socket.gethostname())[0]
- registry = platform_config.get('registry','N/A')
admin_user = platform_config.get('user','N/A')
- if 'localhost' in registry:
- port = registry.split(':')[-1:][0]
- registry = "http://" + hostname +':'+ port
manifold_host = ConfigEngine().manifold_url()
if 'localhost' in manifold_host:
manifold_host = manifold_host.replace('localhost',hostname)
from portal.account import Account, get_expiration
from portal.models import PendingSlice
-from portal.actions import authority_check_pis
+from portal.actions import authority_check_pis, get_jfed_identity
import activity.user
# let's use ManifoldResult.__repr__
env['state']="%s"%manifoldresult
- return render_to_response(self.template,env, context_instance=RequestContext(request))
# user was authenticated at the backend
elif auth_result is not None:
user=auth_result
env['user_cred'] = user_cred
else:
env['person'] = None
- return render_to_response(self.template,env, context_instance=RequestContext(request))
else:
# log user activity
activity.user.login(self.request, "notactive")
env['state'] = "Your account is not active, please contact the site admin."
env['layout_1_or_2']="layout-unfold2.html"
- return render_to_response(self.template,env, context_instance=RequestContext(request))
+ jfed_identity = get_jfed_identity(request)
+ if jfed_identity is not None:
+ import base64
+ encoded_jfed_identity = base64.b64encode(jfed_identity)
+ env['jfed_identity'] = encoded_jfed_identity
+ else:
+ env['jfed_identity'] = None
+
# otherwise
else:
# log user activity
activity.user.login(self.request, "error")
env['state'] = "Your username and/or password were incorrect."
- return render_to_response(self.template, env, context_instance=RequestContext(request))
+ return render_to_response(self.template,env, context_instance=RequestContext(request))
def get (self, request, state=None):
env = self.default_env()
acc_auth_cred={}
+
+ jfed_identity = get_jfed_identity(request)
+ if jfed_identity is not None:
+ import base64
+ encoded_jfed_identity = base64.b64encode(jfed_identity)
+ env['jfed_identity'] = encoded_jfed_identity
+ else:
+ env['jfed_identity'] = None
+
if request.user.is_authenticated():
## check user is pi or not
elif not env['username']: env['state'] = None
# use one or two columns for the layout - not logged in users will see the login prompt
-# account_query = Query().get('local:account').select('user_id','platform_id','auth_type','config')
-# account_details = execute_query(self.request, account_query)
-# for account_detail in account_details:
-# account_config = json.loads(account_detail['config'])
-# platform_name = platform_detail['platform']
-# if 'myslice' in platform_detail['platform']:
-# acc_user_cred = account_config.get('delegated_user_credential','N/A')
-# acc_slice_cred = account_config.get('delegated_slice_credentials','N/A')
-# acc_auth_cred = account_config.get('delegated_authority_credentials','N/A')
-#
-# if 'N/A' not in acc_user_cred:
-# exp_date = re.search('<expires>(.*)</expires>', acc_user_cred)
-# if exp_date:
-# user_exp_date = exp_date.group(1)
-# user_cred_exp_list.append(user_exp_date)
-#
-# my_users = [{'cred_exp': t[0]}
-# for t in zip(user_cred_exp_list)]
-#
-#
-# if 'N/A' not in acc_slice_cred:
-# for key, value in acc_slice_cred.iteritems():
-# slice_list.append(key)
-# # get cred_exp date
-# exp_date = re.search('<expires>(.*)</expires>', value)
-# if exp_date:
-# exp_date = exp_date.group(1)
-# slice_cred_exp_list.append(exp_date)
-#
-# my_slices = [{'slice_name': t[0], 'cred_exp': t[1]}
-# for t in zip(slice_list, slice_cred_exp_list)]
-#
-# if 'N/A' not in acc_auth_cred:
-# for key, value in acc_auth_cred.iteritems():
-# auth_list.append(key)
-# #get cred_exp date
-# exp_date = re.search('<expires>(.*)</expires>', value)
-# if exp_date:
-# exp_date = exp_date.group(1)
-# auth_cred_exp_list.append(exp_date)
-
-
return render_to_response(self.template, env, context_instance=RequestContext(request))
</div>
<div class="modal-body">
<p align="left">
- The exact terms and conditions for Fed4FIRE are currently under development.
+<div style="text-align: left;" class="mk-text-block "><h4>Fed4FIRE Umbrella Terms and Conditions</h4>
+<h4><span style="color: #f97352;">Purpose of this document</span></h4>
+<p>These Terms and Conditions are provided to inform the user (hereinafter ‘You’) about what constitutes acceptable and permitted use of testbed resources and tools (hereinafter ‘the Platform’) in the Fed4FIRE federation (hereinafter ‘Fed4FIRE’).</p>
+<p>The regulations are not intended to constrain You unnecessarily, but to make You aware and protect You, along with all the participating institutions, from the consequences of any misuse or illegal activity as far as is reasonable.</p>
+<p>It is important to understand that when You use the Platform You are bound by these global Fed4FIRE terms and conditions (as provided online at <a href="http://www.fed4fire.eu/terms">http://www.fed4fire.eu/terms</a>), and also by the ICT regulations of Your own institution and the Acceptable Use Policy of the network providers connecting You to the testbed and interconnecting the resources You use. Thus You must have read and understood these before using Platform resources.</p>
+<p>This policy may be updated as necessary. The current version in force will be available at <a href="http://www.fed4fire.eu/terms">http://www.fed4fire.eu/terms</a>.</p>
+<h4><span style="color: #f97352;">Context</span></h4>
+<p>Fed4FIRE provides an experimental platform for testing new ideas and technologies in the area of computer networking (<a href="http://www.fed4fire.eu">http://www.fed4fire.eu</a>). The federated facility consists of individual testbeds and tools, with different owners. The Fed4FIRE consortium is coordinated by iMinds.</p>
+<p>Fed4FIRE provides You with basic access (through a single account, common tools, support and documentation) to the Platform, while each individual testbed provider determines the specifics of this access in terms of available resources, access policies, etc.</p>
+<h4><span style="color: #f97352;">Scope</span></h4>
+<p>These Terms and Conditions apply to every user of the Platform.</p>
+<p>The Terms and Conditions apply to the use of all equipment connected to the Platform. This includes servers, network(s), and Your workstations (whether owned by You, a company or an institution) and any other equipment or facilities connected to the Platform.</p>
+<p>These Terms and Conditions apply to all use of the Platform.</p>
+<p>These Terms and Conditions apply to third parties using the Platform through services You have made available through the Platform as part of an experiment. You will have to inform these third parties of the Terms and Conditions.</p>
+<h4><span style="color: #f97352;">Limitation of Liability</span></h4>
+<p>No liability is assumed by service providers involved on the Platform or any member of the Fed4FIRE consortium in regards to interruption, corruption, loss or disclosure of the services, tools, processes and data hosted<strong>, </strong>unless it is explicitly mentioned otherwise.</p>
+<h4><span style="color: #f97352;">Service Provision</span></h4>
+<p>You are granted Resources within the Fed4FIRE testbed so that You can use the Platform for the purposes described in the experiment projects You are taking part in. These resources can not be used for any other purposes.</p>
+<p>Platform resource providers aim to provide a stable, high-quality service. If there is evidence that the actions of users are adversely impacting this, resource providers are empowered to take reasonable measures to terminate or reprioritise usage in order to protect the overall operation of their services. Implicated users will be contacted by testbed providers as early as is reasonable.</p>
+<h4><span style="color: #f97352;">Acceptable Usage Policy</span></h4>
+<p>You are granted an account solely for Your own and personal use. You should take appropriate measure to protect Your credentials and prevent their use by third parties. The information You provide when requesting an account should be correct to the best of Your knowledge. You shall be responsible for all loss or damages to any part of the Platform as a result of any use of Your credentials to access the Platform, whether they are authorised or unauthorised by You.</p>
+<p>You shall be liable for actions performed on the Platform, by You, at your request or at the request of any other user invited or permitted by You to use services running on Fed4FIRE. In case of any loss or damage to the Platform originating from Your account, You are responsible for repairing or compensating for all damages to the Platform. In addition, You must respect the regulations of the various testbed resources You use in Your work, as described at <a href="http://www.fed4fire.eu/terms">http://www.fed4fire.eu/terms</a>. Your need to do this arises from co-operative agreements that have been made between all the organisations participating in the Platform.</p>
+<p>You may not interfere with others’ work or attempt to invade their privacy.</p>
+<p>You may not attempt to disrupt the working of the Platform.</p>
+<p>You must respect all Copyright for any software and data used on the Platform.</p>
+<p>The terms of software and data licences must be respected.</p>
+<p>You are not entitled to move proprietary data to, from, or via Platform systems without the prior agreement of its owner.</p>
+<p>Once You have registered to use the Platform, it is Your responsibility to remain aware of these regulations and of any changes made to them, and your continued use of the Platform means that you shall abide by the latest version of these terms and conditions.</p>
+<p>In order to keep the Platform operating correctly in both the technical and legal senses, it may become necessary to investigate network traffic (including, for example, e-mails) as well as examine information held on systems that are, or have been, connected to the Platform. You are deemed to have agreed to this.</p>
+<p>You must ensure that all known or obvious threats and vulnerabilities of the systems You run are adequately addressed.</p>
+<p>Should Your usage imply giving access to the Platform to third parties, You understand You will need to gather explicit consent from the operators of the individual testbed providers You will use, and You agree to enforce any restrictions imposed by an individual testbed provider and accept to fulfil Your legal obligations regarding data protection and retention laws.</p>
+<p>The following are explicitly forbidden on the Platform:</p>
+<ul>
+<li>Any military usage, including the development and production of weapons of mass destruction.</li>
+<li>Any activity resulting in compromising the security or integrity of any sites or networks connected to the Fed4FIRE facility</li>
+<li>Distribution of documents or materials containing insults or defamation, racial hatred or revisionism, terrorism, advertising, or distribution of material in a way that infringes the copyright of another person.</li>
+<li>Any illegal activity.</li>
+</ul>
+<p>You must comply to any additional national regulations from the government of the operators of the local testbeds.</p>
+<h4><span style="color: #f97352;">Enforcement</span></h4>
+<p>Whenever You use the Platform, You are bound by all the regulations in the current form of these terms and conditions and the legislation in force at the time.</p>
+<p>The regulations and legislation which applies to You will be enforced by iMinds, as leader of the Fed4FIRE consortium, or/and by the affected testbed providers, even if a breach of either has been evidenced from elsewhere.</p>
+<p>Note that for breaches of some legislation, the law enforcement can be involved.</p>
+<p>Ignorance of regulations or legislation is not a defence.</p>
+<p>Penalties, as defined in the individual testbed regulations at <a href="http://www.fed4fire.eu/terms">http://www.fed4fire.eu/terms</a>, will be levied for confirmed breaches of regulations.</p>
+<p>Disciplinary and investigative processes may also involve any Fed4FIRE partners, users and testbed providers involved in or affected by Your actions.</p>
+<p>Note that all testbed providers have agreed to co-operate in investigating disciplinary cases.</p>
+<p>You agree that the testbed and network providers in Fed4FIRE may monitor the systems and traffic for vulnerabilities and conformance to the acceptable uses, and You will collaborate with Fed4FIRE and any third party involved should any violations or breaches be noticed. The testbed providers involved may suspend or stop systems or suspend network connectivity without notice if such violations are found or suspected. To fulfil legal and contractual requirements, they may communicate to authorized third parties the owner and user of any resource provisioned and connected to the internet.</p>
+<h4><span style="color: #f97352;">Non-research use of Platform resources</span></h4>
+<p>The Fed4FIRE federation Platform has been constructed for experiment-driven research activities, where experiment-driven research is defined as any activity that furthers the user’s knowledge and/or understanding of algorithms, complex data structures or user behaviour.</p>
+<p>If You wish to use the Platform for any other purpose this must be authorized in advance by the Fed4FIRE testbed providers You will use. You will be expected to provide detailed information in support of Your request.</p>
+<p>Experiments must obtain prior agreement from the providers of all resources (e.g. computers, software, data, networks, and any other facilities) before these are used for any purposes other than experiment-driven research activities.</p>
+<p>The use of Fed4FIRE to host commercial services is explicitly disallowed.</p>
+<p>Experimenters that wish to use additional resources also have to agree with the policies of the testbed providers that offer the requested resources (when applicable). The individual testbed policies can be found here:</p>
+<p><a href="http://www.fed4fire.eu/terms/" target="_blank">fed4fire testbeds</a></p>
+<div class="clearboth"></div></div>
</p>
</div>
git://git.onelab.eu / unfold.git / commitdiff