sliver_vs.py

   1 #
   2
   3 """VServer slivers.
   4
   5 There are a couple of tricky things going on here.  First, the kernel
   6 needs disk usage information in order to enforce the quota.  However,
   7 determining disk usage redundantly strains the disks.  Thus, the
   8 Sliver_VS.disk_usage_initialized flag is used to determine whether
   9 this initialization has been made.
  10
  11 Second, it's not currently possible to set the scheduler parameters
  12 for a sliver unless that sliver has a running process.  /bin/vsh helps
  13 us out by reading the configuration file so that it can set the
  14 appropriate limits after entering the sliver context.  Making the
  15 syscall that actually sets the parameters gives a harmless error if no
  16 process is running.  Thus we keep vm_running on when setting scheduler
  17 parameters so that set_sched_params() always makes the syscall, and we
  18 don't have to guess if there is a running process or not.
  19 """
  20
  21 import errno
  22 import traceback
  23 import os, os.path
  24 import sys
  25 import time
  26 from threading import BoundedSemaphore
  27 import subprocess
  28
  29 # the util-vserver-pl module
  30 import vserver
  31
  32 import logger
  33 import tools
  34 from account import Account
  35 from initscript import Initscript
  36
  37 # special constant that tells vserver to keep its existing settings
  38 KEEP_LIMIT = vserver.VC_LIM_KEEP
  39
  40 # populate the sliver/vserver specific default allocations table,
  41 # which is used to look for slice attributes
  42 DEFAULT_ALLOCATION = {}
  43 for rlimit in vserver.RLIMITS.keys():
  44     rlim = rlimit.lower()
  45     DEFAULT_ALLOCATION["%s_min"%rlim]=KEEP_LIMIT
  46     DEFAULT_ALLOCATION["%s_soft"%rlim]=KEEP_LIMIT
  47     DEFAULT_ALLOCATION["%s_hard"%rlim]=KEEP_LIMIT
  48
  49 class Sliver_VS(vserver.VServer, Account, Initscript):
  50     """This class wraps vserver.VServer to make its interface closer to what we need."""
  51
  52     SHELL = '/bin/vsh'
  53     TYPE = 'sliver.VServer'
  54     _init_disk_info_sem = BoundedSemaphore()
  55
  56     def __init__(self, rec):
  57         name=rec['name']
  58         logger.verbose ('sliver_vs: %s init'%name)
  59         try:
  60             logger.log("sliver_vs: %s: first chance..."%name)
  61             vserver.VServer.__init__(self, name,logfile='/var/log/nodemanager')
  62             Account.__init__ (self, name)
  63             Initscript.__init__ (self, name)
  64         except Exception, err:
  65             if not isinstance(err, vserver.NoSuchVServer):
  66                 # Probably a bad vserver or vserver configuration file
  67                 logger.log_exc("sliver_vs:__init__ (first chance) %s",name=name)
  68                 logger.log('sliver_vs: %s: recreating bad vserver' % name)
  69                 self.destroy(name)
  70             self.create(name, rec)
  71             vserver.VServer.__init__(self, name,logfile='/var/log/nodemanager')
  72             Account.__init__ (self, name)
  73             Initscript.__init__ (self, name)
  74
  75         self.rspec = {}
  76         self.slice_id = rec['slice_id']
  77         self.disk_usage_initialized = False
  78         self.enabled = True
  79         # xxx this almost certainly is wrong...
  80         self.configure(rec)
  81
  82     @staticmethod
  83     def create(name, rec = None):
  84         logger.verbose('sliver_vs: %s: create'%name)
  85         vref = rec['vref']
  86         if vref is None:
  87             logger.log("sliver_vs: %s: ERROR - no vref attached, this is unexpected"%(name))
  88             # added by caglar
  89             # band-aid for short period as old API doesn't have GetSliceFamily function
  90             #return
  91             vref = "planetlab-f8-i386"
  92
  93         # used to look in /etc/planetlab/family,
  94         # now relies on the 'GetSliceFamily' extra attribute in GetSlivers()
  95         # which for legacy is still exposed here as the 'vref' key
  96
  97         # check the template exists -- there's probably a better way..
  98         if not os.path.isdir ("/vservers/.vref/%s"%vref):
  99             logger.log ("sliver_vs: %s: ERROR Could not create sliver - vreference image %s not found"%(name,vref))
 100             return
 101
 102         # guess arch
 103         try:
 104             (x,y,arch)=vref.split('-')
 105         # mh, this of course applies when 'vref' is e.g. 'netflow'
 106         # and that's not quite right
 107         except:
 108             arch='i386'
 109
 110         def personality (arch):
 111             personality="linux32"
 112             if arch.find("64")>=0:
 113                 personality="linux64"
 114             return personality
 115
 116         command=[]
 117         # be verbose
 118         command += ['/bin/bash','-x',]
 119         command += ['/usr/sbin/vuseradd', ]
 120         if 'attributes' in rec and 'isolate_loopback' in rec['attributes'] and rec['attributes']['isolate_loopback'] == '1':
 121             command += [ "-i",]
 122         # the vsliver imge to use
 123         command += [ '-t', vref, ]
 124         # slice name
 125         command += [ name, ]
 126         logger.log_call(command, timeout=15*60)
 127         # export slicename to the slice in /etc/slicename
 128         file('/vservers/%s/etc/slicename' % name, 'w').write(name)
 129         file('/vservers/%s/etc/slicefamily' % name, 'w').write(vref)
 130         # set personality: only if needed (if arch's differ)
 131         if tools.root_context_arch() != arch:
 132             file('/etc/vservers/%s/personality' % name, 'w').write(personality(arch)+"\n")
 133             logger.log('sliver_vs: %s: set personality to %s'%(name,personality(arch)))
 134
 135     @staticmethod
 136     def destroy(name):
 137         logger.log_call(['/bin/bash','-x','/usr/sbin/vuserdel', name, ])
 138
 139     def configure(self, rec):
 140         # in case we update nodemanager..
 141         self.install_and_enable_vinit()
 142
 143         new_rspec = rec['_rspec']
 144         if new_rspec != self.rspec:
 145             self.rspec = new_rspec
 146             self.set_resources()
 147
 148         # do the configure part from Initscript
 149         Initscript.configure(self,rec)
 150
 151         Account.configure(self, rec)  # install ssh keys
 152
 153     def start(self, delay=0):
 154         if self.rspec['enabled'] <= 0:
 155             logger.log('sliver_vs: not starting %s, is not enabled'%self.name)
 156         else:
 157             logger.log('sliver_vs: %s: starting in %d seconds' % (self.name, delay))
 158             time.sleep(delay)
 159             # the generic /etc/init.d/vinit script is permanently refreshed, and enabled
 160             self.install_and_enable_vinit()
 161             # expose .ssh for omf_friendly slivers
 162             if 'omf_control' in self.rspec['tags']:
 163                 self.expose_ssh_dir()
 164             # if a change has occured in the slice initscript, reflect this in /etc/init.d/vinit.slice
 165             self.refresh_slice_vinit()
 166             child_pid = os.fork()
 167             if child_pid == 0:
 168                 # VServer.start calls fork() internally,
 169                 # so just close the nonstandard fds and fork once to avoid creating zombies
 170                 tools.close_nonstandard_fds()
 171                 vserver.VServer.start(self)
 172                 os._exit(0)
 173             else:
 174                 os.waitpid(child_pid, 0)
 175
 176     def stop(self):
 177         logger.log('sliver_vs: %s: stopping' % self.name)
 178         vserver.VServer.stop(self)
 179
 180     def is_running(self):
 181         return vserver.VServer.is_running(self)
 182
 183     # this one seems to belong in Initscript at first sight,
 184     # but actually depends on the underlying vm techno
 185     # so let's keep it here
 186     def rerun_slice_vinit(self):
 187         command = "/usr/sbin/vserver %s exec /etc/rc.d/init.d/vinit restart" % (self.name)
 188         logger.log("vsliver_vs: %s: Rerunning slice initscript: %s" % (self.name, command))
 189         subprocess.call(command + "&", stdin=open('/dev/null', 'r'), stdout=open('/dev/null', 'w'), stderr=subprocess.STDOUT, shell=True)
 190
 191     def set_resources(self):
 192         disk_max = self.rspec['disk_max']
 193         logger.log('sliver_vs: %s: setting max disk usage to %d KiB' % (self.name, disk_max))
 194         try:  # if the sliver is over quota, .set_disk_limit will throw an exception
 195             if not self.disk_usage_initialized:
 196                 self.vm_running = False
 197                 Sliver_VS._init_disk_info_sem.acquire()
 198                 logger.log('sliver_vs: %s: computing disk usage: beginning' % self.name)
 199                 # init_disk_info is inherited from VServer
 200                 try: self.init_disk_info()
 201                 finally: Sliver_VS._init_disk_info_sem.release()
 202                 logger.log('sliver_vs: %s: computing disk usage: ended' % self.name)
 203                 self.disk_usage_initialized = True
 204             vserver.VServer.set_disklimit(self, max(disk_max, self.disk_blocks))
 205         except:
 206             logger.log_exc('sliver_vs: failed to set max disk usage',name=self.name)
 207
 208         # get/set the min/soft/hard values for all of the vserver
 209         # related RLIMITS.  Note that vserver currently only
 210         # implements support for hard limits.
 211         for limit in vserver.RLIMITS.keys():
 212             type = limit.lower()
 213             minimum  = self.rspec['%s_min'%type]
 214             soft = self.rspec['%s_soft'%type]
 215             hard = self.rspec['%s_hard'%type]
 216             update = self.set_rlimit(limit, hard, soft, minimum)
 217             if update:
 218                 logger.log('sliver_vs: %s: setting rlimit %s to (%d, %d, %d)'
 219                            % (self.name, type, hard, soft, minimum))
 220
 221         self.set_capabilities_config(self.rspec['capabilities'])
 222         if self.rspec['capabilities']:
 223             logger.log('sliver_vs: %s: setting capabilities to %s' % (self.name, self.rspec['capabilities']))
 224
 225         cpu_pct = self.rspec['cpu_pct']
 226         cpu_share = self.rspec['cpu_share']
 227
 228         count = 1
 229         for key in self.rspec.keys():
 230             if key.find('sysctl.') == 0:
 231                 sysctl=key.split('.')
 232                 try:
 233                     # /etc/vservers/<guest>/sysctl/<id>/
 234                     dirname = "/etc/vservers/%s/sysctl/%s" % (self.name, count)
 235                     try:
 236                         os.makedirs(dirname, 0755)
 237                     except:
 238                         pass
 239                     setting = open("%s/setting" % dirname, "w")
 240                     setting.write("%s\n" % key.lstrip("sysctl."))
 241                     setting.close()
 242                     value = open("%s/value" % dirname, "w")
 243                     value.write("%s\n" % self.rspec[key])
 244                     value.close()
 245                     count += 1
 246
 247                     logger.log("sliver_vs: %s: writing %s=%s"%(self.name,key,self.rspec[key]))
 248                 except IOError, e:
 249                     logger.log("sliver_vs: %s: could not set %s=%s"%(self.name,key,self.rspec[key]))
 250                     logger.log("sliver_vs: %s: error = %s"%(self.name,e))
 251
 252
 253         if self.rspec['enabled'] > 0:
 254             if cpu_pct > 0:
 255                 logger.log('sliver_vs: %s: setting cpu reservation to %d%%' % (self.name, cpu_pct))
 256             else:
 257                 cpu_pct = 0
 258
 259             if cpu_share > 0:
 260                 logger.log('sliver_vs: %s: setting cpu share to %d' % (self.name, cpu_share))
 261             else:
 262                 cpu_share = 0
 263
 264             self.set_sched_config(cpu_pct, cpu_share)
 265             # if IP address isn't set (even to 0.0.0.0), sliver won't be able to use network
 266             if self.rspec['ip_addresses'] != '0.0.0.0':
 267                 logger.log('sliver_vs: %s: setting IP address(es) to %s' % \
 268                 (self.name, self.rspec['ip_addresses']))
 269             add_loopback = True
 270             if 'isolate_loopback' in self.rspec['tags']:
 271                 add_loopback = self.rspec['tags']['isolate_loopback'] != "1"
 272             self.set_ipaddresses_config(self.rspec['ip_addresses'], add_loopback)
 273
 274             #logger.log("sliver_vs: %s: Setting name to %s" % (self.name, self.slice_id))
 275             #self.setname(self.slice_id)
 276             #logger.log("sliver_vs: %s: Storing slice id of %s for PlanetFlow" % (self.name, self.slice_id))
 277             try:
 278                 vserver_config_path = '/etc/vservers/%s'%self.name
 279                 if not os.path.exists (vserver_config_path):
 280                     os.makedirs (vserver_config_path)
 281                 file('%s/slice_id'%vserver_config_path, 'w').write("%d\n"%self.slice_id)
 282                 logger.log("sliver_vs: Recorded slice id %d for slice %s"%(self.slice_id,self.name))
 283             except IOError,e:
 284                 logger.log("sliver_vs: Could not record slice_id for slice %s. Error: %s"%(self.name,str(e)))
 285             except Exception,e:
 286                 logger.log_exc("sliver_vs: Error recording slice id: %s"%str(e),name=self.name)
 287
 288
 289             if self.enabled == False:
 290                 self.enabled = True
 291                 self.start()
 292
 293             if False: # Does not work properly yet.
 294                 if self.have_limits_changed():
 295                     logger.log('sliver_vs: %s: limits have changed --- restarting' % self.name)
 296                     stopcount = 10
 297                     while self.is_running() and stopcount > 0:
 298                         self.stop()
 299                         delay = 1
 300                         time.sleep(delay)
 301                         stopcount = stopcount - 1
 302                     self.start()
 303
 304         else:  # tell vsh to disable remote login by setting CPULIMIT to 0
 305             logger.log('sliver_vs: %s: disabling remote login' % self.name)
 306             self.set_sched_config(0, 0)
 307             self.enabled = False
 308             self.stop()