Ejemplo n.º 1
0
 def set_environ(self):
     self.environ = TraitEnvironment(self.conn, self.suite, self.name)
     while self.env_element.hasChildNodes():
         del self.env_element.childNodes[0]
     for key, value in self.environ.items():
         var_element = TraitVariableElement(self.name, key, value)
         self.env_element.appendChild(var_element)
Ejemplo n.º 2
0
 def delete_trait(self, trait):
     environ = TraitEnvironment(self.conn, self.suite, trait)
     environ.clear()
     self._templates.delete_trait(trait)
     self._parents.delete_trait(trait)
     self._packages.delete_trait(trait)
     self._scripts.delete_trait(trait)
     self._traits.set_clause([('trait', trait)])
     self._traits.delete()
     self._traits.clear(clause=True)
Ejemplo n.º 3
0
 def insert_trait(self, path, suite=None):
     #tar = TraitTarFile(path)
     #trait = tar.get_trait()
     trait = self.parse_trait_xml(path, suite=suite)
     all = Set([x.trait for x in self._alltraits.select()])
     suite_traits = Set([x.trait for x in self._traits.select()])
     parents = Set(trait.parents)
     debug("parents for trait %s, %s" % (trait.name, parents))
     if not parents.issubset(suite_traits):
         raise UnbornError, 'Parent Unborn'        
     if trait.name in suite_traits:
         raise Error, 'trait exists'
     idata ={'trait' : trait.name}
     if trait.name not in all:
         self._alltraits.insert(data=idata)
     description_path = os.path.join(path, 'description.txt')
     if os.path.isfile(description_path):
         idata['description'] = file(description_path).read()            
     if trait.name not in suite_traits:
         self._traits.insert(data=idata)
     else:
         raise RuntimeError, '%s already there' % trait.name
     lasttrait = self.current_trait
     self._parents.set_trait(trait.name)
     self._packages.set_trait(trait.name)
     self._templates.set_trait(trait.name)
     self._scripts.set_trait(trait.name)
     self._parents.insert_parents(trait.parents)
     for package, action in trait.packages:
         self._packages.insert_package(package, action)
     n = 0
     for template, data in trait.templates:
         #print template, data
         #templatefile = tar.get_template(data['package'], template)
         template_id = template.replace('/', '-slash-')
         template_filename = os.path.join(path, 'template-%s' % template_id)
         if not os.path.exists(template_filename):
             print "in suite %s trait %s" % (suite, trait.name)
             print "exported template %s not converted yet" % template
             template_filename = os.path.join(path, 'template-%d' % n)
         templatefile = file(template_filename)
         idata = {'template' : template}
         #print idata
         idata.update(data)
         #print idata
         self._templates.insert_template(idata, templatefile)
         n += 1
     for script in trait.scripts:
         #scriptfile = tar.get_script(script)
         scriptfile = file(os.path.join(path, 'script-%s' % script))
         self._scripts.insert_script(script, scriptfile)
     environ = TraitEnvironment(self.conn, suite, trait.name)
     environ.update(trait.environ)
     self.set_trait(lasttrait)
Ejemplo n.º 4
0
 def set_trait(self, trait):
     self.current_trait = trait
     self.environ = TraitEnvironment(self.conn, self.suite, trait)
     self._parents.set_trait(trait)
     self._packages.set_trait(trait)
     self._templates.set_trait(trait)
     self._scripts.set_trait(trait)
Ejemplo n.º 5
0
class TraitElement(Element):
    def __init__(self, conn, suite):
        self.conn = conn
        self.cursor = StatementCursor(self.conn, name='_Trait_')
        Element.__init__(self, 'trait')
        self.desc_element = TextElement('description', None)
        self.parent_element = Element('parents')
        self.pkg_element = Element('packages')
        self.env_element = Element('environ')
        self.templ_element = Element('templates')
        self.scripts_element = Element('scripts')
        self.appendChild(self.desc_element)
        self.appendChild(self.parent_element)
        self.appendChild(self.pkg_element)
        self.appendChild(self.env_element)
        self.appendChild(self.templ_element)
        self.appendChild(self.scripts_element)
        self.set_suite(suite)
        
    def set_suite(self, suite):
        self.suite = suite
        # will probably make this a configuration option later
        # turning it off for now.
        if False:
            self.setAttribute('suite', self.suite)
        self.traitparent = TraitParent(self.conn, self.suite)
        self.traitpackage = TraitPackage(self.conn, self.suite)
        self.traittemplate = TraitTemplate(self.conn, self.suite)
        self.traitscripts = TraitScript(self.conn, self.suite)

    def set_environ(self):
        self.environ = TraitEnvironment(self.conn, self.suite, self.name)
        while self.env_element.hasChildNodes():
            del self.env_element.childNodes[0]
        for key, value in self.environ.items():
            var_element = TraitVariableElement(self.name, key, value)
            self.env_element.appendChild(var_element)
    
    def set_parents(self):
        self.parents = self.traitparent.parents(self.name)
        while self.parent_element.hasChildNodes():
            del self.parent_element.childNodes[0]
        for parent in self.parents:
            self.parent_element.appendChild(ParentElement(parent.parent))
            
    def set_packages(self):
        self.packages = self.traitpackage.packages([self.name])
        while self.pkg_element.hasChildNodes():
            del self.pkg_element.childNodes[0]
        for package in self.packages:
            pelement = PackageElement(package.package)
            pelement.setAttribute('action', package.action)
            self.pkg_element.appendChild(pelement)

    def set_templates(self):
        self.templates = self.traittemplate.templates(self.name)
        while self.templ_element.hasChildNodes():
            del self.templ_element.childNodes[0]
        for template in self.templates:
            element = TemplateElement(template.template)
            for att in ['mode', 'owner', 'grp_owner']:
                element.setAttribute(att, template[att])
            self.templ_element.appendChild(element)

    def set_scripts(self):
        self.scripts = [x.script for x in self.traitscripts.scripts(self.name)]
        while self.scripts_element.hasChildNodes():
            del self.scripts_element.childNodes[0]
        for script in self.scripts:
            element = Element('script')
            element.setAttribute('name', script)
            self.scripts_element.appendChild(element)
            

    def set_name(self, name):
        self.name = name
        self.setAttribute('name', self.name)

    def set_priority(self, priority):
        self.priority = priority
        self.setAttribute('priority', self.priority)

    def set(self, name):
        self.set_name(name)
        # this is probably not needed here, and slows things down
        # considerably
        #self.set_suite(self.suite)
        self.set_environ()
        self.set_parents()
        self.set_packages()
        self.set_templates()
        self.set_scripts()
        
    def str(self):
        print self.toprettyxml()