X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sliver_vs.py;h=c4dfadbc41d6e945ed49ca538dba0799ff555c88;hb=ccc7b9c4b76a89faad66867b00d16ac45333b6de;hp=ef5b6b21d8146eb205718206f0572f1f5ddaed0d;hpb=915acb08cad7ad57c615e53864e53dc5e742ce94;p=nodemanager.git

diff --git a/sliver_vs.py b/sliver_vs.py
index ef5b6b2..c4dfadb 100644
--- a/sliver_vs.py
+++ b/sliver_vs.py
@@ -1,3 +1,5 @@
+#
+
 """VServer slivers.
 
 There are a couple of tricky things going on here.  First, the kernel
@@ -17,16 +19,20 @@ don't have to guess if there is a running process or not.
 """
 
 import errno
+import traceback
 import os, os.path
+import sys
 import time
+from threading import BoundedSemaphore
+import subprocess
+
+# the util-vserver-pl module
 import vserver
 
-import accounts
 import logger
 import tools
-from threading import BoundedSemaphore
-
-globalsem = BoundedSemaphore()
+from account import Account
+from initscript import Initscript
 
 # special constant that tells vserver to keep its existing settings
 KEEP_LIMIT = vserver.VC_LIM_KEEP
@@ -40,155 +46,167 @@ for rlimit in vserver.RLIMITS.keys():
     DEFAULT_ALLOCATION["%s_soft"%rlim]=KEEP_LIMIT
     DEFAULT_ALLOCATION["%s_hard"%rlim]=KEEP_LIMIT
 
-class Sliver_VS(accounts.Account, vserver.VServer):
+class Sliver_VS(vserver.VServer, Account, Initscript):
     """This class wraps vserver.VServer to make its interface closer to what we need."""
 
     SHELL = '/bin/vsh'
     TYPE = 'sliver.VServer'
-    _init_disk_info_sem = globalsem
+    _init_disk_info_sem = BoundedSemaphore()
 
     def __init__(self, rec):
-        logger.verbose ('initing Sliver_VS with name=%s'%rec['name'])
+        name=rec['name']
+        logger.verbose ('sliver_vs: %s init'%name)
         try:
-            vserver.VServer.__init__(self, rec['name'],logfile='/var/log/nm')
+            logger.log("sliver_vs: %s: first chance..."%name)
+            vserver.VServer.__init__(self, name,logfile='/var/log/nodemanager')
+            Account.__init__ (self, name)
+            Initscript.__init__ (self, name)
         except Exception, err:
             if not isinstance(err, vserver.NoSuchVServer):
                 # Probably a bad vserver or vserver configuration file
-                logger.log_exc(self.name)
-                logger.log('%s: recreating bad vserver' % rec['name'])
-                self.destroy(rec['name'])
-            self.create(rec['name'], rec['vref'])
-            vserver.VServer.__init__(self, rec['name'],logfile='/var/log/nm')
+                logger.log_exc("sliver_vs:__init__ (first chance) %s",name=name)
+                logger.log('sliver_vs: %s: recreating bad vserver' % name)
+                self.destroy(name)
+            self.create(name, rec)
+            vserver.VServer.__init__(self, name,logfile='/var/log/nodemanager')
+            Account.__init__ (self, name)
+            Initscript.__init__ (self, name)
 
-        self.keys = ''
         self.rspec = {}
-        self.initscript = ''
         self.slice_id = rec['slice_id']
         self.disk_usage_initialized = False
-        self.initscriptchanged = False
+        self.enabled = True
+        # xxx this almost certainly is wrong...
         self.configure(rec)
 
     @staticmethod
-    def create(name, vref = None):
-        logger.verbose('Sliver_VS:create - name=%s'%name)
+    def create(name, rec = None):
+        logger.verbose('sliver_vs: %s: create'%name)
+        vref = rec['vref']
         if vref is None:
-            vref='default'
+            # added by caglar
+            # band-aid for short period as old API doesn't have GetSliceFamily function
+            vref = "planetlab-f8-i386"
+            logger.log("sliver_vs: %s: ERROR - no vref attached, using hard-wired default %s"%(name,vref))
+
+        # used to look in /etc/planetlab/family,
+        # now relies on the 'GetSliceFamily' extra attribute in GetSlivers()
+        # which for legacy is still exposed here as the 'vref' key
+
+        # check the template exists -- there's probably a better way..
+        if not os.path.isdir ("/vservers/.vref/%s"%vref):
+            logger.log ("sliver_vs: %s: ERROR Could not create sliver - vreference image %s not found"%(name,vref))
+            return
+
+        # compute guest personality
         try:
-            ### locating the right slicefamily
-            # this is a first draft, and more a proof of concept thing
-            # the idea is to parse vref for dash-separated wishes,
-            # and to project these against the defaults
-            # so e.g. if the default slice family (as found in /etc/planetlab/slicefamily)
-            # is planetlab-f8-i386, then here is what we get
-            # vref=x86_64             -> vuseradd -t planetlab-f8-x86_64 
-            # vref=centos5            -> vuseradd -t planetlab-centos5-i386 
-            # vref=centos5-onelab     -> vuseradd -t onelab-centos5-i386 
-            # vref=planetflow         -> vuseradd -t planetflow-f8-i386
-            # vref=x86_64-planetflow  -> vuseradd -t planetflow-f8-x86_64
-
-            # default
-            default=file("/etc/planetlab/slicefamily").read().strip()
-            (pldistro,fcdistro,arch) = default.split("-")
-
-            known_archs = [ 'i386', 'x86_64' ]
-            known_fcdistros = [ 'f8', 'f9', 'centos5' ]
-            # from the slice attribute: cut dashes and try to figure the meaning
-            slice_wishes = vref.split("-")
-            for wish in slice_wishes:
-                if wish in known_archs:
-                    arch=wish
-                elif wish in known_fcdistros:
-                    fcdistro=wish
-                else:
-                    pldistro=wish
-
-            # rejoin the parts
-            refname="-".join( (pldistro,fcdistro,arch) )
-
-            # check the templates exists -- there's probably a better way..
-            if not (os.path.isdir ("/vservers/.vref/%s"% refname) or 
-            os.path.isdir ("/vservers/.vref/%s"% vref)):
-                logger.verbose("%s (%s) : vref %s not found, using default %s"%(
-                        name,vref,refname,default))
-                refname=default
-                # could check again, but as we have /etc/slicefamily 
-                # there's probably no /vservers/.vref/default
-
-        except IOError:
-            # have not found slicefamily
-            logger.verbose("%s (%s): legacy node - using fallback vrefname 'default'"%(name,vref))
-                # for legacy nodes
-            refname="default"
+            (x,y,arch)=vref.split('-')
+        # mh, this of course applies when 'vref' is e.g. 'netflow'
+        # and that's not quite right
         except:
-            import traceback
-            logger.log("%s (%s) : unexpected error follows - using 'default'"%(
-                    name,vref))
-            logger.log(traceback.format_exc())
-            refname="default"
-            
-        logger.log_call('/usr/sbin/vuseradd', '-t', refname, name)
-        open('/vservers/%s/etc/slicename' % name, 'w').write(name)
+            arch='i386'
+
+        def personality (arch): return "linux64" if arch.find("64") >=0 else "linux32"
+
+        command=[]
+        # be verbose
+        command += ['/bin/bash','-x',]
+        command += ['/usr/sbin/vuseradd', ]
+        if 'attributes' in rec and 'isolate_loopback' in rec['attributes'] and rec['attributes']['isolate_loopback'] == '1':
+            command += [ "-i",]
+        # the vsliver imge to use
+        command += [ '-t', vref, ]
+        # slice name
+        command += [ name, ]            
+        logger.log_call(command, timeout=15*60)
+        # export slicename to the slice in /etc/slicename
+        file('/vservers/%s/etc/slicename' % name, 'w').write(name)
+        file('/vservers/%s/etc/slicefamily' % name, 'w').write(vref)
+        # set personality: only if needed (if arch's differ)
+        if tools.root_context_arch() != arch:
+            file('/etc/vservers/%s/personality' % name, 'w').write(personality(arch)+"\n")
+            logger.log('sliver_vs: %s: set personality to %s'%(name,personality(arch)))
 
     @staticmethod
-    def destroy(name): logger.log_call('/usr/sbin/vuserdel', name)
+    def destroy(name):
+        # need to umount before we trash, otherwise we end up with sequels in 
+        # /vservers/slicename/ (namely in home/ )
+        # also because this is a static method we cannot check for 'omf_control'
+        # but it is no big deal as umount_ssh_dir checks before it umounts..
+        Account.umount_ssh_dir(name)
+        logger.log("sliver_vs: destroying %s"%name)
+        logger.log_call(['/bin/bash','-x','/usr/sbin/vuserdel', name, ])
+
 
     def configure(self, rec):
+        # in case we update nodemanager..
+        self.install_and_enable_vinit()
+
         new_rspec = rec['_rspec']
         if new_rspec != self.rspec:
             self.rspec = new_rspec
             self.set_resources()
 
-        new_initscript = rec['initscript']
-        if new_initscript != self.initscript:
-            self.initscript = new_initscript
-            logger.log('%s: installing initscript' % self.name)
-            def install_initscript():
-                flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
-                fd = os.open('/etc/rc.vinit', flags, 0755)
-                os.write(fd, new_initscript)
-                os.close(fd)
-            try:
-                self.chroot_call(install_initscript)
-                self.initscriptchanged = True
-            except: logger.log_exc(self.name)
+        # do the configure part from Initscript
+        Initscript.configure(self,rec)
 
-        accounts.Account.configure(self, rec)  # install ssh keys
+        Account.configure(self, rec)  # install ssh keys
 
+    # remember configure() always gets called *before* start()
     def start(self, delay=0):
-        if self.rspec['enabled'] > 0:
-            logger.log('%s: starting in %d seconds' % (self.name, delay))
-            time.sleep(delay)
-            child_pid = os.fork()
-            if child_pid == 0:
-                # VServer.start calls fork() internally, 
-                # so just close the nonstandard fds and fork once to avoid creating zombies
-                tools.close_nonstandard_fds()
-                vserver.VServer.start(self)
-                os._exit(0)
-            else: os.waitpid(child_pid, 0)
-        else: logger.log('%s: not starting, is not enabled' % self.name)
-        self.initscriptchanged = False
+        if self.rspec['enabled'] <= 0:
+            logger.log('sliver_vs: not starting %s, is not enabled'%self.name)
+            return
+        logger.log('sliver_vs: %s: starting in %d seconds' % (self.name, delay))
+        time.sleep(delay)
+        # the generic /etc/init.d/vinit script is permanently refreshed, and enabled
+        self.install_and_enable_vinit()
+        # expose .ssh for omf_friendly slivers
+        if 'omf_control' in self.rspec['tags']:
+            Account.mount_ssh_dir(self.name)
+        # if a change has occured in the slice initscript, reflect this in /etc/init.d/vinit.slice
+        self.refresh_slice_vinit()
+        child_pid = os.fork()
+        if child_pid == 0:
+            # VServer.start calls fork() internally,
+            # so just close the nonstandard fds and fork once to avoid creating zombies
+            tools.close_nonstandard_fds()
+            vserver.VServer.start(self)
+            os._exit(0)
+        else:
+            os.waitpid(child_pid, 0)
 
     def stop(self):
-        logger.log('%s: stopping' % self.name)
+        logger.log('sliver_vs: %s: stopping' % self.name)
         vserver.VServer.stop(self)
 
+    def is_running(self):
+        return vserver.VServer.is_running(self)
+
+    # this one seems to belong in Initscript at first sight, 
+    # but actually depends on the underlying vm techno
+    # so let's keep it here
+    def rerun_slice_vinit(self):
+        command = "/usr/sbin/vserver %s exec /etc/rc.d/init.d/vinit restart" % (self.name)
+        logger.log("vsliver_vs: %s: Rerunning slice initscript: %s" % (self.name, command))
+        subprocess.call(command + "&", stdin=open('/dev/null', 'r'), stdout=open('/dev/null', 'w'), stderr=subprocess.STDOUT, shell=True)
+
     def set_resources(self):
         disk_max = self.rspec['disk_max']
-        logger.log('%s: setting max disk usage to %d KiB' % (self.name, disk_max))
+        logger.log('sliver_vs: %s: setting max disk usage to %d KiB' % (self.name, disk_max))
         try:  # if the sliver is over quota, .set_disk_limit will throw an exception
             if not self.disk_usage_initialized:
                 self.vm_running = False
-                logger.log('%s: computing disk usage: beginning' % self.name)
                 Sliver_VS._init_disk_info_sem.acquire()
+                logger.log('sliver_vs: %s: computing disk usage: beginning' % self.name)
+                # init_disk_info is inherited from VServer
                 try: self.init_disk_info()
                 finally: Sliver_VS._init_disk_info_sem.release()
-                logger.log('%s: computing disk usage: ended' % self.name)
+                logger.log('sliver_vs: %s: computing disk usage: ended' % self.name)
                 self.disk_usage_initialized = True
             vserver.VServer.set_disklimit(self, max(disk_max, self.disk_blocks))
         except:
-            logger.log('%s: failed to set max disk usage' % self.name)
-            logger.log_exc(self.name)
+            logger.log_exc('sliver_vs: failed to set max disk usage',name=self.name)
 
         # get/set the min/soft/hard values for all of the vserver
         # related RLIMITS.  Note that vserver currently only
@@ -200,41 +218,84 @@ class Sliver_VS(accounts.Account, vserver.VServer):
             hard = self.rspec['%s_hard'%type]
             update = self.set_rlimit(limit, hard, soft, minimum)
             if update:
-                logger.log('%s: setting rlimit %s to (%d, %d, %d)'
+                logger.log('sliver_vs: %s: setting rlimit %s to (%d, %d, %d)'
                            % (self.name, type, hard, soft, minimum))
 
         self.set_capabilities_config(self.rspec['capabilities'])
         if self.rspec['capabilities']:
-            logger.log('%s: setting capabilities to %s' % (self.name, self.rspec['capabilities']))
+            logger.log('sliver_vs: %s: setting capabilities to %s' % (self.name, self.rspec['capabilities']))
 
         cpu_pct = self.rspec['cpu_pct']
         cpu_share = self.rspec['cpu_share']
 
+        count = 1
+        for key in self.rspec.keys():
+            if key.find('sysctl.') == 0:
+                sysctl=key.split('.')
+                try:
+                    # /etc/vservers/<guest>/sysctl/<id>/
+                    dirname = "/etc/vservers/%s/sysctl/%s" % (self.name, count)
+                    try:
+                        os.makedirs(dirname, 0755)
+                    except:
+                        pass
+                    setting = open("%s/setting" % dirname, "w")
+                    setting.write("%s\n" % key.lstrip("sysctl."))
+                    setting.close()
+                    value = open("%s/value" % dirname, "w")
+                    value.write("%s\n" % self.rspec[key])
+                    value.close()
+                    count += 1
+
+                    logger.log("sliver_vs: %s: writing %s=%s"%(self.name,key,self.rspec[key]))
+                except IOError, e:
+                    logger.log("sliver_vs: %s: could not set %s=%s"%(self.name,key,self.rspec[key]))
+                    logger.log("sliver_vs: %s: error = %s"%(self.name,e))
+
+
         if self.rspec['enabled'] > 0:
             if cpu_pct > 0:
-                logger.log('%s: setting cpu reservation to %d%%' % (self.name, cpu_pct))
+                logger.log('sliver_vs: %s: setting cpu reservation to %d%%' % (self.name, cpu_pct))
             else:
                 cpu_pct = 0
 
             if cpu_share > 0:
-                logger.log('%s: setting cpu share to %d' % (self.name, cpu_share))
+                logger.log('sliver_vs: %s: setting cpu share to %d' % (self.name, cpu_share))
             else:
                 cpu_share = 0
 
             self.set_sched_config(cpu_pct, cpu_share)
             # if IP address isn't set (even to 0.0.0.0), sliver won't be able to use network
             if self.rspec['ip_addresses'] != '0.0.0.0':
-                logger.log('%s: setting IP address(es) to %s' % \
+                logger.log('sliver_vs: %s: setting IP address(es) to %s' % \
                 (self.name, self.rspec['ip_addresses']))
-            self.set_ipaddresses_config(self.rspec['ip_addresses'])
+            add_loopback = True
+            if 'isolate_loopback' in self.rspec['tags']:
+                add_loopback = self.rspec['tags']['isolate_loopback'] != "1"
+            self.set_ipaddresses_config(self.rspec['ip_addresses'], add_loopback)
+
+            #logger.log("sliver_vs: %s: Setting name to %s" % (self.name, self.slice_id))
+            #self.setname(self.slice_id)
+            #logger.log("sliver_vs: %s: Storing slice id of %s for PlanetFlow" % (self.name, self.slice_id))
+            try:
+                vserver_config_path = '/etc/vservers/%s'%self.name
+                if not os.path.exists (vserver_config_path):
+                    os.makedirs (vserver_config_path)
+                file('%s/slice_id'%vserver_config_path, 'w').write("%d\n"%self.slice_id)
+                logger.log("sliver_vs: Recorded slice id %d for slice %s"%(self.slice_id,self.name))
+            except IOError,e:
+                logger.log("sliver_vs: Could not record slice_id for slice %s. Error: %s"%(self.name,str(e)))
+            except Exception,e:
+                logger.log_exc("sliver_vs: Error recording slice id: %s"%str(e),name=self.name)
+
+
+            if self.enabled == False:
+                self.enabled = True
+                self.start()
 
-            if self.is_running():
-                logger.log("%s: Setting name to %s" % (self.name, self.slice_id),2)
-                self.setname(self.slice_id)
- 
             if False: # Does not work properly yet.
                 if self.have_limits_changed():
-                    logger.log('%s: limits have changed --- restarting' % self.name)
+                    logger.log('sliver_vs: %s: limits have changed --- restarting' % self.name)
                     stopcount = 10
                     while self.is_running() and stopcount > 0:
                         self.stop()
@@ -244,6 +305,7 @@ class Sliver_VS(accounts.Account, vserver.VServer):
                     self.start()
 
         else:  # tell vsh to disable remote login by setting CPULIMIT to 0
-            logger.log('%s: disabling remote login' % self.name)
+            logger.log('sliver_vs: %s: disabling remote login' % self.name)
             self.set_sched_config(0, 0)
+            self.enabled = False
             self.stop()