示例#1
0
文件: config.py 项目: fkei/karesansui
    def writecfg(self, cfg):
        ConfigFile(self.config_path).write(cfg)
        r_chmod(self.config_path, "o-rwx")
        r_chmod(self.config_path, "g+rw")

        if os.getuid() == 0:
            r_chgrp(self.config_path, KARESANSUI_GROUP)
示例#2
0
    def _pre_write_conf(self, conf_arr={}):

        # Change permission to be able to read/write data kss group.
        if os.path.exists(COLLECTD_DATA_DIR):
            if os.getuid() == 0:
                r_chgrp(COLLECTD_DATA_DIR, KARESANSUI_GROUP)
                r_chmod(COLLECTD_DATA_DIR, "g+rwx")
                r_chmod(COLLECTD_DATA_DIR, "o-rwx")

        dop = DictOp()
        dop.addconf("__", conf_arr)

        if dop.isset("__", ["python"]) is True:
            dop.cdp_unset("__", ["python", "Plugin", "python", "@ORDERS"],
                          multiple_file=True)
            orders = []
            orders.append(['Encoding'])
            orders.append(['LogTraces'])
            orders.append(['Interactive'])
            orders.append(['ModulePath'])
            orders.append(['Import'])
            orders.append(['Module'])
            dop.cdp_set("__", ["python", "Plugin", "python", "@ORDERS"],
                        orders,
                        is_opt_multi=True,
                        multiple_file=True)

        return dop.getconf("__")
示例#3
0
    def writecfg(self, cfg):
        ConfigFile(self.config_path).write(cfg)
        r_chmod(self.config_path, "o-rwx")
        r_chmod(self.config_path, "g+rw")

        if os.getuid() == 0:
            r_chgrp(self.config_path, KARESANSUI_GROUP)
示例#4
0
    def createSnapshot(self, domain=None, xmlDesc=None):
        retval = False

        if domain is not None:
            parent_snapshot_name = self.getCurrentSnapshotName(domain)

            if xmlDesc is None:
                xml = "<domainsnapshot/>"

            else: # validate xml file
                try:
                    doc = XMLParse(xmlDesc)
                    name = XMLXpath(doc, '/domainsnapshot/name/text()')
                    if name is not None:
                        xml = xmlDesc
                except:
                    pass
            try:
                xml
                guest = self.kvc.search_guests(domain)[0]
                snapshot = libvirtmod.virDomainSnapshotCreateXML(guest._o,xml,0)
                if snapshot is not False:
                    retval = libvirtmod.virDomainSnapshotGetXMLDesc(snapshot, 0)
            except:
                pass

        if retval is not False:
            kvg_guest = self.kvc.search_kvg_guests(domain)[0]
            id = self.getCurrentSnapshotName(domain)
            kvg_guest.set_current_snapshot(id)

            # ここにsnapshotのxmlファイルに親のsnapshotの情報を書き込む処理
            try:
                xml_path = self.getSnapshotXMLPath(id)

                # <parent/>が設定されてない場合
                # かつ、snapshot実行前に<currentSnapshot/>が設定されていた場合
                if self.getParentName(id) is None and parent_snapshot_name is not None:
                    if os.path.exists(xml_path):
                        doc = XMLParse(xml_path)
                        parent = doc.createElement("parent")
                        name   = doc.createElement("name")
                        txt = doc.createTextNode(str(parent_snapshot_name))
                        name.appendChild(txt)
                        parent.appendChild(name)
                        doc.childNodes[0].appendChild(parent)
                        xmlDesc = self.generateXML(doc)

                        ConfigFile(xml_path).write(xmlDesc)

                if os.path.exists(xml_path):
                    if os.getuid() == 0:
                        r_chgrp(xml_path,KARESANSUI_GROUP)
                        r_chmod(xml_path,"g+rw")
                        r_chmod(xml_path,"o-rwx")
            except:
                pass

        return retval
示例#5
0
 def create(self):
     if not os.path.exists(self.path):
         self.db = self._open("c")
         from karesansui.lib.utils import r_chmod, r_chgrp
         r_chgrp(self.path,KARESANSUI_GROUP)
         r_chmod(self.path,"g+rw")
     else:
         self.db = self._open("c")
     pass
示例#6
0
 def writecfg(self,cfg, config_dir=None):
     if config_dir is None:
         config_dir = self.config_dir
         
     filename = "%s/%s" %(config_dir, self.config.get_domain_name())
     ConfigFile(filename).write(cfg)
     r_chmod(filename,"o-rwx")
     r_chmod(filename,"g+rw")
     if os.getuid() == 0:
         r_chgrp(filename,KARESANSUI_GROUP)
示例#7
0
 def copycfg(self,src_dir):
         
     src_filename = "%s/%s" %(src_dir, self.config.get_domain_name())
     filename = "%s/%s" %(self.config_dir, self.config.get_domain_name())
     
     shutil.copy(src_filename, filename)
     
     r_chmod(filename,"o-rwx")
     r_chmod(filename,"g+rw")
     if os.getuid() == 0:
         r_chgrp(filename,KARESANSUI_GROUP)
示例#8
0
class StorageXMLGenerator:
    def __init__(self):
        self.config_dir = VIRT_STORAGE_CONFIG_DIR

    def _create_text_node(self, tag, txt):
        node = self.document.createElement(tag)
        self._add_text(node, txt)
        return node

    def _add_text(self, node, txt):
        txt_n = self.document.createTextNode(txt)
        node.appendChild(txt_n)

    def generate(self, config):
        tree = self.generate_xml_tree(config)
        out = StringIO()
        out.write(tree.toxml())
        return out.getvalue()

    def end_build(self):
        pass

    def writecfg(self, cfg):
        try:
            os.makedirs(self.config_dir)
        except OSError, (err, msg):
            if err != errno.EEXIST:
                raise OSError(err, msg)

        filename = "%s/%s.xml" % (self.config_dir,
                                  self.config.get_storage_name())
        ConfigFile(filename).write(cfg)
        r_chmod(filename, "o-rwx")
        r_chmod(filename, "g+rw")
        if os.getuid() == 0:
            r_chgrp(filename, KARESANSUI_GROUP)
示例#9
0
    def _pre_write_conf(self,conf_arr={}):

        # Change permission to be able to read/write data kss group.
        if os.path.exists(COLLECTD_DATA_DIR):
            if os.getuid() == 0:
                r_chgrp(COLLECTD_DATA_DIR,KARESANSUI_GROUP)
                r_chmod(COLLECTD_DATA_DIR,"g+rwx")
                r_chmod(COLLECTD_DATA_DIR,"o-rwx")

        dop = DictOp()
        dop.addconf("__",conf_arr)

        if dop.isset("__",["python"]) is True:
            dop.cdp_unset("__",["python","Plugin","python","@ORDERS"],multiple_file=True)
            orders = []
            orders.append(['Encoding'])
            orders.append(['LogTraces'])
            orders.append(['Interactive'])
            orders.append(['ModulePath'])
            orders.append(['Import'])
            orders.append(['Module'])
            dop.cdp_set("__",["python","Plugin","python","@ORDERS"],orders,is_opt_multi=True,multiple_file=True)

        return dop.getconf("__")
示例#10
0
def iptables_lint_contents(contents, webobj=None, machine=None):
    from karesansui.lib.file.configfile import ConfigFile
    
    if not os.path.exists(CONF_TMP_DIR):
        os.makedirs(CONF_TMP_DIR)
        r_chmod(CONF_TMP_DIR,0770)
        r_chown(CONF_TMP_DIR,KARESANSUI_USER)
        r_chgrp(CONF_TMP_DIR,KARESANSUI_GROUP)

    seconds = 10 * 60
    for _old in glob.glob("%s/iptables-save.*" % (CONF_TMP_DIR,)):
        mtime = os.stat(_old).st_mtime
        if int(time.time()) > (mtime + seconds):
            os.unlink(_old)

    serial = time.strftime("%Y%m%d%H%M%S",time.localtime())
    filename = "%s/iptables-save.%s" % (CONF_TMP_DIR,serial,)

    ConfigFile(filename).write(contents)
    r_chmod(filename,0660)
    r_chown(filename,KARESANSUI_USER)
    r_chgrp(filename,KARESANSUI_GROUP)

    return iptables_lint(filename, webobj, machine, delete=True)
示例#11
0
    def createSnapshot(self, domain=None, xmlDesc=None):
        retval = False

        if domain is not None:
            parent_snapshot_name = self.getCurrentSnapshotName(domain)

            if xmlDesc is None:
                xml = "<domainsnapshot/>"

            else:  # validate xml file
                try:
                    doc = XMLParse(xmlDesc)
                    name = XMLXpath(doc, '/domainsnapshot/name/text()')
                    if name is not None:
                        xml = xmlDesc
                except:
                    pass
            try:
                xml
                guest = self.kvc.search_guests(domain)[0]
                snapshot = libvirtmod.virDomainSnapshotCreateXML(
                    guest._o, xml, 0)
                if snapshot is not False:
                    retval = libvirtmod.virDomainSnapshotGetXMLDesc(
                        snapshot, 0)
            except:
                pass

        if retval is not False:
            kvg_guest = self.kvc.search_kvg_guests(domain)[0]
            id = self.getCurrentSnapshotName(domain)
            kvg_guest.set_current_snapshot(id)

            # ここにsnapshotのxmlファイルに親のsnapshotの情報を書き込む処理
            try:
                xml_path = self.getSnapshotXMLPath(id)

                # <parent/>が設定されてない場合
                # かつ、snapshot実行前に<currentSnapshot/>が設定されていた場合
                if self.getParentName(
                        id) is None and parent_snapshot_name is not None:
                    if os.path.exists(xml_path):
                        doc = XMLParse(xml_path)
                        parent = doc.createElement("parent")
                        name = doc.createElement("name")
                        txt = doc.createTextNode(str(parent_snapshot_name))
                        name.appendChild(txt)
                        parent.appendChild(name)
                        doc.childNodes[0].appendChild(parent)
                        xmlDesc = self.generateXML(doc)

                        ConfigFile(xml_path).write(xmlDesc)

                if os.path.exists(xml_path):
                    if os.getuid() == 0:
                        r_chgrp(xml_path, KARESANSUI_GROUP)
                        r_chmod(xml_path, "g+rw")
                        r_chmod(xml_path, "o-rwx")
            except:
                pass

        return retval
示例#12
0
def exec_script(script="",user="******",msg="",watch_name="",logfile="/dev/null"):
    retval = False

    func_name = sys._getframe(0).f_code.co_name
    append_line(logfile,"[%s] Entering function '%s'." % (func_name,func_name,))

    # スクリプトの一時保存ディレクトリを作成
    SCRIPT_TMP_DIR = "%s/tmp/.script" % (KARESANSUI_DATA_DIR,)
    if not os.path.exists(SCRIPT_TMP_DIR):
        os.makedirs(SCRIPT_TMP_DIR)
        r_chmod(SCRIPT_TMP_DIR,0770)
        r_chown(SCRIPT_TMP_DIR,KARESANSUI_USER)
        r_chgrp(SCRIPT_TMP_DIR,KARESANSUI_GROUP)
        append_line(logfile,"[%s] Create directory '%s'." % (func_name,SCRIPT_TMP_DIR,))

    try:
       user_id = int(user)
    except:
       user_id = pwd.getpwnam(user)[2]

    # スクリプトファイルの生成
    fname = None
    try:
        fd, fname  = tempfile.mkstemp(suffix="",prefix="script_",dir=SCRIPT_TMP_DIR)
        append_line(logfile,"[%s] Create script '%s'." % (func_name,fname,))
        fp = os.fdopen(fd,"w")
        fcntl.lockf(fp.fileno(), fcntl.LOCK_EX)
        script = re.sub("%{watch_name}",watch_name.encode('utf_8'),script)
        script = re.sub("%{msg}"       ,msg.encode('utf_8')       ,script)
        fp.write(script)
        fcntl.lockf(fp.fileno(), fcntl.LOCK_UN)
        fp.close()
        os.chmod(fname,0700)
        os.chown(fname,user_id,-1)

    except:
        append_line(logfile,"[%s] Error: failed to create script." % (func_name,))
        if fname is not None and os.path.exists(fname):
            os.unlink(fname)

    if fname is not None and os.path.exists(fname):

        # マジッククッキーを調べる
        magic_cookie = open(fname).readline().rstrip()
        if magic_cookie[-8:] == "bin/perl":
            interpreter = "perl"
        elif magic_cookie[-10:] == "bin/python" or \
             magic_cookie[-10:] == "env python":
            interpreter = "python"
        elif magic_cookie[-7:] == "bin/php":
            interpreter = "php"
        elif magic_cookie[-8:] == "bin/ruby":
            interpreter = "ruby"
        elif magic_cookie[-8:] == "bin/tcsh":
            interpreter = "tcsh"
        elif magic_cookie[-7:] == "bin/csh":
            interpreter = "csh"
        else:
            interpreter = "sh"

        # コマンド文字列の作成
        if os.getuid() != user_id:
            command_args = ["su","-s", "/bin/bash", user, fname]
        else:
            command_args = [interpreter,fname]

        # コマンドの実行
        append_line(logfile,"[%s] Execute command '%s'." % (func_name," ".join(command_args),))
        (rc,res) = execute_command(command_args)
        new_res = []
        for _aline in res:
            append_line(logfile,"[%s] output> %s" % (func_name,_aline,))
            _aline = re.sub("^%s:[ \t]+" % fname, "", _aline)
            new_res.append(_aline)
            pass
        append_line(logfile,"[%s] command return value = %d" % (func_name,rc,))

        os.unlink(fname)

        retval = [rc,new_res]
    else:
        append_line(logfile,"[%s] Error: cannot create script file." % (func_name,))

    append_line(logfile,"[%s] Leaving function '%s'." % (func_name,func_name,))
    return retval
示例#13
0
class XMLConfigGenerator(XMLGenerator):

    def __init__(self):
        self.config_dir = VIRT_XML_CONFIG_DIR

    def generate_xml_tree(self, config):
        config.validate()
        self.config = config

        self.begin_build()
        self.build_os()
        self.build_features()
        self.build_other()
        self.build_devices()
        self.build_behavior()
        self.end_build()

        return self.document

    def begin_build(self):
        self.document = implementation.createDocument(None,None,None)
        self.domain = self.document.createElement("domain")

        self.domain.setAttribute("type", self.config.get_domain_type())
        name = self._create_text_node("name", self.config.get_domain_name())
        uuid = self._create_text_node("uuid", self.config.get_uuid())
        self.domain.appendChild(name)
        self.domain.appendChild(uuid)
        if self.config.get_current_snapshot():
            current_snapshot = self._create_text_node("currentSnapshot", self.config.get_current_snapshot())
            self.domain.appendChild(current_snapshot)

        self.document.appendChild(self.domain)

    def build_os(self):
        doc = self.document
        os_elem = doc.createElement("os")

        if self.config.get_domain_type() == "kvm":
            type_n = self._create_text_node("type", "hvm")
            type_n.setAttribute("arch", os.uname()[4])
            type_n.setAttribute("machine", "pc")
        else:
            type_n = self._create_text_node("type", "linux")
        os_elem.appendChild(type_n)

        if self.config.get_kernel():
            os_elem.appendChild(self._create_text_node("kernel", self.config.get_kernel()))
        if self.config.get_initrd():
            os_elem.appendChild(self._create_text_node("initrd", self.config.get_initrd()))
        os_elem.appendChild(self._create_text_node("root", "/dev/" + self.config.get_disk()[0]["target"]))

        if self.config.get_boot_dev():
            boot_dev_n = doc.createElement("boot")
            boot_dev_n.setAttribute("dev", self.config.get_boot_dev())
            os_elem.appendChild(boot_dev_n)

        # additional commandline
        if self.config.get_commandline():
            os_elem.appendChild(self._create_text_node("cmdline", self.config.get_commandline()))

        self.domain.appendChild(os_elem)

    def build_features(self):
        doc = self.document
        if self.config.get_features_pae()  is True or \
           self.config.get_features_acpi() is True or \
           self.config.get_features_apic() is True:

            features_elem = doc.createElement("features")

            if self.config.get_features_pae() is True:
                features_elem.appendChild(self._create_text_node("pae",None))

            if self.config.get_features_acpi() is True:
                features_elem.appendChild(self._create_text_node("acpi",None))

            if self.config.get_features_apic() is True:
                features_elem.appendChild(self._create_text_node("apic",None))

            self.domain.appendChild(features_elem)

    def build_other(self):
        self.domain.appendChild(self._create_text_node("maxmem",
                                    str(self.config.get_max_memory("k"))))
        self.domain.appendChild(self._create_text_node("memory",
                                    str(self.config.get_memory("k"))))
        self.domain.appendChild(self._create_text_node("vcpu",
                                    str(self.config.get_max_vcpus())))
        if self.config.get_bootloader():
            self.domain.appendChild(self._create_text_node("bootloader",
                                        str(self.config.get_bootloader())))

    def build_devices(self):
        doc = self.document
        devs_elem = doc.createElement("devices")

        # graphics
        if self.config.get_graphics_port():
            graphics_n = doc.createElement("graphics")
            if self.config.get_graphics_type() == "sdl":
                graphics_n.setAttribute("type", "sdl")
            elif self.config.get_graphics_type() == "spice":
                graphics_n.setAttribute("type", "spice")
            else:
                graphics_n.setAttribute("type", "vnc")
            graphics_n.setAttribute("port", str(self.config.get_graphics_port()))
            graphics_n.setAttribute("autoport", str(self.config.get_graphics_autoport()))
            graphics_n.setAttribute("listen", str(self.config.get_graphics_listen()))
            if self.config.get_graphics_keymap() is not None:
                graphics_n.setAttribute("keymap", str(self.config.get_graphics_keymap()))
            if self.config.get_graphics_passwd() is not None:
                graphics_n.setAttribute("passwd", str(self.config.get_graphics_passwd()))
            devs_elem.appendChild(graphics_n)

        # disks
        for disk in self.config.get_disk():
            disk_n = doc.createElement("disk")

            if disk["disk_type"] == "file":
                disk_n.setAttribute("type", "file")
            elif disk["disk_type"] == "block":
                disk_n.setAttribute("type", "block")
            else:
                disk_n.setAttribute("type", "file") # default                
                
            disk_n.setAttribute("device", disk["device"])

            # disk -> driver
            driver_n = doc.createElement("driver")
            try:
                if disk["driver_name"] is not None:
                    driver_n.setAttribute("name", disk["driver_name"])
            except:
                pass
            try:
                if disk["driver_type"] is not None:
                    driver_n.setAttribute("type", disk["driver_type"])
            except:
                pass

            source_n = doc.createElement("source")
            if disk["disk_type"] == "file":
                source_n.setAttribute("file", disk["path"])
            elif disk["disk_type"] == "block":
                source_n.setAttribute("dev", disk["path"])
            else:
                source_n.setAttribute("file", disk["path"]) # default
                
            target_n = doc.createElement("target")
            target_n.setAttribute("dev", disk["target"])
            if disk["bus"] != None:
                target_n.setAttribute("bus", disk["bus"])

            disk_n.appendChild(driver_n)
            disk_n.appendChild(source_n)
            disk_n.appendChild(target_n)

            #if isset("disk['shareable']",vars=locals()) is True:
            #    disk_n.appendChild(self._create_text_node("shareable",None))

            #if isset("disk['readonly']",vars=locals()) is True:
            #    disk_n.appendChild(self._create_text_node("readonly",None))

            devs_elem.appendChild(disk_n)

        # network
        for interface in self.config.get_interface():

            interface_n = doc.createElement("interface")
            interface_n.setAttribute("type", "bridge")
            
            source_n = doc.createElement("source")
            source_n.setAttribute("bridge", interface["bridge"])
            mac_n = doc.createElement("mac")
            mac_n.setAttribute("address", interface["mac"])
            interface_n.appendChild(source_n)
            interface_n.appendChild(mac_n)
            if interface["script"] != None:
                script_n = doc.createElement("script")
                script_n.setAttribute("path", interface["script"])
                interface_n.appendChild(script_n)
            if interface["target"] != None:
                target_n = doc.createElement("target")
                target_n.setAttribute("dev", interface["target"])
                interface_n.appendChild(target_n)
            if interface["model"] != None:
                model_n = doc.createElement("model")
                model_n.setAttribute("type", interface["model"])
                interface_n.appendChild(model_n)
            devs_elem.appendChild(interface_n)
        
        self.domain.appendChild(devs_elem)

    def build_behavior(self):
        self.domain.appendChild(self._create_text_node("on_poweroff",
                                    self.config.get_behavior("on_poweroff")))
        self.domain.appendChild(self._create_text_node("on_reboot",
                                    self.config.get_behavior("on_reboot")))
        self.domain.appendChild(self._create_text_node("on_crash",
                                    self.config.get_behavior("on_crash")))

    def end_build(self):
        pass

    def writecfg(self,cfg,config_dir=None):
        if config_dir is None:
            config_dir = self.config_dir
        try:
            os.makedirs(config_dir)
        except OSError, (err, msg):
            if err != errno.EEXIST:
                raise OSError(err,msg)
        filename = "%s/%s.xml" %(config_dir,self.config.get_domain_name())
        ConfigFile(filename).write(cfg)
        r_chmod(filename,"o-rwx")
        r_chmod(filename,"g+rw")
        if os.getuid() == 0:
            r_chgrp(filename,KARESANSUI_GROUP)
示例#14
0
        r_chmod(filename,"g+rw")
        if os.getuid() == 0:
            r_chgrp(filename,KARESANSUI_GROUP)

    def copycfg(self,src_dir):
        try:
            os.makedirs(self.config_dir)
        except OSError, (err, msg):
            if err != errno.EEXIST:
                raise OSError(err,msg)
            
        src_filename = "%s/%s.xml" %(src_dir ,self.config.get_domain_name())
        filename = "%s/%s.xml" %(self.config_dir,self.config.get_domain_name())
        
        shutil.copy(src_filename, filename)
        r_chmod(filename,"o-rwx")
        r_chmod(filename,"g+rw")
        if os.getuid() == 0:
            r_chgrp(filename,KARESANSUI_GROUP)

    def removecfg(self, config_dir=None):
        if config_dir is None:
            config_dir = self.config_dir

        filename = "%s/%s.xml" %(config_dir,self.config.get_domain_name())
        if os.path.exists(filename):
            os.unlink(filename)

def sync_config_generator(param, domname=None):

    domain_type = param.get_domain_type()
示例#15
0
文件: conf.py 项目: AdUser/karesansui
def write_conf(dop, webobj=None, machine=None, modules=[], extra_args={}):
    """<comment-ja>
    @param dop: 辞書配列操作オブジェクト
    @param webobj: 
    @param machine: 
    @type dop: object dict_op
    @rtype: boolean
    @return: True or False
    </comment-ja>
    <comment-en>
    TODO: English Comment
    </comment-en>
    """
    from karesansui.lib.file.configfile import ConfigFile

    if isinstance(dop,karesansui.lib.dict_op.DictOp) is False:
        return False

    if not os.path.exists(CONF_TMP_DIR):
        os.makedirs(CONF_TMP_DIR)
        r_chmod(CONF_TMP_DIR,0770)
        r_chown(CONF_TMP_DIR,KARESANSUI_USER)
        r_chgrp(CONF_TMP_DIR,KARESANSUI_GROUP)

    serial = time.strftime("%Y%m%d%H%M%S",time.localtime())

    if len(modules) == 0:
        modules = dop.ModuleNames

    w_modules = []
    w_files   = []
    for _module in modules:
        if _module in dop.ModuleNames:
            filename = "%s/%s.%s" % (CONF_TMP_DIR,_module,serial,)
            data = preprint_r(dop.getconf(_module),return_var=True)
            ConfigFile(filename).write(data+"\n")
            r_chmod(filename,0660)
            r_chown(filename,KARESANSUI_USER)
            r_chgrp(filename,KARESANSUI_GROUP)
            w_modules.append(_module)
            w_files.append(filename)

    if len(w_modules) == 0:
        return False

    options = {
         "module"     : ":".join(w_modules),
         "input-file" : ":".join(w_files),
    }
    options["delete"] = None

    try:
        extra_args['pre-command']
        options['pre-command'] = "b64:" + base64_encode(extra_args['pre-command'])
    except:
        pass
    try:
        extra_args['post-command']
        options['post-command'] = "b64:" + base64_encode(extra_args['post-command'])
    except:
        pass

    try:
        options['include'] = extra_args['include']
    except:
        pass

    #cmd_name = u"Write Settings - %s" % ":".join(w_modules)
    cmd_name = u"Write Settings"

    if type(webobj) == types.InstanceType:
        from karesansui.db.model._2pysilhouette import Job, JobGroup, \
                                                       JOBGROUP_TYPE
        from karesansui.db.access._2pysilhouette import jg_findby1, jg_save,corp
        from karesansui.db.access._2pysilhouette import save_job_collaboration
        from karesansui.db.access.machine2jobgroup import new as m2j_new
        from pysilhouette.command import dict2command

        _cmd = dict2command(
            "%s/%s" % (karesansui.config['application.bin.dir'],
                       CONFIGURE_COMMAND_WRITE), options)

        _jobgroup = JobGroup(cmd_name, karesansui.sheconf['env.uniqkey'])
        _jobgroup.jobs.append(Job('%s command' % cmd_name, 0, _cmd))

        _machine2jobgroup = m2j_new(machine=machine,
                                jobgroup_id=-1,
                                uniq_key=karesansui.sheconf['env.uniqkey'],
                                created_user=webobj.me,
                                modified_user=webobj.me,
                                )

        save_job_collaboration(webobj.orm,
                               webobj.pysilhouette.orm,
                               _machine2jobgroup,
                               _jobgroup,
                               )

        """
        _jobgroup.type = JOBGROUP_TYPE['PARALLEL']
        if corp(webobj.orm, webobj.pysilhouette.orm,_machine2jobgroup, _jobgroup) is False:
            webobj.logger.debug("%s command failed. Return to timeout" % (cmd_name))
            for filename in w_files:
                if os.path.exists(filename):
                    os.unlink(filename)
            return False

        cmd_res = jobgroup.jobs[0].action_stdout
        """

    else:
        from karesansui.lib.utils import execute_command

        opts_str = ""
        for x in options.keys():
            if options[x] is None:
                opts_str += "--%s " % x 
            else:
                opts_str += "--%s=%s " % (x, options[x])

        _cmd = "%s/bin/%s %s" % (KARESANSUI_PREFIX, CONFIGURE_COMMAND_WRITE, opts_str.strip(),)

        command_args = _cmd.strip().split(" ")
        (rc,res) = execute_command(command_args)
        if rc != 0:
            for filename in w_files:
                if os.path.exists(filename):
                    os.unlink(filename)
            return False

        cmd_res = "\n".join(res)

    """
    for filename in w_files:
        if os.path.exists(filename):
            os.unlink(filename)
    """

    return True
示例#16
0
class NetworkXMLConfigGenerator(NetworkXMLGenerator):
    def __init__(self):
        self.config_dir = VIRT_NETWORK_CONFIG_DIR

    def generate_xml_tree(self, config):
        config.validate()
        self.config = config

        self.begin_build()
        self.build_bridge()
        self.build_forward()
        self.build_ip()
        self.end_build()

        return self.document

    def begin_build(self):
        self.document = implementation.createDocument(None, None, None)
        self.network = self.document.createElement("network")

        name = self._create_text_node("name", self.config.get_network_name())
        uuid = self._create_text_node("uuid", self.config.get_uuid())
        self.network.appendChild(name)
        self.network.appendChild(uuid)

        self.document.appendChild(self.network)

    def build_bridge(self):
        doc = self.document
        if self.config.get_bridge():
            bridge = doc.createElement("bridge")
            bridge.setAttribute("name", self.config.get_bridge())

            if self.config.get_bridge_stp() is not None:
                bridge.setAttribute("stp", self.config.get_bridge_stp())
            else:
                bridge.setAttribute("stp", "on")

            if self.config.get_bridge_forwardDelay() is not None:
                bridge.setAttribute("forwardDelay",
                                    self.config.get_bridge_forwardDelay())
            else:
                bridge.setAttribute("forwardDelay", "0")

            self.network.appendChild(bridge)

    def build_forward(self):
        doc = self.document
        if self.config.get_forward_dev() is not None or \
           self.config.get_forward_mode() is not None:

            forward = doc.createElement("forward")
            if self.config.get_forward_dev() is not None:
                forward.setAttribute("dev", self.config.get_forward_dev())
            if self.config.get_forward_mode() is not None:
                forward.setAttribute("mode", self.config.get_forward_mode())
            self.network.appendChild(forward)

    def build_ip(self):
        doc = self.document
        ip = doc.createElement("ip")
        ip.setAttribute("netmask", self.config.get_netmask())
        ip.setAttribute("address", self.config.get_ipaddr())
        self.network.appendChild(ip)

        dhcp = doc.createElement("dhcp")
        range = doc.createElement("range")
        range.setAttribute("start", self.config.get_dhcp_start())
        range.setAttribute("end", self.config.get_dhcp_end())
        dhcp.appendChild(range)
        ip.appendChild(dhcp)

    def end_build(self):
        pass

    def writecfg(self, cfg):
        try:
            os.makedirs(self.config_dir)
        except OSError, (err, msg):
            if err != errno.EEXIST:
                raise OSError(err, msg)

        filename = "%s/%s.xml" % (self.config_dir,
                                  self.config.get_network_name())
        ConfigFile(filename).write(cfg)
        r_chmod(filename, "o-rwx")
        r_chmod(filename, "g+rw")
        if os.getuid() == 0:
            r_chgrp(filename, KARESANSUI_GROUP)