# nodes no longer direclty connected to deployments
#suit_form_tabs =(('sites','Deployment Details'),('nodes','Nodes'),('deploymentprivileges','Privileges'),('tags','Tags'),('imagedeployments','Images'))
- suit_form_tabs =(('sites','Deployment Details'),('deploymentprivileges','Privileges'),,('imagedeployments','Images'))
+ suit_form_tabs =(('sites','Deployment Details'),('deploymentprivileges','Privileges'))
def get_form(self, request, obj=None, **kwargs):
if request.user.isReadOnlyUser():
('sliceprivileges','Privileges'),
('slivers','Slivers'),
('reservations','Reservations'),
+ ('tags','Tags'),
]
request=getattr(_thread_locals, "request", None)
def handle(controller):
from core.models import Controller, Site, ControllerSite, Slice, ControllerSlice, User, ControllerUser
from collections import defaultdict
+
+ #controller = Controller.get(controller_id)
+
+
# relations for all sites
ctrls_by_site = defaultdict(list)
ctrl_sites = ControllerSite.objects.all()
if site not in ctrls_by_site or \
controller not in ctrls_by_site[site]:
controller_site = ControllerSite(controller=controller, site=site)
- controller_site.save()
+ controller_site.save()
# relations for all slices
ctrls_by_slice = defaultdict(list)
ctrl_slices = ControllerSlice.objects.all()
if slice not in ctrls_by_slice or \
controller not in ctrls_by_slice:
controller_slice = ControllerSlice(controller=controller, slice=slice)
- controller_slice.save()
+ controller_slice.save()
# relations for all users
ctrls_by_user = defaultdict(list)
ctrl_users = ControllerUser.objects.all()
if user not in ctrls_by_user or \
controller not in ctrls_by_user[user]:
controller_user = ControllerUser(controller=controller, user=user)
- controller_user.save()
-
-
-
-
+ controller_user.save()
from core.models import *
def handle(network):
- from core.models import ControllerSlice,ControllerNetwork
+ from core.models import ControllerSlice,ControllerNetwork, Network
from collections import defaultdict
+
+ # network = Network.get(network_id)
# network controllers are not visible to users. We must ensure
# networks are deployed at all deploymets available to their slices.
slice_controllers = ControllerSlice.objects.all()
def handle(site):
- from core.models import Controller, ControllerSite
+ from core.models import Controller, ControllerSite, Site
+
+ # site = Site.get(site_id)
# make sure site has a ControllerSite record for each controller
ctrl_sites = ControllerSite.objects.filter(site=site)
existing_controllers = [cs.controller for cs in ctrl_sites]
def handle(site_privilege):
from core.models import Controller, SitePrivilege, ControllerSitePrivilege
+ # site_privilege = SitePrivilege.get(site_privilege_id)
# apply site privilage at all controllers
controller_site_privileges = ControllerSitePrivilege.objects.filter(
site_privilege = site_privilege,
def handle(slice):
- from core.models import Controller, ControllerSlice, SiteDeployment, Network, NetworkSlice,NetworkTemplate
+ from core.models import Controller, ControllerSlice, SiteDeployment, Network, NetworkSlice,NetworkTemplate, Slice
from collections import defaultdict
+
+ # slice = Slice.get(slice_id)
+
controller_slices = ControllerSlice.objects.filter(slice=slice)
existing_controllers = [cs.controller for cs in controller_slices]
def handle(slice_privilege):
from core.models import Controller, SlicePrivilege, ControllerSlicePrivilege
-
+
+ # slice_privilege = SlicePrivilege.get(slice_privilege_id)
# apply slice privilage at all controllers
controller_slice_privileges = ControllerSlicePrivilege.objects.filter(
slice_privilege = slice_privilege,
def handle(user):
- from core.models import Controller, ControllerSite, ControllerUser
+ from core.models import Controller, ControllerSite, ControllerUser, User
from collections import defaultdict
+
+ # user = User.get(user_id)
controller_users = ControllerUser.objects.filter(user=user)
existing_controllers = [cu.controller for cu in controller_users]
import model_policies
from util.logger import logger
+
modelPolicyEnabled = True
def EnableModelPolicy(x):
if (d.updated < o.updated):
d.save(update_fields=['updated'])
except AttributeError,e:
- pdb.set_trace()
raise e
def delete_if_inactive(d, o):
d.delete()
return
-@receiver(post_save)
-def post_save_handler(sender, instance, **kwargs):
- if not modelPolicyEnabled:
- return
-
- sender_name = sender.__name__
- policy_name = 'model_policy_%s'%sender_name
-
- if (not kwargs['update_fields']):
+def execute_model_policy(policy_name, instance, update_fields_empty, deleted):
+ if (update_fields_empty):
# Automatic dirtying
- walk_inv_deps(update_dep, instance)
+ #walk_inv_deps(update_dep, instance)
try:
policy_handler = getattr(model_policies, policy_name, None)
+ logger.error("POLICY HANDLER: %s %s" % (policy_name, policy_handler))
if policy_handler is not None:
policy_handler.handle(instance)
except:
logger.log_exc("Model Policy Error:")
- elif 'deleted' in kwargs['update_fields']:
+ print "Policy Exceution Error"
+ elif deleted:
walk_inv_deps(delete_if_inactive, instance)
+
+
+@receiver(post_save)
+def post_save_handler(sender, instance, **kwargs):
+ if not modelPolicyEnabled:
+ return
+
+ sender_name = sender.__name__
+ policy_name = 'model_policy_%s'%sender_name
+ if (not kwargs['update_fields']):
+ noargs = True
+ deleted = False
+ else:
+ noargs = False
+ deleted = True
+
+ execute_model_policy(policy_name, instance, noargs, deleted)
+
from syncstep import SyncStep
from toposort import toposort
from observer.error_mapper import *
+from openstack_observer.openstacksyncstep import OpenStackSyncStep
+
debug_mode = False
+class bcolors:
+ HEADER = '\033[95m'
+ OKBLUE = '\033[94m'
+ OKGREEN = '\033[92m'
+ WARNING = '\033[93m'
+ FAIL = '\033[91m'
+ ENDC = '\033[0m'
+ BOLD = '\033[1m'
+ UNDERLINE = '\033[4m'
+
logger = Logger(level=logging.INFO)
class StepNotReady(Exception):
# provides field (this eliminates the abstract base classes
# since they don't have a provides)
- if inspect.isclass(c) and issubclass(c, SyncStep) and hasattr(c,"provides") and (c not in self.sync_steps):
+ if inspect.isclass(c) and (issubclass(c, SyncStep) or issubclass(c,OpenStackSyncStep)) and hasattr(c,"provides") and (c not in self.sync_steps):
self.sync_steps.append(c)
logger.info('loaded sync steps: %s' % ",".join([x.__name__ for x in self.sync_steps]))
# print 'loaded sync steps: %s' % ",".join([x.__name__ for x in self.sync_steps])
-#!/bin/sh
+#!/bin/bash
source /opt/ansible/hacking/env-setup
ansible-playbook -v $@
logger = Logger(level=logging.INFO)
class SyncControllerImages(OpenStackSyncStep):
- provides=[ControllerImages]
+ provides=[ControllerImages, Image]
requested_interval=0
def fetch_pending(self, deleted):
def sync_record(self, controller_image):
logger.info("Working on image %s on controller %s" % (controller_image.image.name, controller_image.controller))
- image_fields = {'endpoint':controller_image.controller.auth_url,
- 'admin_user':controller_image.controller.admin_user,
- 'admin_password':controller_image.controller.admin_password,
- 'name':controller_image.image.name,
- 'filepath':controller_image.image.path,
- 'ansible_tag': '%s@%s'%(controller_image.image.name,controller_image.controller.name), # name of ansible playbook
- }
+ image_fields = {'endpoint':controller_image.controller.auth_url,
+ 'admin_user':controller_image.controller.admin_user,
+ 'admin_password':controller_image.controller.admin_password,
+ 'name':controller_image.image.name,
+ 'filepath':controller_image.image.path,
+ 'ansible_tag': '%s@%s'%(controller_image.image.name,controller_image.controller.name), # name of ansible playbook
+ }
- res = run_template('sync_controller_images.yaml', image_fields, path='controller_images')
+ res = run_template('sync_controller_images.yaml', image_fields, path='controller_images')
- if (len(res)!=1):
- raise Exception('Could not sync image %s'%controller_image.image.name)
- else:
- image_id = res[0]['id']
+ if (len(res)!=1):
+ raise Exception('Could not sync image %s'%controller_image.image.name)
+ else:
+ image_id = res[0]['id']
controller_image.glance_image_id = image_id
controller_image.save()
login_username: {{ admin_user }}
login_tenant_name: 'admin'
login_password: {{ admin_password }}
- name: {{ name }}
- file: {{ filepath }}
+ name: "{{ name }}"
+ file: "{{ filepath }}"
disk_format: 'raw'
is_public: true
class SyncControllerNetworks(OpenStackSyncStep):
requested_interval = 0
- provides=[Network, ControllerNetwork, Sliver]
+ provides=[ControllerNetwork, Network]
def alloc_subnet(self, uuid):
a = 10
logger = Logger(level=logging.INFO)
class SyncControllerSitePrivileges(OpenStackSyncStep):
- provides=[ControllerSitePrivilege]
+ provides=[ControllerSitePrivilege, SitePrivilege]
requested_interval=0
def fetch_pending(self, deleted):
class SyncControllerSites(OpenStackSyncStep):
requested_interval=0
- provides=[ControllerSite]
+ provides=[ControllerSite, Site]
def fetch_pending(self, deleted=False):
pending = super(OpenStackSyncStep, self).fetch_pending(deleted)
logger = Logger(level=logging.INFO)
class SyncControllerSlicePrivileges(OpenStackSyncStep):
- provides=[ControllerSlicePrivilege]
+ provides=[ControllerSlicePrivilege, SlicePrivilege]
requested_interval=0
def fetch_pending(self, deleted):
logger = Logger(level=logging.INFO)
class SyncControllerSlices(OpenStackSyncStep):
- provides=[ControllerSlice]
+ provides=[ControllerSlice, Slice]
requested_interval=0
def fetch_pending(self, deleted):
if (legacy):
host_filter = sliver.node.name.split('.',1)[0]
else:
- host_filter = sliver.node.name
+ host_filter = sliver.node.name.strip()
availability_zone_filter = 'nova:%s'%host_filter
sliver_name = '%s-%d'%(sliver.slice.name,sliver.id)
controller = sliver.node.site_deployment.controller
tenant_fields = {'endpoint':controller.auth_url,
'admin_user': sliver.creator.email,
- 'admin_password': sliver.creator.reomote_password,
+ 'admin_password': sliver.creator.remote_password,
'admin_tenant': sliver.slice.name,
'tenant': sliver.slice.name,
'tenant_description': sliver.slice.description,
git://git.onelab.eu / plstackapi.git / commitdiff