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 time
  25 from threading import BoundedSemaphore
  26 import subprocess
  27
  28 # the util-vserver-pl module
  29 import vserver
  30
  31 import accounts
  32 import logger
  33 import tools
  34
  35 # special constant that tells vserver to keep its existing settings
  36 KEEP_LIMIT = vserver.VC_LIM_KEEP
  37
  38 # populate the sliver/vserver specific default allocations table,
  39 # which is used to look for slice attributes
  40 DEFAULT_ALLOCATION = {}
  41 for rlimit in vserver.RLIMITS.keys():
  42     rlim = rlimit.lower()
  43     DEFAULT_ALLOCATION["%s_min"%rlim]=KEEP_LIMIT
  44     DEFAULT_ALLOCATION["%s_soft"%rlim]=KEEP_LIMIT
  45     DEFAULT_ALLOCATION["%s_hard"%rlim]=KEEP_LIMIT
  46
  47 class Sliver_VS(accounts.Account, vserver.VServer):
  48     """This class wraps vserver.VServer to make its interface closer to what we need."""
  49
  50     SHELL = '/bin/vsh'
  51     TYPE = 'sliver.VServer'
  52     _init_disk_info_sem = BoundedSemaphore()
  53
  54     def __init__(self, rec):
  55         name=rec['name']
  56         logger.verbose ('sliver_vs: %s init'%name)
  57         try:
  58             logger.log("sliver_vs: %s: first chance..."%name)
  59             vserver.VServer.__init__(self, name,logfile='/var/log/nodemanager')
  60         except Exception, err:
  61             if not isinstance(err, vserver.NoSuchVServer):
  62                 # Probably a bad vserver or vserver configuration file
  63                 logger.log_exc("sliver_vs:__init__ (first chance) %s",name=name)
  64                 logger.log('sliver_vs: %s: recreating bad vserver' % name)
  65                 self.destroy(name)
  66             self.create(name, rec['vref'])
  67             logger.log("sliver_vs: %s: second chance..."%name)
  68             vserver.VServer.__init__(self, name,logfile='/var/log/nodemanager')
  69
  70         self.keys = ''
  71         self.rspec = {}
  72         self.slice_id = rec['slice_id']
  73         self.disk_usage_initialized = False
  74         self.initscript = ''
  75         self.enabled = True
  76         self.configure(rec)
  77
  78     @staticmethod
  79     def create(name, vref = None):
  80         logger.verbose('sliver_vs: %s: create'%name)
  81         if vref is None:
  82             logger.log("sliver_vs: %s: ERROR - no vref attached, this is unexpected"%(name))
  83             # added by caglar
  84             # band-aid for short period as old API doesn't have GetSliceFamily function
  85             #return
  86             vref = "planetlab-f8-i386"
  87
  88         # used to look in /etc/planetlab/family,
  89         # now relies on the 'GetSliceFamily' extra attribute in GetSlivers()
  90         # which for legacy is still exposed here as the 'vref' key
  91
  92         # check the template exists -- there's probably a better way..
  93         if not os.path.isdir ("/vservers/.vref/%s"%vref):
  94             logger.log ("sliver_vs: %s: ERROR Could not create sliver - vreference image %s not found"%(name,vref))
  95             return
  96
  97         # guess arch
  98         try:
  99             (x,y,arch)=vref.split('-')
 100         # mh, this of course applies when 'vref' is e.g. 'netflow'
 101         # and that's not quite right
 102         except:
 103             arch='i386'
 104
 105         def personality (arch):
 106             personality="linux32"
 107             if arch.find("64")>=0:
 108                 personality="linux64"
 109             return personality
 110
 111 #        logger.log_call(['/usr/sbin/vuseradd', '-t', vref, name, ], timeout=15*60)
 112         logger.log_call(['/bin/bash','-x','/usr/sbin/vuseradd', '-t', vref, name, ], timeout=15*60)
 113         # export slicename to the slice in /etc/slicename
 114         file('/vservers/%s/etc/slicename' % name, 'w').write(name)
 115         file('/vservers/%s/etc/slicefamily' % name, 'w').write(vref)
 116         # set personality: only if needed (if arch's differ)
 117         if tools.root_context_arch() != arch:
 118             file('/etc/vservers/%s/personality' % name, 'w').write(personality(arch)+"\n")
 119             logger.log('sliver_vs: %s: set personality to %s'%(name,personality(arch)))
 120
 121     @staticmethod
 122     def destroy(name):
 123 #        logger.log_call(['/usr/sbin/vuserdel', name, ])
 124         logger.log_call(['/bin/bash','-x','/usr/sbin/vuserdel', name, ])
 125
 126     def configure(self, rec):
 127         new_rspec = rec['_rspec']
 128         if new_rspec != self.rspec:
 129             self.rspec = new_rspec
 130             self.set_resources()
 131
 132         new_initscript = rec['initscript']
 133         if new_initscript != self.initscript:
 134             self.initscript = new_initscript
 135             # not used anymore, we always check against the installed script
 136             #self.initscriptchanged = True
 137             self.refresh_slice_vinit()
 138
 139         accounts.Account.configure(self, rec)  # install ssh keys
 140
 141     # unconditionnally install and enable the generic vinit script
 142     # mimicking chkconfig for enabling the generic vinit script
 143     # this is hardwired for runlevel 3
 144     def install_and_enable_vinit (self):
 145         vinit_source="/usr/share/NodeManager/sliver-initscripts/vinit"
 146         vinit_script="/vservers/%s/etc/rc.d/init.d/vinit"%self.name
 147         rc3_link="/vservers/%s/etc/rc.d/rc3.d/S99vinit"%self.name
 148         rc3_target="../init.d/vinit"
 149         # install in sliver
 150         body=file(vinit_source).read()
 151         if tools.replace_file_with_string(vinit_script,body,chmod=0755):
 152             logger.log("vsliver_vs: %s: installed generic vinit rc script"%self.name)
 153         # create symlink for runlevel 3
 154         if not os.path.islink(rc3_link):
 155             try:
 156                 logger.log("vsliver_vs: %s: creating runlevel3 symlink %s"%(self.name,rc3_link))
 157                 os.symlink(rc3_target,rc3_link)
 158             except:
 159                 logger.log_exc("vsliver_vs: %s: failed to create runlevel3 symlink %s"%rc3_link)
 160
 161     # this one checks for the existence of the slice initscript
 162     # install or remove the slice inistscript, as instructed by the initscript tag
 163     def refresh_slice_vinit(self):
 164         body=self.initscript
 165         sliver_initscript="/vservers/%s/etc/rc.d/init.d/vinit.slice"%self.name
 166         if tools.replace_file_with_string(sliver_initscript,body,remove_if_empty=True,chmod=0755):
 167             if body:
 168                 logger.log("vsliver_vs: %s: Installed new initscript in %s"%(self.name,sliver_initscript))
 169             else:
 170                 logger.log("vsliver_vs: %s: Removed obsolete initscript %s"%(self.name,sliver_initscript))
 171
 172     # bind mount root side dir to sliver side
 173     # needs to be done before sliver starts
 174     def expose_ssh_dir (self):
 175         try:
 176             root_ssh="/home/%s/.ssh"%self.name
 177             sliver_ssh="/vservers/%s/home/%s/.ssh"%(self.name,self.name)
 178             # any of both might not exist yet
 179             for path in [root_ssh,sliver_ssh]:
 180                 if not os.path.exists (path):
 181                     os.mkdir(path)
 182                 if not os.path.isdir (path):
 183                     raise Exception
 184             mounts=file('/proc/mounts').read()
 185             if mounts.find(sliver_ssh)<0:
 186                 # xxx perform mount
 187                 subprocess.call("mount --bind -o ro %s %s"%(root_ssh,sliver_ssh),shell=True)
 188                 logger.log("expose_ssh_dir: %s mounted into slice %s"%(root_ssh,self.name))
 189         except:
 190             logger.log_exc("expose_ssh_dir with slice %s failed"%self.name)
 191
 192     def start(self, delay=0):
 193         if self.rspec['enabled'] <= 0:
 194             logger.log('sliver_vs: not starting %s, is not enabled'%self.name)
 195         else:
 196             logger.log('sliver_vs: %s: starting in %d seconds' % (self.name, delay))
 197             time.sleep(delay)
 198             # the generic /etc/init.d/vinit script is permanently refreshed, and enabled
 199             self.install_and_enable_vinit()
 200             self.expose_ssh_dir()
 201             # if a change has occured in the slice initscript, reflect this in /etc/init.d/vinit.slice
 202             self.refresh_slice_vinit()
 203             child_pid = os.fork()
 204             if child_pid == 0:
 205                 # VServer.start calls fork() internally,
 206                 # so just close the nonstandard fds and fork once to avoid creating zombies
 207                 tools.close_nonstandard_fds()
 208                 vserver.VServer.start(self)
 209                 os._exit(0)
 210             else:
 211                 os.waitpid(child_pid, 0)
 212
 213     def stop(self):
 214         logger.log('sliver_vs: %s: stopping' % self.name)
 215         vserver.VServer.stop(self)
 216
 217     def is_running(self):
 218         return vserver.VServer.is_running(self)
 219
 220     def set_resources(self):
 221         disk_max = self.rspec['disk_max']
 222         logger.log('sliver_vs: %s: setting max disk usage to %d KiB' % (self.name, disk_max))
 223         try:  # if the sliver is over quota, .set_disk_limit will throw an exception
 224             if not self.disk_usage_initialized:
 225                 self.vm_running = False
 226                 Sliver_VS._init_disk_info_sem.acquire()
 227                 logger.log('sliver_vs: %s: computing disk usage: beginning' % self.name)
 228                 # init_disk_info is inherited from VServer
 229                 try: self.init_disk_info()
 230                 finally: Sliver_VS._init_disk_info_sem.release()
 231                 logger.log('sliver_vs: %s: computing disk usage: ended' % self.name)
 232                 self.disk_usage_initialized = True
 233             vserver.VServer.set_disklimit(self, max(disk_max, self.disk_blocks))
 234         except:
 235             logger.log_exc('sliver_vs: failed to set max disk usage',name=self.name)
 236
 237         # get/set the min/soft/hard values for all of the vserver
 238         # related RLIMITS.  Note that vserver currently only
 239         # implements support for hard limits.
 240         for limit in vserver.RLIMITS.keys():
 241             type = limit.lower()
 242             minimum  = self.rspec['%s_min'%type]
 243             soft = self.rspec['%s_soft'%type]
 244             hard = self.rspec['%s_hard'%type]
 245             update = self.set_rlimit(limit, hard, soft, minimum)
 246             if update:
 247                 logger.log('sliver_vs: %s: setting rlimit %s to (%d, %d, %d)'
 248                            % (self.name, type, hard, soft, minimum))
 249
 250         self.set_capabilities_config(self.rspec['capabilities'])
 251         if self.rspec['capabilities']:
 252             logger.log('sliver_vs: %s: setting capabilities to %s' % (self.name, self.rspec['capabilities']))
 253
 254         cpu_pct = self.rspec['cpu_pct']
 255         cpu_share = self.rspec['cpu_share']
 256
 257         count = 1
 258         for key in self.rspec.keys():
 259             if key.find('sysctl.') == 0:
 260                 sysctl=key.split('.')
 261                 try:
 262                     # /etc/vservers/<guest>/sysctl/<id>/
 263                     dirname = "/etc/vservers/%s/sysctl/%s" % (self.name, count)
 264                     try:
 265                         os.makedirs(dirname, 0755)
 266                     except:
 267                         pass
 268                     setting = open("%s/setting" % dirname, "w")
 269                     setting.write("%s\n" % key.lstrip("sysctl."))
 270                     setting.close()
 271                     value = open("%s/value" % dirname, "w")
 272                     value.write("%s\n" % self.rspec[key])
 273                     value.close()
 274                     count += 1
 275
 276                     logger.log("sliver_vs: %s: writing %s=%s"%(self.name,key,self.rspec[key]))
 277                 except IOError, e:
 278                     logger.log("sliver_vs: %s: could not set %s=%s"%(self.name,key,self.rspec[key]))
 279                     logger.log("sliver_vs: %s: error = %s"%(self.name,e))
 280
 281
 282         if self.rspec['enabled'] > 0:
 283             if cpu_pct > 0:
 284                 logger.log('sliver_vs: %s: setting cpu reservation to %d%%' % (self.name, cpu_pct))
 285             else:
 286                 cpu_pct = 0
 287
 288             if cpu_share > 0:
 289                 logger.log('sliver_vs: %s: setting cpu share to %d' % (self.name, cpu_share))
 290             else:
 291                 cpu_share = 0
 292
 293             self.set_sched_config(cpu_pct, cpu_share)
 294             # if IP address isn't set (even to 0.0.0.0), sliver won't be able to use network
 295             if self.rspec['ip_addresses'] != '0.0.0.0':
 296                 logger.log('sliver_vs: %s: setting IP address(es) to %s' % \
 297                 (self.name, self.rspec['ip_addresses']))
 298             self.set_ipaddresses_config(self.rspec['ip_addresses'])
 299
 300             #logger.log("sliver_vs: %s: Setting name to %s" % (self.name, self.slice_id))
 301             #self.setname(self.slice_id)
 302             #logger.log("sliver_vs: %s: Storing slice id of %s for PlanetFlow" % (self.name, self.slice_id))
 303             try:
 304                 vserver_config_path = '/etc/vservers/%s'%self.name
 305                 if not os.path.exists (vserver_config_path):
 306                     os.makedirs (vserver_config_path)
 307                 file('%s/slice_id'%vserver_config_path, 'w').write("%d\n"%self.slice_id)
 308                 logger.log("sliver_vs: Recorded slice id %d for slice %s"%(self.slice_id,self.name))
 309             except IOError,e:
 310                 logger.log("sliver_vs: Could not record slice_id for slice %s. Error: %s"%(self.name,str(e)))
 311             except Exception,e:
 312                 logger.log_exc("sliver_vs: Error recording slice id: %s"%str(e),name=self.name)
 313
 314
 315             if self.enabled == False:
 316                 self.enabled = True
 317                 self.start()
 318
 319             if False: # Does not work properly yet.
 320                 if self.have_limits_changed():
 321                     logger.log('sliver_vs: %s: limits have changed --- restarting' % self.name)
 322                     stopcount = 10
 323                     while self.is_running() and stopcount > 0:
 324                         self.stop()
 325                         delay = 1
 326                         time.sleep(delay)
 327                         stopcount = stopcount - 1
 328                     self.start()
 329
 330         else:  # tell vsh to disable remote login by setting CPULIMIT to 0
 331             logger.log('sliver_vs: %s: disabling remote login' % self.name)
 332             self.set_sched_config(0, 0)
 333             self.enabled = False
 334             self.stop()